container

package
v0.23.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 10, 2025 License: GPL-3.0, Apache-2.0 Imports: 13 Imported by: 4

Documentation

Overview

Package container contains RPC wrappers for NeoFS Container contract.

Index

Constants

View Source 
const (
	// RegistrationFeeKey is a key in netmap config which contains fee for container registration.
	RegistrationFeeKey = containerconst.RegistrationFeeKey
	// AliasFeeKey is a key in netmap config which contains fee for nice-name registration.
	AliasFeeKey = containerconst.AliasFeeKey

	// CleanupDelta contains the number of the last epochs for which container estimations are present.
	CleanupDelta = containerconst.CleanupDelta
	// TotalCleanupDelta contains the number of the epochs after which estimation
	// will be removed by epoch tick cleanup if any of the nodes hasn't updated
	// container size and/or container has been removed. It must be greater than CleanupDelta.
	TotalCleanupDelta = containerconst.TotalCleanupDelta

	// NotFoundError is returned if container is missing.
	NotFoundError = containerconst.NotFoundError
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Actor 

type Actor interface {
	Invoker

	MakeCall(contract util.Uint160, method string, params ...any) (*transaction.Transaction, error)
	MakeRun(script []byte) (*transaction.Transaction, error)
	MakeUnsignedCall(contract util.Uint160, method string, attrs []transaction.Attribute, params ...any) (*transaction.Transaction, error)
	MakeUnsignedRun(script []byte, attrs []transaction.Attribute) (*transaction.Transaction, error)
	SendCall(contract util.Uint160, method string, params ...any) (util.Uint256, uint32, error)
	SendRun(script []byte) (util.Uint256, uint32, error)
}

Actor is used by Contract to call state-changing methods.

type ContainerContainer 

type ContainerContainer struct {
	Value []byte
	Sig   []byte
	Pub   *keys.PublicKey
	Token []byte
}

ContainerContainer is a contract-specific container.Container type used by its methods.

func (*ContainerContainer) FromStackItem 

func (res *ContainerContainer) FromStackItem(item stackitem.Item) error

FromStackItem retrieves fields of ContainerContainer from the given stackitem.Item or returns an error if it's not possible to do to so. It implements stackitem.Convertible interface.

func (*ContainerContainer) ToSCParameter added in v0.21.0 

func (res *ContainerContainer) ToSCParameter() (smartcontract.Parameter, error)

ToSCParameter creates smartcontract.Parameter representing ContainerContainer. It implements smartcontract.Convertible interface so that ContainerContainer could be used with invokers.

func (*ContainerContainer) ToStackItem added in v0.21.0 

func (res *ContainerContainer) ToStackItem() (stackitem.Item, error)

ToStackItem creates stackitem.Item representing ContainerContainer. It implements stackitem.Convertible interface.

type ContainerContainerSizes 

type ContainerContainerSizes struct {
	CID         []byte
	Estimations []*ContainerEstimation
}

ContainerContainerSizes is a contract-specific container.ContainerSizes type used by its methods.

func (*ContainerContainerSizes) FromStackItem 

func (res *ContainerContainerSizes) FromStackItem(item stackitem.Item) error

FromStackItem retrieves fields of ContainerContainerSizes from the given stackitem.Item or returns an error if it's not possible to do to so. It implements stackitem.Convertible interface.

func (*ContainerContainerSizes) ToSCParameter added in v0.21.0 

func (res *ContainerContainerSizes) ToSCParameter() (smartcontract.Parameter, error)

ToSCParameter creates smartcontract.Parameter representing ContainerContainerSizes. It implements smartcontract.Convertible interface so that ContainerContainerSizes could be used with invokers.

func (*ContainerContainerSizes) ToStackItem added in v0.21.0 

func (res *ContainerContainerSizes) ToStackItem() (stackitem.Item, error)

ToStackItem creates stackitem.Item representing ContainerContainerSizes. It implements stackitem.Convertible interface.

type ContainerEstimation 

type ContainerEstimation struct {
	From *keys.PublicKey
	Size *big.Int
}

ContainerEstimation is a contract-specific container.Estimation type used by its methods.

func (*ContainerEstimation) FromStackItem 

func (res *ContainerEstimation) FromStackItem(item stackitem.Item) error

FromStackItem retrieves fields of ContainerEstimation from the given stackitem.Item or returns an error if it's not possible to do to so. It implements stackitem.Convertible interface.

func (*ContainerEstimation) ToSCParameter added in v0.21.0 

func (res *ContainerEstimation) ToSCParameter() (smartcontract.Parameter, error)

ToSCParameter creates smartcontract.Parameter representing ContainerEstimation. It implements smartcontract.Convertible interface so that ContainerEstimation could be used with invokers.

func (*ContainerEstimation) ToStackItem added in v0.21.0 

func (res *ContainerEstimation) ToStackItem() (stackitem.Item, error)

ToStackItem creates stackitem.Item representing ContainerEstimation. It implements stackitem.Convertible interface.

type ContainerExtendedACL 

type ContainerExtendedACL struct {
	Value []byte
	Sig   []byte
	Pub   *keys.PublicKey
	Token []byte
}

ContainerExtendedACL is a contract-specific container.ExtendedACL type used by its methods.

func (*ContainerExtendedACL) FromStackItem 

func (res *ContainerExtendedACL) FromStackItem(item stackitem.Item) error

FromStackItem retrieves fields of ContainerExtendedACL from the given stackitem.Item or returns an error if it's not possible to do to so. It implements stackitem.Convertible interface.

func (*ContainerExtendedACL) ToSCParameter added in v0.21.0 

func (res *ContainerExtendedACL) ToSCParameter() (smartcontract.Parameter, error)

ToSCParameter creates smartcontract.Parameter representing ContainerExtendedACL. It implements smartcontract.Convertible interface so that ContainerExtendedACL could be used with invokers.

func (*ContainerExtendedACL) ToStackItem added in v0.21.0 

func (res *ContainerExtendedACL) ToStackItem() (stackitem.Item, error)

ToStackItem creates stackitem.Item representing ContainerExtendedACL. It implements stackitem.Convertible interface.

type Contract 

type Contract struct {
	ContractReader
	// contains filtered or unexported fields
}

Contract implements all contract methods.

func New 

func New(actor Actor, hash util.Uint160) *Contract

New creates an instance of Contract using provided contract hash and the given Actor.

func (*Contract) AddNextEpochNodes added in v0.21.0 

func (c *Contract) AddNextEpochNodes(cID util.Uint256, placementVector *big.Int, publicKeys keys.PublicKeys) (util.Uint256, uint32, error)

AddNextEpochNodes creates a transaction invoking `addNextEpochNodes` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) AddNextEpochNodesTransaction added in v0.21.0 

