api

package
v0.1.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 16, 2024 License: GPL-3.0 Imports: 45 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func BlockByNumber 

func BlockByNumber(ctx context.Context, number jsonrpc.BlockNumber, n *API) (block.IBlock, error)

func BlockByNumberOrHash 

func BlockByNumberOrHash(ctx context.Context, blockNrOrHash jsonrpc.BlockNumberOrHash, api *API) (block.IBlock, error)

func DepositInfo 

func DepositInfo(db kv.RwDB, key types.Address) *deposit.Info

func DoCall 

func DoCall(ctx context.Context, api *API, args TransactionArgs, blockNrOrHash jsonrpc.BlockNumberOrHash, overrides *StateOverride, timeout time.Duration, globalGasCap uint64) (*internal.ExecutionResult, error)

func DoEstimateGas 

func DoEstimateGas(ctx context.Context, n *API, args TransactionArgs, blockNrOrHash jsonrpc.BlockNumberOrHash, gasCap uint64) (hexutil.Uint64, error)

func IsDeposit 

func IsDeposit(db kv.RwDB, addr types.Address) (bool, error)

func MachineVerify 

func MachineVerify(ctx context.Context) error

func RPCMarshalBlock 

func RPCMarshalBlock(block block.IBlock, chain common.IBlockChain, inclTx bool, fullTx bool) (map[string]interface{}, error)

func RPCMarshalHeader 

func RPCMarshalHeader(head block.IHeader) map[string]interface{}

RPCMarshalHeader converts the given header to the RPC output .

func SignMerge 

func SignMerge(ctx context.Context, header *block.Header, depositNum uint64) (types.Signature, []*block.Verify, error)

func SubmitTransaction 

func SubmitTransaction(ctx context.Context, api *API, tx *transaction.Transaction) (mvm_common.Hash, error)

SubmitTransaction ?

Types

type API 

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

API compatible EthereumAPI provides an API to access related information.

func NewAPI 

func NewAPI(bc common.IBlockChain, db kv.RwDB, engine consensus.Engine, txspool common.ITxsPool, accountManager *accounts.Manager, config *params.ChainConfig) *API

NewAPI creates a new protocol API.

func (*API) AccountManager 

func (b *API) AccountManager() *accounts.Manager

func (*API) Apis 

func (api *API) Apis() []jsonrpc.API

func (*API) BlockByHash 

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

func (*API) BlockByNumber 

func (b *API) BlockByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Block, error)

func (*API) BlockByNumberOrHash 

func (b *API) BlockByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Block, error)

func (*API) BlockChain 

func (n *API) BlockChain() common.IBlockChain

func (*API) ChainConfig 

func (b *API) ChainConfig() *params.ChainConfig

ChainConfig returns the active chain configuration.

func (*API) ChainDb 

func (b *API) ChainDb() kv.RwDB

func (*API) CurrentBlock 

func (b *API) CurrentBlock() *types.Header

func (*API) CurrentHeader 

func (b *API) CurrentHeader() *types.Header

func (*API) Database 

func (n *API) Database() kv.RwDB

func (*API) Engine 

func (n *API) Engine() consensus.Engine

func (*API) GetChainConfig 

func (n *API) GetChainConfig() *params.ChainConfig

func (*API) GetEVM 

func (b *API) GetEVM(ctx context.Context, msg *transaction.Message, state *state.IntraBlockState, header *types.Header, vmConfig *vm.Config) (*vm.EVM, func() error, error)

func (*API) GetEvm 

func (n *API) GetEvm(ctx context.Context, msg internal.Message, ibs evmtypes.IntraBlockState, header block.IHeader, vmConfig *vm2.Config) (*vm2.EVM, func() error, error)

func (*API) GetReceipts 

func (b *API) GetReceipts(ctx context.Context, hash common.Hash) (types.Receipts, error)

func (*API) GetTd 

func (b *API) GetTd(ctx context.Context, hash common.Hash) *uint256.Int

func (*API) GetTransaction 

func (b *API) GetTransaction(ctx context.Context, txHash common.Hash) (*transaction.Transaction, common.Hash, uint64, uint64, error)

