container

package
v0.21.0-rc.3 Latest Latest
Warning

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

 Go to latest Published: Nov 19, 2024 License: GPL-3.0 Imports: 11 Imported by: 0

Documentation

Overview

Package container contains RPC wrappers for Container contract.

Index

Constants

This section is empty.

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 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) Delete 

func (c *Contract) Delete(containerID []byte, signature []byte, publicKey *keys.PublicKey, 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, publicKey *keys.PublicKey, 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, publicKey *keys.PublicKey, 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) 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) 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) 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) Update 

func (c *Contract) Update(script []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(script []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(script []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) 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) DeletionInfo 

func (c *ContractReader) DeletionInfo(containerID []byte) ([]stackitem.Item, error)

DeletionInfo invokes `deletionInfo` method of contract.

func (*ContractReader) EACL 

func (c *ContractReader) EACL(containerID []byte) ([]stackitem.Item, error)

EACL invokes `eACL` method of contract.

func (*ContractReader) Get 

func (c *ContractReader) Get(containerID []byte) ([]stackitem.Item, error)

Get invokes `get` method of contract.

func (*ContractReader) GetContainerSize 

func (c *ContractReader) GetContainerSize(id []byte) ([]stackitem.Item, error)

GetContainerSize invokes `getContainerSize` method of contract.

func (*ContractReader) IterateContainerSizes 

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

IterateContainerSizes invokes `iterateContainerSizes` method of contract.

func (*ContractReader) IterateContainerSizesExpanded 

func (c *ContractReader) IterateContainerSizesExpanded(epoch *big.Int, _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) ([]stackitem.Item, error)

List invokes `list` method of contract.

func (*ContractReader) ListContainerSizes 

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

ListContainerSizes invokes `listContainerSizes` method of contract.

func (*ContractReader) Owner 

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

Owner invokes `owner` method of contract.

func (*ContractReader) Version 

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

Version invokes `version` method of contract.

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 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 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 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.