func (c *Contract) AddNextEpochNodesTransaction(cID util.Uint256, placementVector *big.Int, publicKeys keys.PublicKeys) (*transaction.Transaction, error)

AddNextEpochNodesTransaction creates a transaction invoking `addNextEpochNodes` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) AddNextEpochNodesUnsigned added in v0.21.0 

func (c *Contract) AddNextEpochNodesUnsigned(cID util.Uint256, placementVector *big.Int, publicKeys keys.PublicKeys) (*transaction.Transaction, error)

AddNextEpochNodesUnsigned creates a transaction invoking `addNextEpochNodes` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) CommitContainerListUpdate added in v0.21.0 

func (c *Contract) CommitContainerListUpdate(cID util.Uint256, replicas []byte) (util.Uint256, uint32, error)

CommitContainerListUpdate creates a transaction invoking `commitContainerListUpdate` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) CommitContainerListUpdateTransaction added in v0.21.0 

func (c *Contract) CommitContainerListUpdateTransaction(cID util.Uint256, replicas []byte) (*transaction.Transaction, error)

CommitContainerListUpdateTransaction creates a transaction invoking `commitContainerListUpdate` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) CommitContainerListUpdateUnsigned added in v0.21.0 

func (c *Contract) CommitContainerListUpdateUnsigned(cID util.Uint256, replicas []byte) (*transaction.Transaction, error)

