management

Documentation

Overview

Package management provides an RPC wrapper for the native ContractManagement contract.

Safe methods are encapsulated in the ContractReader structure while Contract provides various methods to perform state-changing calls.

Index

• Variables
• type Actor
• type Contract
  • func New(actor Actor) *Contract
  • func (c *Contract) Deploy(exe *nef.File, manif *manifest.Manifest, data interface{}) (util.Uint256, uint32, error)
  • func (c *Contract) DeployTransaction(exe *nef.File, manif *manifest.Manifest, data interface{}) (*transaction.Transaction, error)
  • func (c *Contract) DeployUnsigned(exe *nef.File, manif *manifest.Manifest, data interface{}) (*transaction.Transaction, error)
  • func (c *Contract) SetMinimumDeploymentFee(value *big.Int) (util.Uint256, uint32, error)
  • func (c *Contract) SetMinimumDeploymentFeeTransaction(value *big.Int) (*transaction.Transaction, error)
  • func (c *Contract) SetMinimumDeploymentFeeUnsigned(value *big.Int) (*transaction.Transaction, error)
• type ContractReader
  • func NewReader(invoker Invoker) *ContractReader
  • func (c *ContractReader) GetContract(hash util.Uint160) (*state.Contract, error)
  • func (c *ContractReader) GetContractByID(id int32) (*state.Contract, error)
  • func (c *ContractReader) GetContractHashes() (*HashesIterator, error)
  • func (c *ContractReader) GetContractHashesExpanded(num int) ([]IDHash, error)
  • func (c *ContractReader) GetMinimumDeploymentFee() (*big.Int, error)
  • func (c *ContractReader) HasMethod(hash util.Uint160, method string, pcount int) (bool, error)
• type Event
• type HashesIterator
  • func (h *HashesIterator) Next(num int) ([]IDHash, error)
  • func (h *HashesIterator) Terminate() error
• type IDHash
• type Invoker

Variables

var Hash = state.CreateNativeContractHash(nativenames.Management)

Hash stores the hash of the native ContractManagement contract.

Types

type Actor

