test

Documentation

Index

• Variables
• func Bytes32Enum(in interface{}) interface{}
• func ToHex(b Bytes32) string
• func ToOGRN(orgId Bytes32) string
• func ToString(b Bytes32) string
• func ToString8(b Bytes8) string
• type Bytes16
  • func B16(s string) (r Bytes16)
• type Bytes32
  • func B32(s string) (r Bytes32)
  • func FromHex(s string) (Bytes32, error)
  • func FromOGRN(ogrn string) Bytes32
  • func ToBytes32(s string) (r Bytes32, err error)
• type Bytes8
  • func B8(s string) (r Bytes8)
• type ContractBackend
• type ContractCaller
• type ContractFilterer
• type ContractTransactor
• type PendingContractCaller

Variables

var (
	// ErrNoCode is returned by call and transact operations for which the requested
	// recipient contract to operate on does not exist in the state db or does not
	// have any code associated with it (i.e. suicided).
	ErrNoCode = errors.New("no contract code at given address")

	// This error is raised when attempting to perform a pending state action
	// on a backend that doesn't implement PendingContractCaller.
	ErrNoPendingState = errors.New("backend does not support pending state")

	// This error is returned by WaitForDeploy if contract creation leaves an
	// empty contract behind.
	ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")

	ErrIsNotDeploy = errors.New("tx is not a contract deployment")

	ErrZeroAddress = errors.New("zero contract address after deployment")
)

var ErrHexTooShort = errors.New("hex string is shorter than bytes32")

var ErrStringTooLong = errors.New("string to long")

Functions

func Bytes32Enum

func Bytes32Enum(in interface{}) interface{}

func ToHex

func ToHex(b Bytes32) string

func ToOGRN

func ToOGRN(orgId Bytes32) string

func ToString

func ToString(b Bytes32) string

func ToString8

func ToString8(b Bytes8) string

Types

type Bytes16

type Bytes16 = [16]byte

func B16

func B16(s string) (r Bytes16)

type Bytes32

type Bytes32 = [32]byte

func B32

func B32(s string) (r Bytes32)

func FromHex

func FromHex(s string) (Bytes32, error)

func FromOGRN

func FromOGRN(ogrn string) Bytes32

func ToBytes32

func ToBytes32(s string) (r Bytes32, err error)

type Bytes8

type Bytes8 = [8]byte

func B8

func B8(s string) (r Bytes8)

type ContractBackend

type ContractBackend interface {
	ContractCaller
	ContractTransactor
	ContractFilterer
}

ContractBackend defines the methods needed to work with contracts on a read-write basis.

type ContractCaller

type ContractCaller interface {
	// CodeAt returns the code of the given account. This is needed to differentiate
	// between contract internal errors and the local chain being out of sync.
	CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error)
	// ContractCall executes an Ethereum contract call with the specified data as the
	// input.
	CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)

	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
}

ContractCaller defines the methods needed to allow operating with contract on a read only basis.

type ContractFilterer

type ContractFilterer interface {
	// FilterLogs executes a log filter operation, blocking during execution and
	// returning all the results in one batch.
	//
	// TODO(karalabe): Deprecate when the subscription one can return past data too.
	FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error)

	// SubscribeFilterLogs creates a background log filtering operation, returning
	// a subscription immediately, which can be used to stream the found events.
	SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error)
}

ContractFilterer defines the methods needed to access log events using one-off queries or continuous event subscriptions.

type ContractTransactor

type ContractTransactor interface {
	// PendingCodeAt returns the code of the given account in the pending state.
	PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error)
	// PendingNonceAt retrieves the current pending nonce associated with an account.
	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
	// SuggestGasPrice retrieves the currently suggested gas price to allow a timely
	// execution of a transaction.
	SuggestGasPrice(ctx context.Context) (*big.Int, error)
	// EstimateGas tries to estimate the gas needed to execute a specific
	// transaction based on the current pending state of the backend blockchain.
	// There is no guarantee that this is the true gas limit requirement as other
	// transactions may be added or removed by miners, but it should provide a basis
	// for setting a reasonable default.
	EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error)
	GasLimit(ctx context.Context) (limit uint64, err error)
	// SendTransaction injects the transaction into the pending pool for execution.
	SendTransaction(ctx context.Context, tx *types.Transaction) error
}

ContractTransactor defines the methods needed to allow operating with contract on a write only basis. Beside the transacting method, the remainder are helpers used when the user does not provide some needed values, but rather leaves it up to the transactor to decide.

type PendingContractCaller

type PendingContractCaller interface {
	// PendingCodeAt returns the code of the given account in the pending state.
	PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error)
	// PendingCallContract executes an Ethereum contract call against the pending state.
	PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error)
}

PendingContractCaller defines methods to perform contract calls on the pending state. Call will try to discover this interface when access to the pending state is requested. If the backend does not support the pending state, Call returns ErrNoPendingState.