CommitContainerListUpdateUnsigned creates a transaction invoking `commitContainerListUpdate` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) Create added in v0.22.0 

func (c *Contract) Create(cnr []byte, invocScript []byte, verifScript []byte, sessionToken []byte, name string, zone string, metaOnChain bool) (util.Uint256, uint32, error)

Create creates a transaction invoking `create` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) CreateTransaction added in v0.22.0 

func (c *Contract) CreateTransaction(cnr []byte, invocScript []byte, verifScript []byte, sessionToken []byte, name string, zone string, metaOnChain bool) (*transaction.Transaction, error)

CreateTransaction creates a transaction invoking `create` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) CreateUnsigned added in v0.22.0 

func (c *Contract) CreateUnsigned(cnr []byte, invocScript []byte, verifScript []byte, sessionToken []byte, name string, zone string, metaOnChain bool) (*transaction.Transaction, error)

CreateUnsigned creates a transaction invoking `create` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) Delete 

func (c *Contract) Delete(containerID []byte, signature []byte, token []byte) (util.Uint256, uint32, error)

Delete creates a transaction invoking `delete` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) DeleteTransaction 

func (c *Contract) DeleteTransaction(containerID []byte, signature []byte, token []byte) (*transaction.Transaction, error)

DeleteTransaction creates a transaction invoking `delete` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) DeleteUnsigned 

func (c *Contract) DeleteUnsigned(containerID []byte, signature []byte, token []byte) (*transaction.Transaction, error)

DeleteUnsigned creates a transaction invoking `delete` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) NewEpoch 

func (c *Contract) NewEpoch(epochNum *big.Int) (util.Uint256, uint32, error)

NewEpoch creates a transaction invoking `newEpoch` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) NewEpochTransaction 

func (c *Contract) NewEpochTransaction(epochNum *big.Int) (*transaction.Transaction, error)

NewEpochTransaction creates a transaction invoking `newEpoch` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) NewEpochUnsigned 

func (c *Contract) NewEpochUnsigned(epochNum *big.Int) (*transaction.Transaction, error)

NewEpochUnsigned creates a transaction invoking `newEpoch` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) Put 

func (c *Contract) Put(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte) (util.Uint256, uint32, error)

Put creates a transaction invoking `put` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) Put2 added in v0.21.0 

func (c *Contract) Put2(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string, metaOnChain bool) (util.Uint256, uint32, error)

Put2 creates a transaction invoking `put` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) Put2Transaction added in v0.21.0 

func (c *Contract) Put2Transaction(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string, metaOnChain bool) (*transaction.Transaction, error)

Put2Transaction creates a transaction invoking `put` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) Put2Unsigned added in v0.21.0 

func (c *Contract) Put2Unsigned(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string, metaOnChain bool) (*transaction.Transaction, error)

Put2Unsigned creates a transaction invoking `put` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) Put3 added in v0.21.0 

func (c *Contract) Put3(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string) (util.Uint256, uint32, error)

Put3 creates a transaction invoking `put` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) Put3Transaction added in v0.21.0 

func (c *Contract) Put3Transaction(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string) (*transaction.Transaction, error)

Put3Transaction creates a transaction invoking `put` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) Put3Unsigned added in v0.21.0 

func (c *Contract) Put3Unsigned(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string) (*transaction.Transaction, error)

Put3Unsigned creates a transaction invoking `put` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) PutContainerSize 

func (c *Contract) PutContainerSize(epoch *big.Int, cid []byte, usedSize *big.Int, pubKey *keys.PublicKey) (util.Uint256, uint32, error)

PutContainerSize creates a transaction invoking `putContainerSize` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) PutContainerSizeTransaction 

func (c *Contract) PutContainerSizeTransaction(epoch *big.Int, cid []byte, usedSize *big.Int, pubKey *keys.PublicKey) (*transaction.Transaction, error)

PutContainerSizeTransaction creates a transaction invoking `putContainerSize` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) PutContainerSizeUnsigned 