func (*API) HeaderByHash 

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

func (*API) HeaderByNumber 

func (b *API) HeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*types.Header, error)

func (*API) HeaderByNumberOrHash 

func (b *API) HeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*types.Header, error)

func (*API) RPCGasCap 

func (n *API) RPCGasCap() uint64

func (*API) SetGpo 

func (api *API) SetGpo(gpo *Oracle)

func (*API) State 

func (n *API) State(tx kv.Tx, blockNrOrHash jsonrpc.BlockNumberOrHash) evmtypes.IntraBlockState

func (*API) StateAtBlock 

func (eth *API) StateAtBlock(ctx context.Context, tx kv.Tx, blk *types.Block) (statedb *state.IntraBlockState, err error)

StateAtBlock retrieves the state database associated with a certain block. If no state is locally available for the given block, a number of blocks are attempted to be reexecuted to generate the desired state. The optional base layer statedb can be provided which is regarded as the statedb of the parent block.

An additional release function will be returned if the requested state is available. Release is expected to be invoked when the returned state is no longer needed. Its purpose is to prevent resource leaking. Though it can be noop in some cases.

Parameters:

  • block: The block for which we want the state(state = block.Root)
  • reexec: The maximum number of blocks to reprocess trying to obtain the desired state
  • base: If the caller is tracing multiple blocks, the caller can provide the parent state continuously from the callsite.
  • readOnly: If true, then the live 'blockchain' state database is used. No mutation should be made from caller, e.g. perform Commit or other 'save-to-disk' changes. Otherwise, the trash generated by caller may be persisted permanently.
  • preferDisk: this arg can be used by the caller to signal that even though the 'base' is provided, it would be preferable to start from a fresh state, if we have it on disk.

func (*API) StateAtTransaction 

func (eth *API) StateAtTransaction(ctx context.Context, dbTx kv.Tx, blk *types.Block, txIndex int) (*transaction.Message, evmtypes.BlockContext, *state.IntraBlockState, error)

stateAtTransaction returns the execution environment of a certain transaction.

func (*API) TxsPool 

func (n *API) TxsPool() common.ITxsPool

type AccountAPI 

type AccountAPI struct {
}

AccountAPI provides an API to access accounts managed by this node. It offers only methods that can retrieve accounts.

func NewAccountAPI 

func NewAccountAPI() *AccountAPI

NewAccountAPI creates a new AccountAPI.

func (*AccountAPI) Accounts 

func (s *AccountAPI) Accounts() []types.Address

Accounts returns the collection of accounts this node manages.

type AccountResult 

type AccountResult struct {
	Address      types.Address   `json:"address"`
	AccountProof []string        `json:"accountProof"`
	Balance      *hexutil.Big    `json:"balance"`
	CodeHash     types.Hash      `json:"codeHash"`
	Nonce        hexutil.Uint64  `json:"nonce"`
	StorageHash  types.Hash      `json:"storageHash"`
	StorageProof []StorageResult `json:"storageProof"`
}

Result structs for GetProof

type AddrLocker 

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

func (*AddrLocker) LockAddr 

func (l *AddrLocker) LockAddr(address types.Address)

LockAddr locks an account's mutex. This is used to prevent another tx getting the same nonce until the lock is released. The mutex prevents the (an identical nonce) from being read again during the time that the first transaction is being signed.

func (*AddrLocker) UnlockAddr 

func (l *AddrLocker) UnlockAddr(address types.Address)

UnlockAddr unlocks the mutex of the given account.

type AggSign 

type AggSign struct {
	Number    uint64          `json:"number"`
	StateRoot types.Hash      `json:"stateRoot"`
	Sign      types.Signature `json:"sign"`
	Address   types.Address   `json:"address"`
	PublicKey types.PublicKey `json:"-"`
}

func (*AggSign) Check 

func (s *AggSign) Check(root types.Hash) bool

type AmcAPI 

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

AmcAPI provides an API to access metadata related information.

func NewAmcAPI 

func NewAmcAPI(api *API) *AmcAPI

NewAmcAPI creates a new Meta protocol API.