type Actor interface {
	Invoker

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

Actor is used by Contract to create and send transactions.

type Contract

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

Contract represents a ContractManagement contract client that can be used to invoke all of its methods except 'update' and 'destroy' because they can be called successfully only from the contract itself (that is doing an update or self-destruction).

func New

func New(actor Actor) *Contract

New creates an instance of Contract to perform actions using the given Actor.

func (*Contract) Deploy

func (c *Contract) Deploy(exe *nef.File, manif *manifest.Manifest, data interface{}) (util.Uint256, uint32, error)

Deploy creates and sends to the network a transaction that deploys the given contract (with the manifest provided), if data is not nil then it also added to the invocation and will be used for "_deploy" method invocation done by the ContractManagement contract. If successful, this method returns deployed contract state that can be retrieved from the stack after execution.

func (*Contract) DeployTransaction

func (c *Contract) DeployTransaction(exe *nef.File, manif *manifest.Manifest, data interface{}) (*transaction.Transaction, error)

DeployTransaction creates and returns a transaction that deploys the given contract (with the manifest provided), if data is not nil then it also added to the invocation and will be used for "_deploy" method invocation done by the ContractManagement contract. If successful, this method returns deployed contract state that can be retrieved from the stack after execution.

func (*Contract) DeployUnsigned

func (c *Contract) DeployUnsigned(exe *nef.File, manif *manifest.Manifest, data interface{}) (*transaction.Transaction, error)

DeployUnsigned creates and returns an unsigned transaction that deploys the given contract (with the manifest provided), if data is not nil then it also added to the invocation and will be used for "_deploy" method invocation done by the ContractManagement contract. If successful, this method returns deployed contract state that can be retrieved from the stack after execution.

func (*Contract) SetMinimumDeploymentFee

func (c *Contract) SetMinimumDeploymentFee(value *big.Int) (util.Uint256, uint32, error)

SetMinimumDeploymentFee creates and sends a transaction that changes the minimum GAS amount required to deploy a contract. This method can be called successfully only by the network's committee, so make sure you're using an appropriate Actor. This invocation returns nothing and is successful when transactions ends up in the HALT state.

func (*Contract) SetMinimumDeploymentFeeTransaction

func (c *Contract) SetMinimumDeploymentFeeTransaction(value *big.Int) (*transaction.Transaction, error)

SetMinimumDeploymentFeeTransaction creates a transaction that changes the minimum GAS amount required to deploy a contract. This method can be called successfully only by the network's committee, so make sure you're using an appropriate Actor. This invocation returns nothing and is successful when transactions ends up in the HALT state. The transaction returned is signed, but not sent to the network.

func (*Contract) SetMinimumDeploymentFeeUnsigned

func (c *Contract) SetMinimumDeploymentFeeUnsigned(value *big.Int) (*transaction.Transaction, error)

SetMinimumDeploymentFeeUnsigned creates a transaction that changes the minimum GAS amount required to deploy a contract. This method can be called successfully only by the network's committee, so make sure you're using an appropriate Actor. This invocation returns nothing and is successful when transactions ends up in the HALT state. The transaction returned is not signed.

type ContractReader

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

ContractReader provides an interface to call read-only ContractManagement contract's methods.

func NewReader

func NewReader(invoker Invoker) *ContractReader

NewReader creates an instance of ContractReader that can be used to read data from the contract.

func (*ContractReader) GetContract

func (c *ContractReader) GetContract(hash util.Uint160) (*state.Contract, error)

GetContract allows to get contract data from its hash. This method is mostly useful for historic invocations since for current contracts there is a direct getcontractstate RPC API that has more options and works faster than going via contract invocation.

func (*ContractReader) GetContractByID

func (c *ContractReader) GetContractByID(id int32) (*state.Contract, error)

GetContractByID allows to get contract data from its ID.

func (*ContractReader) GetContractHashes

func (c *ContractReader) GetContractHashes() (*HashesIterator, error)

GetContractHashes returns an iterator that allows to retrieve all ID-hash mappings for non-native contracts. It depends on the server to provide proper session-based iterator, but can also work with expanded one.

func (*ContractReader) GetContractHashesExpanded

func (c *ContractReader) GetContractHashesExpanded(num int) ([]IDHash, error)

GetContractHashesExpanded is similar to GetContractHashes (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 num 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) GetMinimumDeploymentFee

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

GetMinimumDeploymentFee returns the minimal amount of GAS needed to deploy a contract on the network.

func (*ContractReader) HasMethod

func (c *ContractReader) HasMethod(hash util.Uint160, method string, pcount int) (bool, error)

HasMethod checks if the contract specified has a method with the given name and number of parameters.

type Event

type Event struct {
	Hash util.Uint160
}

Event is the event emitted on contract deployment/update/destroy. Even though these events are different they all have the same field inside.

type HashesIterator

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

HashesIterator is used for iterating over GetContractHashes results.

func (*HashesIterator) Next

func (h *HashesIterator) Next(num int) ([]IDHash, error)

Next returns the next set of elements from the iterator (up to num of them). It can return less than num elements in case iterator doesn't have that many or zero elements if the iterator has no more elements or the session is expired.

func (*HashesIterator) Terminate

func (h *HashesIterator) Terminate() error

Terminate closes the iterator session used by HashesIterator (if it's session-based).

type IDHash

type IDHash struct {
	ID   int32
	Hash util.Uint160
}

IDHash is an ID/Hash pair returned by the iterator from the GetContractHashes method.

type Invoker

type Invoker interface {
	Call(contract util.Uint160, operation string, params ...interface{}) (*result.Invoke, error)
	CallAndExpandIterator(contract util.Uint160, method string, maxItems int, params ...interface{}) (*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 methods.