c213fd1fd8
There is no need to depend on the old context package now that the minimum Go version is 1.7. The move to "context" eliminates our weird vendoring setup. Some vendored code still uses golang.org/x/net/context and it is now vendored in the normal way. This change triggered new vet checks around context.WithTimeout which didn't fire with golang.org/x/net/context.
98 lines
4.6 KiB
Go
98 lines
4.6 KiB
Go
// Copyright 2015 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package bind
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"math/big"
|
|
|
|
"github.com/ethereum/go-ethereum"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
)
|
|
|
|
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 WaitDeployed if contract creation leaves an
|
|
// empty contract behind.
|
|
ErrNoCodeAfterDeploy = errors.New("no contract code after deployment")
|
|
)
|
|
|
|
// ContractCaller defines the methods needed to allow operating with contract on a read
|
|
// only basis.
|
|
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)
|
|
}
|
|
|
|
// DeployBackend wraps the operations needed by WaitMined and WaitDeployed.
|
|
type DeployBackend interface {
|
|
TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
|
|
CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]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.
|
|
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)
|
|
}
|
|
|
|
// 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 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) (usedGas *big.Int, err error)
|
|
// SendTransaction injects the transaction into the pending pool for execution.
|
|
SendTransaction(ctx context.Context, tx *types.Transaction) error
|
|
}
|
|
|
|
// ContractBackend defines the methods needed to work with contracts on a read-write basis.
|
|
type ContractBackend interface {
|
|
ContractCaller
|
|
ContractTransactor
|
|
}
|