func (c *Contract) PutContainerSizeUnsigned(epoch *big.Int, cid []byte, usedSize *big.Int, pubKey *keys.PublicKey) (*transaction.Transaction, error)

PutContainerSizeUnsigned creates a transaction invoking `putContainerSize` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) PutEACL added in v0.22.0 

func (c *Contract) PutEACL(eACL []byte, invocScript []byte, verifScript []byte, sessionToken []byte) (util.Uint256, uint32, error)

PutEACL creates a transaction invoking `putEACL` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) PutEACLTransaction added in v0.22.0 

func (c *Contract) PutEACLTransaction(eACL []byte, invocScript []byte, verifScript []byte, sessionToken []byte) (*transaction.Transaction, error)

PutEACLTransaction creates a transaction invoking `putEACL` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) PutEACLUnsigned added in v0.22.0 

func (c *Contract) PutEACLUnsigned(eACL []byte, invocScript []byte, verifScript []byte, sessionToken []byte) (*transaction.Transaction, error)

PutEACLUnsigned creates a transaction invoking `putEACL` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) PutNamed 

func (c *Contract) PutNamed(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string) (util.Uint256, uint32, error)

PutNamed creates a transaction invoking `putNamed` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) PutNamedTransaction 

func (c *Contract) PutNamedTransaction(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string) (*transaction.Transaction, error)

PutNamedTransaction creates a transaction invoking `putNamed` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) PutNamedUnsigned 

func (c *Contract) PutNamedUnsigned(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte, name string, zone string) (*transaction.Transaction, error)

PutNamedUnsigned creates a transaction invoking `putNamed` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) PutTransaction 

func (c *Contract) PutTransaction(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte) (*transaction.Transaction, error)

PutTransaction creates a transaction invoking `put` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) PutUnsigned 

func (c *Contract) PutUnsigned(container []byte, signature []byte, publicKey *keys.PublicKey, token []byte) (*transaction.Transaction, error)

PutUnsigned creates a transaction invoking `put` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) Remove added in v0.22.0 

func (c *Contract) Remove(id []byte, invocScript []byte, verifScript []byte, sessionToken []byte) (util.Uint256, uint32, error)

Remove creates a transaction invoking `remove` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) RemoveTransaction added in v0.22.0 

func (c *Contract) RemoveTransaction(id []byte, invocScript []byte, verifScript []byte, sessionToken []byte) (*transaction.Transaction, error)

RemoveTransaction creates a transaction invoking `remove` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) RemoveUnsigned added in v0.22.0 

func (c *Contract) RemoveUnsigned(id []byte, invocScript []byte, verifScript []byte, sessionToken []byte) (*transaction.Transaction, error)

RemoveUnsigned creates a transaction invoking `remove` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) SetEACL 

func (c *Contract) SetEACL(eACL []byte, signature []byte, publicKey *keys.PublicKey, token []byte) (util.Uint256, uint32, error)

SetEACL creates a transaction invoking `setEACL` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) SetEACLTransaction 

func (c *Contract) SetEACLTransaction(eACL []byte, signature []byte, publicKey *keys.PublicKey, token []byte) (*transaction.Transaction, error)

SetEACLTransaction creates a transaction invoking `setEACL` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) SetEACLUnsigned 

func (c *Contract) SetEACLUnsigned(eACL []byte, signature []byte, publicKey *keys.PublicKey, token []byte) (*transaction.Transaction, error)

SetEACLUnsigned creates a transaction invoking `setEACL` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) StartContainerEstimation 

func (c *Contract) StartContainerEstimation(epoch *big.Int) (util.Uint256, uint32, error)

StartContainerEstimation creates a transaction invoking `startContainerEstimation` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) StartContainerEstimationTransaction 

func (c *Contract) StartContainerEstimationTransaction(epoch *big.Int) (*transaction.Transaction, error)

StartContainerEstimationTransaction creates a transaction invoking `startContainerEstimation` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) StartContainerEstimationUnsigned 

func (c *Contract) StartContainerEstimationUnsigned(epoch *big.Int) (*transaction.Transaction, error)