func (*AmcAPI) FeeHistory 

func (s *AmcAPI) FeeHistory(ctx context.Context, blockCount jsonrpc.DecimalOrHex, lastBlock jsonrpc.BlockNumber, rewardPercentiles []float64) (*feeHistoryResult, error)

FeeHistory returns the fee market history.

func (*AmcAPI) GasPrice 

func (s *AmcAPI) GasPrice(ctx context.Context) (*hexutil.Big, error)

GasPrice returns a suggestion for a gas price for legacy transactions.

func (*AmcAPI) MaxPriorityFeePerGas 

func (s *AmcAPI) MaxPriorityFeePerGas(ctx context.Context) (*hexutil.Big, error)

MaxPriorityFeePerGas returns a suggestion for a gas tip cap for dynamic fee transactions.

type BlockChainAPI 

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

BlockChainAPI provides an API to access Ethereum blockchain data.

func NewBlockChainAPI 

func NewBlockChainAPI(api *API) *BlockChainAPI

NewBlockChainAPI creates a new blockchain API.

func (*BlockChainAPI) BlockNumber 

func (s *BlockChainAPI) BlockNumber() hexutil.Uint64

func (*BlockChainAPI) Call 

func (s *BlockChainAPI) Call(ctx context.Context, args TransactionArgs, blockNrOrHash jsonrpc.BlockNumberOrHash, overrides *StateOverride) (hexutil.Bytes, error)

Call executes the given transaction on the state for the given block number.

Additionally, the caller can specify a batch of contract for fields overriding.

Note, this function doesn't make and changes in the state/blockchain and is useful to execute and retrieve values.

func (*BlockChainAPI) ChainId 

func (api *BlockChainAPI) ChainId() *hexutil.Big

ChainId get Chain ID

func (*BlockChainAPI) EstimateGas 

func (s *BlockChainAPI) EstimateGas(ctx context.Context, args TransactionArgs, blockNrOrHash *jsonrpc.BlockNumberOrHash) (hexutil.Uint64, error)

EstimateGas returns an estimate of the amount of gas needed to execute the given transaction against the current pending block.

func (*BlockChainAPI) GetBalance 

func (s *BlockChainAPI) GetBalance(ctx context.Context, address mvm_common.Address, blockNrOrHash jsonrpc.BlockNumberOrHash) (*hexutil.Big, error)

GetBalance get balance

func (*BlockChainAPI) GetBlockByHash 

func (s *BlockChainAPI) GetBlockByHash(ctx context.Context, hash mvm_common.Hash, fullTx bool) (map[string]interface{}, error)

GetBlockByHash get block by hash

func (*BlockChainAPI) GetBlockByNumber 

func (s *BlockChainAPI) GetBlockByNumber(ctx context.Context, number jsonrpc.BlockNumber, fullTx bool) (map[string]interface{}, error)

GetBlockByNumber returns the requested canonical block.

  • When blockNr is -1 the chain head is returned.
  • When blockNr is -2 the pending chain head is returned.
  • When fullTx is true all transactions in the block are returned, otherwise only the transaction hash is returned.

func (*BlockChainAPI) GetCode 

func (s *BlockChainAPI) GetCode(ctx context.Context, address mvm_common.Address, blockNrOrHash jsonrpc.BlockNumberOrHash) (hexutil.Bytes, error)

GetCode get code

func (*BlockChainAPI) GetStorageAt 

func (s *BlockChainAPI) GetStorageAt(ctx context.Context, address types.Address, key string, blockNrOrHash jsonrpc.BlockNumberOrHash) (hexutil.Bytes, error)

GetStorageAt returns the storage from the state at the given address, key and block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber metadata block numbers are also allowed.

func (*BlockChainAPI) GetUncleByBlockHashAndIndex 

func (s *BlockChainAPI) GetUncleByBlockHashAndIndex(ctx context.Context, blockHash mvm_common.Hash, index hexutil.Uint) (map[string]interface{}, error)

GetUncleByBlockHashAndIndex returns the uncle block for the given block hash and index.

func (*BlockChainAPI) GetUncleCountByBlockHash 

