Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type SimulatedBackend

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

    SimulatedBackend implements bind.ContractBackend, simulating a blockchain in the background. Its main purpose is to allow for easy testing of contract bindings. Simulated backend implements the following interfaces: ChainReader, ChainStateReader, ContractBackend, ContractCaller, ContractFilterer, ContractTransactor, DeployBackend, GasEstimator, GasPricer, LogFilterer, PendingContractCaller, TransactionReader, and TransactionSender

    func NewSimulatedBackend

    func NewSimulatedBackend(alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend

      NewSimulatedBackend creates a new binding backend using a simulated blockchain for testing purposes. A simulated backend always uses chainID 1337.

      func NewSimulatedBackendWithDatabase

      func NewSimulatedBackendWithDatabase(database ethdb.Database, alloc core.GenesisAlloc, gasLimit uint64) *SimulatedBackend

        NewSimulatedBackendWithDatabase creates a new binding backend based on the given database and uses a simulated blockchain for testing purposes. A simulated backend always uses chainID 1337.

        func (*SimulatedBackend) AdjustTime

        func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error

          AdjustTime adds a time shift to the simulated clock. It can only be called on empty blocks.

          func (*SimulatedBackend) BalanceAt

          func (b *SimulatedBackend) BalanceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (*big.Int, error)

            BalanceAt returns the wei balance of a certain account in the blockchain.

            func (*SimulatedBackend) BlockByHash

            func (b *SimulatedBackend) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error)

              BlockByHash retrieves a block based on the block hash.

              func (*SimulatedBackend) BlockByNumber

              func (b *SimulatedBackend) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)

                BlockByNumber retrieves a block from the database by number, caching it (associated with its hash) if found.

                func (*SimulatedBackend) Blockchain

                func (b *SimulatedBackend) Blockchain() *core.BlockChain

                  Blockchain returns the underlying blockchain.

                  func (*SimulatedBackend) CallContract

                  func (b *SimulatedBackend) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)

                    CallContract executes a contract call.

                    func (*SimulatedBackend) Close

                    func (b *SimulatedBackend) Close() error

                      Close terminates the underlying blockchain's update loop.

                      func (*SimulatedBackend) CodeAt

                      func (b *SimulatedBackend) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error)

                        CodeAt returns the code associated with a certain account in the blockchain.

                        func (*SimulatedBackend) Commit

                        func (b *SimulatedBackend) Commit()

                          Commit imports all the pending transactions as a single block and starts a fresh new state.

                          func (*SimulatedBackend) EstimateGas

                          func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error)

                            EstimateGas executes the requested code against the currently pending block/state and returns the used amount of gas.

                            func (*SimulatedBackend) FilterLogs

                            func (b *SimulatedBackend) FilterLogs(ctx context.Context, query ethereum.FilterQuery) ([]types.Log, error)

                              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.

                              func (*SimulatedBackend) HeaderByHash

                              func (b *SimulatedBackend) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error)

                                HeaderByHash returns a block header from the current canonical chain.

                                func (*SimulatedBackend) HeaderByNumber

                                func (b *SimulatedBackend) HeaderByNumber(ctx context.Context, block *big.Int) (*types.Header, error)

                                  HeaderByNumber returns a block header from the current canonical chain. If number is nil, the latest known header is returned.

                                  func (*SimulatedBackend) NonceAt

                                  func (b *SimulatedBackend) NonceAt(ctx context.Context, contract common.Address, blockNumber *big.Int) (uint64, error)

                                    NonceAt returns the nonce of a certain account in the blockchain.

                                    func (*SimulatedBackend) PendingCallContract

                                    func (b *SimulatedBackend) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error)

                                      PendingCallContract executes a contract call on the pending state.

                                      func (*SimulatedBackend) PendingCodeAt

                                      func (b *SimulatedBackend) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error)

                                        PendingCodeAt returns the code associated with an account in the pending state.

                                        func (*SimulatedBackend) PendingNonceAt

                                        func (b *SimulatedBackend) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)

                                          PendingNonceAt implements PendingStateReader.PendingNonceAt, retrieving the nonce currently pending for the account.

                                          func (*SimulatedBackend) Rollback

                                          func (b *SimulatedBackend) Rollback()

                                            Rollback aborts all pending transactions, reverting to the last committed state.

                                            func (*SimulatedBackend) SendTransaction

                                            func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transaction) error

                                              SendTransaction updates the pending block to include the given transaction. It panics if the transaction is invalid.

                                              func (*SimulatedBackend) StorageAt

                                              func (b *SimulatedBackend) StorageAt(ctx context.Context, contract common.Address, key common.Hash, blockNumber *big.Int) ([]byte, error)

                                                StorageAt returns the value of key in the storage of an account in the blockchain.

                                                func (*SimulatedBackend) SubscribeFilterLogs

                                                func (b *SimulatedBackend) SubscribeFilterLogs(ctx context.Context, query ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error)

                                                  SubscribeFilterLogs creates a background log filtering operation, returning a subscription immediately, which can be used to stream the found events.

                                                  func (*SimulatedBackend) SubscribeNewHead

                                                  func (b *SimulatedBackend) SubscribeNewHead(ctx context.Context, ch chan<- *types.Header) (ethereum.Subscription, error)

                                                    SubscribeNewHead returns an event subscription for a new header.

                                                    func (*SimulatedBackend) SuggestGasPrice

                                                    func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error)

                                                      SuggestGasPrice implements ContractTransactor.SuggestGasPrice. Since the simulated chain doesn't have miners, we just return a gas price of 1 for any call.

                                                      func (*SimulatedBackend) TransactionByHash

                                                      func (b *SimulatedBackend) TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error)

                                                        TransactionByHash checks the pool of pending transactions in addition to the blockchain. The isPending return value indicates whether the transaction has been mined yet. Note that the transaction may not be part of the canonical chain even if it's not pending.

                                                        func (*SimulatedBackend) TransactionCount

                                                        func (b *SimulatedBackend) TransactionCount(ctx context.Context, blockHash common.Hash) (uint, error)

                                                          TransactionCount returns the number of transactions in a given block.

                                                          func (*SimulatedBackend) TransactionInBlock

                                                          func (b *SimulatedBackend) TransactionInBlock(ctx context.Context, blockHash common.Hash, index uint) (*types.Transaction, error)

                                                            TransactionInBlock returns the transaction for a specific block at a specific index.

                                                            func (*SimulatedBackend) TransactionReceipt

                                                            func (b *SimulatedBackend) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)

                                                              TransactionReceipt returns the receipt of a transaction.

                                                              Source Files