StartContainerEstimationUnsigned creates a transaction invoking `startContainerEstimation` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) StopContainerEstimation 

func (c *Contract) StopContainerEstimation(epoch *big.Int) (util.Uint256, uint32, error)

StopContainerEstimation creates a transaction invoking `stopContainerEstimation` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) StopContainerEstimationTransaction 

func (c *Contract) StopContainerEstimationTransaction(epoch *big.Int) (*transaction.Transaction, error)

StopContainerEstimationTransaction creates a transaction invoking `stopContainerEstimation` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) StopContainerEstimationUnsigned 

func (c *Contract) StopContainerEstimationUnsigned(epoch *big.Int) (*transaction.Transaction, error)

StopContainerEstimationUnsigned creates a transaction invoking `stopContainerEstimation` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) SubmitObjectPut added in v0.21.0 

func (c *Contract) SubmitObjectPut(metaInformation []byte, sigs [][][]byte) (util.Uint256, uint32, error)

SubmitObjectPut creates a transaction invoking `submitObjectPut` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) SubmitObjectPutTransaction added in v0.21.0 

func (c *Contract) SubmitObjectPutTransaction(metaInformation []byte, sigs [][][]byte) (*transaction.Transaction, error)

SubmitObjectPutTransaction creates a transaction invoking `submitObjectPut` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) SubmitObjectPutUnsigned added in v0.21.0 

func (c *Contract) SubmitObjectPutUnsigned(metaInformation []byte, sigs [][][]byte) (*transaction.Transaction, error)

SubmitObjectPutUnsigned creates a transaction invoking `submitObjectPut` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

func (*Contract) Update 

func (c *Contract) Update(nefFile []byte, manifest []byte, data any) (util.Uint256, uint32, error)

Update creates a transaction invoking `update` method of the contract. This transaction is signed and immediately sent to the network. The values returned are its hash, ValidUntilBlock value and error if any.

func (*Contract) UpdateTransaction 

func (c *Contract) UpdateTransaction(nefFile []byte, manifest []byte, data any) (*transaction.Transaction, error)

UpdateTransaction creates a transaction invoking `update` method of the contract. This transaction is signed, but not sent to the network, instead it's returned to the caller.

func (*Contract) UpdateUnsigned 

func (c *Contract) UpdateUnsigned(nefFile []byte, manifest []byte, data any) (*transaction.Transaction, error)

UpdateUnsigned creates a transaction invoking `update` method of the contract. This transaction is not signed, it's simply returned to the caller. Any fields of it that do not affect fees can be changed (ValidUntilBlock, Nonce), fee values (NetworkFee, SystemFee) can be increased as well.

type ContractReader 

type ContractReader struct {
	// contains filtered or unexported fields
}

ContractReader implements safe contract methods.

func NewReader 

func NewReader(invoker Invoker, hash util.Uint160) *ContractReader

NewReader creates an instance of ContractReader using provided contract hash and the given Invoker.

func (*ContractReader) Alias 

func (c *ContractReader) Alias(cid []byte) (string, error)

Alias invokes `alias` method of contract.

func (*ContractReader) ContainersOf 

func (c *ContractReader) ContainersOf(owner []byte) (uuid.UUID, result.Iterator, error)

ContainersOf invokes `containersOf` method of contract.

func (*ContractReader) ContainersOfExpanded 

func (c *ContractReader) ContainersOfExpanded(owner []byte, _numOfIteratorItems int) ([]stackitem.Item, error)

ContainersOfExpanded is similar to ContainersOf (uses the same contract method), but can be useful if the server used doesn't support sessions and doesn't expand iterators. It creates a script that will get the specified number of result items from the iterator right in the VM and return them to you. It's only limited by VM stack and GAS available for RPC invocations.

func (*ContractReader) Count 

func (c *ContractReader) Count() (*big.Int, error)

Count invokes `count` method of contract.

func (*ContractReader) EACL 

func (c *ContractReader) EACL(containerID []byte) (*ContainerExtendedACL, error)

EACL invokes `eACL` method of contract.

func (*ContractReader) Get 