func (s *BlockChainAPI) GetUncleCountByBlockHash(ctx context.Context, blockHash mvm_common.Hash) *hexutil.Uint

GetUncleCountByBlockHash returns number of uncles in the block for the given block hash

func (*BlockChainAPI) MinedBlock 

func (s *BlockChainAPI) MinedBlock(ctx context.Context, address types.Address) (*jsonrpc.Subscription, error)

func (*BlockChainAPI) SubmitSign 

func (s *BlockChainAPI) SubmitSign(sign AggSign) error

type BlockOverrides 

type BlockOverrides struct {
	Number     *hexutil.Big
	Difficulty *hexutil.Big
	Time       *hexutil.Uint64
	GasLimit   *hexutil.Uint64
	Coinbase   *types.Address
	Random     *types.Hash
	BaseFee    *hexutil.Big
}

BlockOverrides is a set of header fields to override.

func (*BlockOverrides) Apply 

func (diff *BlockOverrides) Apply(blockCtx *evmtypes.BlockContext)

Apply overrides the given header fields into the given block context.

type DebugAPI 

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

func NewDebugAPI 

func NewDebugAPI(api *API) *DebugAPI

NewDebugAPI creates a new instance of DebugAPI.

func (*DebugAPI) GetAccount 

func (debug *DebugAPI) GetAccount(ctx context.Context, address types.Address)

func (*DebugAPI) SetHead 

func (api *DebugAPI) SetHead(number hexutil.Uint64)

SetHead rewinds the head of the blockchain to a previous block.

type DumpAccount 

type DumpAccount struct {
	Balance   string                `json:"balance"`
	Nonce     uint64                `json:"nonce"`
	Root      hexutil.Bytes         `json:"root"`
	CodeHash  hexutil.Bytes         `json:"codeHash"`
	Code      hexutil.Bytes         `json:"code,omitempty"`
	Storage   map[types.Hash]string `json:"storage,omitempty"`
	Address   *common.Address       `json:"address,omitempty"` // Address only present in iterative (line-by-line) mode
	SecureKey hexutil.Bytes         `json:"key,omitempty"`     // If we don't have address, we can output the key

}

type NetAPI 

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

NetAPI offers network related RPC methods

func NewNetAPI 

func NewNetAPI(api *API, networkVersion uint64) *NetAPI

NewNetAPI creates a new net API instance.

func (*NetAPI) Listening 

func (s *NetAPI) Listening() bool

Listening returns an indication if the node is listening for network connections.

func (*NetAPI) PeerCount 

func (s *NetAPI) PeerCount() hexutil.Uint

PeerCount returns the number of connected peers

func (*NetAPI) Version 

func (s *NetAPI) Version() string

Version returns the current ethereum protocol version.

type Oracle 

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

Oracle recommends gas prices based on the content of recent blocks. Suitable for both light and full clients.

func NewOracle 

func NewOracle(backend common2.IBlockChain, miner common2.IMiner, chainConfig *params.ChainConfig, params conf.GpoConfig) *Oracle

NewOracle returns a new gasprice oracle which can recommend suitable gasprice for newly created transaction.

func (*Oracle) FeeHistory 

func (oracle *Oracle) FeeHistory(ctx context.Context, blocks int, unresolvedLastBlock jsonrpc.BlockNumber, resolvedLastBlock *uint256.Int, rewardPercentiles []float64) (*big.Int, [][]*big.Int, []*big.Int, []float64, error)

FeeHistory returns data relevant for fee estimation based on the specified range of blocks. The range can be specified either with absolute block numbers or ending with the latest or pending block. Backends may or may not support gathering data from the pending block or blocks older than a certain age (specified in maxHistory). The first block of the actually processed range is returned to avoid ambiguity when parts of the requested range are not available or when the head has changed during processing this request. Three arrays are returned based on the processed blocks:

  • reward: the requested percentiles of effective priority fees per gas of transactions in each block, sorted in ascending order and weighted by gas used.
  • baseFee: base fee per gas in the given block
  • gasUsedRatio: gasUsed/gasLimit in the given block

