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) GetMinimumDeploymentFee() (*big.Int, error)
  • func (c *ContractReader) HasMethod(hash util.Uint160, method string, pcount int) (bool, error)
• type Event
• 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) 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 Invoker

type Invoker interface {
	Call(contract util.Uint160, operation string, params ...interface{}) (*result.Invoke, error)
}

Invoker is used by ContractReader to call various methods.