func (c *ContractReader) Get(containerID []byte) (*ContainerContainer, error)

Get invokes `get` method of contract.

func (*ContractReader) GetContainerData added in v0.22.0 

func (c *ContractReader) GetContainerData(id []byte) ([]byte, error)

GetContainerData invokes `getContainerData` method of contract.

func (*ContractReader) GetContainerSize 

func (c *ContractReader) GetContainerSize(id []byte) (*ContainerContainerSizes, error)

GetContainerSize invokes `getContainerSize` method of contract.

func (*ContractReader) GetEACLData added in v0.22.0 

func (c *ContractReader) GetEACLData(id []byte) ([]byte, error)

GetEACLData invokes `getEACLData` method of contract.

func (*ContractReader) IterateAllContainerSizes 

func (c *ContractReader) IterateAllContainerSizes(epoch *big.Int) (uuid.UUID, result.Iterator, error)

IterateAllContainerSizes invokes `iterateAllContainerSizes` method of contract.

func (*ContractReader) IterateAllContainerSizesExpanded 

func (c *ContractReader) IterateAllContainerSizesExpanded(epoch *big.Int, _numOfIteratorItems int) ([]stackitem.Item, error)

IterateAllContainerSizesExpanded is similar to IterateAllContainerSizes (uses the same contract method), but can be useful if the server used doesn't support sessions and doesn't expand iterators. It creates a script that will get the specified number of result items from the iterator right in the VM and return them to you. It's only limited by VM stack and GAS available for RPC invocations.

func (*ContractReader) IterateContainerSizes 

func (c *ContractReader) IterateContainerSizes(epoch *big.Int, cid util.Uint256) (uuid.UUID, result.Iterator, error)

IterateContainerSizes invokes `iterateContainerSizes` method of contract.

func (*ContractReader) IterateContainerSizesExpanded 

func (c *ContractReader) IterateContainerSizesExpanded(epoch *big.Int, cid util.Uint256, _numOfIteratorItems int) ([]stackitem.Item, error)

IterateContainerSizesExpanded is similar to IterateContainerSizes (uses the same contract method), but can be useful if the server used doesn't support sessions and doesn't expand iterators. It creates a script that will get the specified number of result items from the iterator right in the VM and return them to you. It's only limited by VM stack and GAS available for RPC invocations.

func (*ContractReader) List 

func (c *ContractReader) List(owner []byte) ([][]byte, error)

List invokes `list` method of contract.

func (*ContractReader) ListContainerSizes 

func (c *ContractReader) ListContainerSizes(epoch *big.Int) ([][]byte, error)

ListContainerSizes invokes `listContainerSizes` method of contract.

func (*ContractReader) Nodes added in v0.21.0 

func (c *ContractReader) Nodes(cID util.Uint256, placementVector *big.Int) (uuid.UUID, result.Iterator, error)

Nodes invokes `nodes` method of contract.

func (*ContractReader) NodesExpanded added in v0.21.0 

func (c *ContractReader) NodesExpanded(cID util.Uint256, placementVector *big.Int, _numOfIteratorItems int) ([]stackitem.Item, error)

NodesExpanded is similar to Nodes (uses the same contract method), but can be useful if the server used doesn't support sessions and doesn't expand iterators. It creates a script that will get the specified number of result items from the iterator right in the VM and return them to you. It's only limited by VM stack and GAS available for RPC invocations.

func (*ContractReader) Owner 

func (c *ContractReader) Owner(containerID []byte) ([]byte, error)

Owner invokes `owner` method of contract.

func (*ContractReader) ReplicasNumbers added in v0.21.0 

func (c *ContractReader) ReplicasNumbers(cID util.Uint256) (uuid.UUID, result.Iterator, error)

ReplicasNumbers invokes `replicasNumbers` method of contract.

func (*ContractReader) ReplicasNumbersExpanded added in v0.21.0 

func (c *ContractReader) ReplicasNumbersExpanded(cID util.Uint256, _numOfIteratorItems int) ([]stackitem.Item, error)