Note: baseFee includes the next block after the newest of the returned range, because this value can be derived from the newest block.

func (*Oracle) SuggestTipCap 

func (oracle *Oracle) SuggestTipCap(ctx context.Context, chainConfig *params.ChainConfig) (*big.Int, error)

SuggestTipCap returns a tip cap so that newly created transaction can have a very high chance to be included in the following blocks.

Note, for legacy transactions and the legacy eth_gasPrice RPC call, it will be necessary to add the basefee to the returned number to fall back to the legacy behavior.

type OverrideAccount 

type OverrideAccount struct {
	Nonce      *hexutil.Uint64                      `json:"nonce"`
	Code       *hexutil.Bytes                       `json:"code"`
	Balance    **hexutil.Big                        `json:"balance"`
	StatsPrint *map[mvm_common.Hash]mvm_common.Hash `json:"state"`
	StateDiff  *map[mvm_common.Hash]mvm_common.Hash `json:"stateDiff"`
}

// OverrideAccount indicates the overriding fields of account during the execution // of a message call. // Note, state and stateDiff can't be specified at the same time. If state is // set, message execution will only use the data in the given state. Otherwise // if statDiff is set, all diff will be applied first and then execute the call // message.

type RPCTransaction 

type RPCTransaction struct {
	BlockHash        *mvm_common.Hash      `json:"blockHash"`
	BlockNumber      *hexutil.Big          `json:"blockNumber"`
	From             mvm_common.Address    `json:"from"`
	Gas              hexutil.Uint64        `json:"gas"`
	GasPrice         *hexutil.Big          `json:"gasPrice"`
	GasFeeCap        *hexutil.Big          `json:"maxFeePerGas,omitempty"`
	GasTipCap        *hexutil.Big          `json:"maxPriorityFeePerGas,omitempty"`
	Hash             mvm_common.Hash       `json:"hash"`
	Input            hexutil.Bytes         `json:"input"`
	Nonce            hexutil.Uint64        `json:"nonce"`
	To               *mvm_common.Address   `json:"to"`
	TransactionIndex *hexutil.Uint64       `json:"transactionIndex"`
	Value            *hexutil.Big          `json:"value"`
	Type             hexutil.Uint64        `json:"type"`
	Accesses         *mvm_types.AccessList `json:"accessList,omitempty"`
	ChainID          *hexutil.Big          `json:"chainId,omitempty"`
	V                *hexutil.Big          `json:"v"`
	R                *hexutil.Big          `json:"r"`
	S                *hexutil.Big          `json:"s"`
}

RPCTransaction represents a transaction that will serialize to the RPC representation of a transaction

type StateOverride 

type StateOverride map[mvm_common.Address]OverrideAccount

StateOverride is the collection of overridden accounts.

func (*StateOverride) Apply 

func (diff *StateOverride) Apply(state *state.IntraBlockState) error

Apply overrides the fields of specified accounts into the given state.

type StorageResult 

type StorageResult struct {
	Key   string       `json:"key"`
	Value *hexutil.Big `json:"value"`
	Proof []string     `json:"proof"`
}

type TransactionAPI 

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

TransactionAPI exposes methods for reading and creating transaction data.

func NewTransactionAPI 

func NewTransactionAPI(api *API, nonceLock *AddrLocker) *TransactionAPI

NewTransactionAPI creates a new RPC service with methods for interacting with transactions.

func (*TransactionAPI) BatchRawTransaction 

func (s *TransactionAPI) BatchRawTransaction(ctx context.Context, inputs []hexutil.Bytes) ([]mvm_common.Hash, error)

func (*TransactionAPI) GetBlockTransactionCountByHash 

func (s *TransactionAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash mvm_common.Hash) *hexutil.Uint

GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.

func (*TransactionAPI) GetTransactionByBlockHashAndIndex 

func (s *TransactionAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash mvm_common.Hash, index hexutil.Uint) *RPCTransaction

GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index.

func (*TransactionAPI) GetTransactionByHash 

func (s *TransactionAPI) GetTransactionByHash(ctx context.Context, hash mvm_common.Hash) (*RPCTransaction, error)

GetTransactionByHash returns the transaction for the given hash

func (*TransactionAPI) GetTransactionCount 

func (s *TransactionAPI) GetTransactionCount(ctx context.Context, address mvm_common.Address, blockNrOrHash jsonrpc.BlockNumberOrHash) (*hexutil.Uint64, error)

GetTransactionCount returns the number of transactions the given address has sent for the given block number

func (*TransactionAPI) GetTransactionReceipt 

func (s *TransactionAPI) GetTransactionReceipt(ctx context.Context, hash mvm_common.Hash) (map[string]interface{}, error)

GetTransactionReceipt returns the transaction receipt for the given transaction hash.

func (*TransactionAPI) SendRawTransaction 

func (s *TransactionAPI) SendRawTransaction(ctx context.Context, input hexutil.Bytes) (mvm_common.Hash, error)

func (*TransactionAPI) SendTransaction 

func (s *TransactionAPI) SendTransaction(ctx context.Context, args TransactionArgs) (mvm_common.Hash, error)

SendTransaction Send Transaction

func (*TransactionAPI) TestBatchTxs 

func (api *TransactionAPI) TestBatchTxs(ctx context.Context)

type TransactionArgs 

type TransactionArgs struct {
	From                 *mvm_common.Address `json:"from"`
	To                   *mvm_common.Address `json:"to"`
	Gas                  *hexutil.Uint64     `json:"gas"`
	GasPrice             *hexutil.Big        `json:"gasPrice"`
	MaxFeePerGas         *hexutil.Big        `json:"maxFeePerGas"`
	MaxPriorityFeePerGas *hexutil.Big        `json:"maxPriorityFeePerGas"`
	Value                *hexutil.Big        `json:"value"`
	Nonce                *hexutil.Uint64     `json:"nonce"`

	Data  *hexutil.Bytes `json:"data"`
	Input *hexutil.Bytes `json:"input"`

	// Introduced by AccessListTxType transaction.
	AccessList *mvm_types.AccessList `json:"accessList,omitempty"`
	ChainID    *hexutil.Big          `json:"chainId,omitempty"`
}

TransactionArgs represents

func (*TransactionArgs) ToMessage 

func (args *TransactionArgs) ToMessage(globalGasCap uint64, baseFee *big.Int) (transaction.Message, error)

ToMessage to evm message

type TxPoolAPI 

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

TxPoolAPI offers and API for the transaction pool. It only operates on data that is non confidential.

func NewTxPoolAPI 

func NewTxPoolAPI(api *API) *TxPoolAPI

NewTxPoolAPI creates a new tx pool service that gives information about the transaction pool.

func (*TxPoolAPI) Content 

func (s *TxPoolAPI) Content() map[string]map[string]map[string]*RPCTransaction

Content returns the transactions contained within the transaction pool.

func (*TxPoolAPI) ContentFrom 

func (s *TxPoolAPI) ContentFrom(addr types.Address) map[string]map[string]*RPCTransaction

ContentFrom returns the transactions contained within the transaction pool.

func (*TxPoolAPI) Inspect 

func (s *TxPoolAPI) Inspect() map[string]map[string]map[string]string

Inspect retrieves the content of the transaction pool and flattens it into an easily inspectable list.

func (*TxPoolAPI) Status 

func (s *TxPoolAPI) Status() map[string]hexutil.Uint

Status returns the number of pending and queued transaction in the pool.

type TxsPoolAPI 

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

TxsPoolAPI offers and API for the transaction pool. It only operates on data that is non confidential.

func NewTxsPoolAPI 

func NewTxsPoolAPI(api *API) *TxsPoolAPI

NewTxsPoolAPI creates a new tx pool service that gives information about the transaction pool.

func (*TxsPoolAPI) Content 

func (s *TxsPoolAPI) Content() map[string]map[string]map[string]*RPCTransaction

Content returns the transactions contained within the transaction pool.

type Web3API 

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

func (*Web3API) ClientVersion 

func (s *Web3API) ClientVersion() string

func (*Web3API) Sha3 

func (s *Web3API) Sha3(input hexutil.Bytes) hexutil.Bytes

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.