ReplicasNumbersExpanded is similar to ReplicasNumbers (uses the same contract method), but can be useful if the server used doesn't support sessions and doesn't expand iterators. It creates a script that will get the specified number of result items from the iterator right in the VM and return them to you. It's only limited by VM stack and GAS available for RPC invocations.

func (*ContractReader) VerifyPlacementSignatures added in v0.21.0 

func (c *ContractReader) VerifyPlacementSignatures(cid util.Uint256, msg []byte, sigs [][][]byte) (bool, error)

VerifyPlacementSignatures invokes `verifyPlacementSignatures` method of contract.

func (*ContractReader) Version 

func (c *ContractReader) Version() (*big.Int, error)

Version invokes `version` method of contract.

type CreatedEvent added in v0.22.0 

type CreatedEvent struct {
	ContainerID util.Uint256
	Owner       []byte
}

CreatedEvent represents "Created" event emitted by the contract.

func CreatedEventsFromApplicationLog added in v0.22.0 

func CreatedEventsFromApplicationLog(log *result.ApplicationLog) ([]*CreatedEvent, error)

CreatedEventsFromApplicationLog retrieves a set of all emitted events with "Created" name from the provided result.ApplicationLog.

func (*CreatedEvent) FromStackItem added in v0.22.0 

func (e *CreatedEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to CreatedEvent or returns an error if it's not possible to do to so.

type DeleteSuccessEvent 

type DeleteSuccessEvent struct {
	ContainerID []byte
}

DeleteSuccessEvent represents "DeleteSuccess" event emitted by the contract.

func DeleteSuccessEventsFromApplicationLog 

func DeleteSuccessEventsFromApplicationLog(log *result.ApplicationLog) ([]*DeleteSuccessEvent, error)

DeleteSuccessEventsFromApplicationLog retrieves a set of all emitted events with "DeleteSuccess" name from the provided result.ApplicationLog.

func (*DeleteSuccessEvent) FromStackItem 

func (e *DeleteSuccessEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to DeleteSuccessEvent or returns an error if it's not possible to do to so.

type EACLChangedEvent added in v0.22.0 

type EACLChangedEvent struct {
	ContainerID util.Uint256
}

EACLChangedEvent represents "EACLChanged" event emitted by the contract.

func EACLChangedEventsFromApplicationLog added in v0.22.0 

func EACLChangedEventsFromApplicationLog(log *result.ApplicationLog) ([]*EACLChangedEvent, error)

EACLChangedEventsFromApplicationLog retrieves a set of all emitted events with "EACLChanged" name from the provided result.ApplicationLog.

func (*EACLChangedEvent) FromStackItem added in v0.22.0 

func (e *EACLChangedEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to EACLChangedEvent or returns an error if it's not possible to do to so.

type Invoker 

type Invoker interface {
	Call(contract util.Uint160, operation string, params ...any) (*result.Invoke, error)
	CallAndExpandIterator(contract util.Uint160, method string, maxItems int, params ...any) (*result.Invoke, error)
	TerminateSession(sessionID uuid.UUID) error
	TraverseIterator(sessionID uuid.UUID, iterator *result.Iterator, num int) ([]stackitem.Item, error)
}

Invoker is used by ContractReader to call various safe methods.

type NodesUpdateEvent added in v0.21.0 

type NodesUpdateEvent struct {
	ContainerID util.Uint256
}

NodesUpdateEvent represents "NodesUpdate" event emitted by the contract.

func NodesUpdateEventsFromApplicationLog added in v0.21.0 

func NodesUpdateEventsFromApplicationLog(log *result.ApplicationLog) ([]*NodesUpdateEvent, error)

NodesUpdateEventsFromApplicationLog retrieves a set of all emitted events with "NodesUpdate" name from the provided result.ApplicationLog.

func (*NodesUpdateEvent) FromStackItem added in v0.21.0 

func (e *NodesUpdateEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to NodesUpdateEvent or returns an error if it's not possible to do to so.

type ObjectPutEvent added in v0.21.0 

type ObjectPutEvent struct {
	ContainerID util.Uint256
	ObjectID    util.Uint256
	Meta        map[any]any
}

ObjectPutEvent represents "ObjectPut" event emitted by the contract.

func ObjectPutEventsFromApplicationLog added in v0.21.0 

func ObjectPutEventsFromApplicationLog(log *result.ApplicationLog) ([]*ObjectPutEvent, error)

ObjectPutEventsFromApplicationLog retrieves a set of all emitted events with "ObjectPut" name from the provided result.ApplicationLog.

func (*ObjectPutEvent) FromStackItem added in v0.21.0 

func (e *ObjectPutEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to ObjectPutEvent or returns an error if it's not possible to do to so.

type PutSuccessEvent 

type PutSuccessEvent struct {
	ContainerID util.Uint256
	PublicKey   *keys.PublicKey
}

PutSuccessEvent represents "PutSuccess" event emitted by the contract.

func PutSuccessEventsFromApplicationLog 

func PutSuccessEventsFromApplicationLog(log *result.ApplicationLog) ([]*PutSuccessEvent, error)

PutSuccessEventsFromApplicationLog retrieves a set of all emitted events with "PutSuccess" name from the provided result.ApplicationLog.

func (*PutSuccessEvent) FromStackItem 

func (e *PutSuccessEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to PutSuccessEvent or returns an error if it's not possible to do to so.

type RemovedEvent added in v0.22.0 

type RemovedEvent struct {
	ContainerID util.Uint256
	Owner       []byte
}

RemovedEvent represents "Removed" event emitted by the contract.

func RemovedEventsFromApplicationLog added in v0.22.0 

func RemovedEventsFromApplicationLog(log *result.ApplicationLog) ([]*RemovedEvent, error)

RemovedEventsFromApplicationLog retrieves a set of all emitted events with "Removed" name from the provided result.ApplicationLog.

func (*RemovedEvent) FromStackItem added in v0.22.0 

func (e *RemovedEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to RemovedEvent or returns an error if it's not possible to do to so.

type SetEACLSuccessEvent 

type SetEACLSuccessEvent struct {
	ContainerID []byte
	PublicKey   *keys.PublicKey
}

SetEACLSuccessEvent represents "SetEACLSuccess" event emitted by the contract.

func SetEACLSuccessEventsFromApplicationLog 

func SetEACLSuccessEventsFromApplicationLog(log *result.ApplicationLog) ([]*SetEACLSuccessEvent, error)

SetEACLSuccessEventsFromApplicationLog retrieves a set of all emitted events with "SetEACLSuccess" name from the provided result.ApplicationLog.

func (*SetEACLSuccessEvent) FromStackItem 

func (e *SetEACLSuccessEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to SetEACLSuccessEvent or returns an error if it's not possible to do to so.

type StartEstimationEvent 

type StartEstimationEvent struct {
	Epoch *big.Int
}

StartEstimationEvent represents "StartEstimation" event emitted by the contract.

func StartEstimationEventsFromApplicationLog 

func StartEstimationEventsFromApplicationLog(log *result.ApplicationLog) ([]*StartEstimationEvent, error)

StartEstimationEventsFromApplicationLog retrieves a set of all emitted events with "StartEstimation" name from the provided result.ApplicationLog.

func (*StartEstimationEvent) FromStackItem 

func (e *StartEstimationEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to StartEstimationEvent or returns an error if it's not possible to do to so.

type StopEstimationEvent 

type StopEstimationEvent struct {
	Epoch *big.Int
}

StopEstimationEvent represents "StopEstimation" event emitted by the contract.

func StopEstimationEventsFromApplicationLog 

func StopEstimationEventsFromApplicationLog(log *result.ApplicationLog) ([]*StopEstimationEvent, error)

StopEstimationEventsFromApplicationLog retrieves a set of all emitted events with "StopEstimation" name from the provided result.ApplicationLog.

func (*StopEstimationEvent) FromStackItem 

func (e *StopEstimationEvent) FromStackItem(item *stackitem.Array) error

FromStackItem converts provided stackitem.Array to StopEstimationEvent or returns an error if it's not possible to do to so.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.