Struct ethereum_json_rpc::EthereumJSONRPC

pub struct EthereumJSONRPC<T: Transport> { /* fields omitted */ }

Methods

impl<T: Transport> EthereumJSONRPC<T>

pub fn new(transport: T) -> Self

Creates a new RPC client backed by the given transport implementation.

pub fn web3_clientVersion(&mut self) -> RpcRequest<ClientVersion, T::Future>

pub fn web3_sha3(&mut self, data: Data) -> RpcRequest<HashedData, T::Future>

pub fn net_listening(&mut self) -> RpcRequest<NetListeningResult, T::Future>

pub fn net_peerCount(&mut self) -> RpcRequest<Quantity, T::Future>

pub fn net_version(&mut self) -> RpcRequest<ChainId, T::Future>

pub fn eth_blockNumber(&mut self) -> RpcRequest<BlockNumber, T::Future>

pub fn eth_call(
    &mut self,
    transaction: Transaction,
    blockNumber: BlockNumber
) -> RpcRequest<ReturnValue, T::Future>

pub fn eth_chainId(&mut self) -> RpcRequest<ChainId, T::Future>

pub fn eth_coinbase(&mut self) -> RpcRequest<Address, T::Future>

pub fn eth_estimateGas(
    &mut self,
    transaction: Transaction
) -> RpcRequest<GasUsed, T::Future>

pub fn eth_gasPrice(&mut self) -> RpcRequest<GasPrice, T::Future>

pub fn eth_getBalance(
    &mut self,
    address: Address,
    blockNumber: BlockNumber
) -> RpcRequest<GetBalanceResult, T::Future>

pub fn eth_getBlockByHash(
    &mut self,
    blockHash: BlockHash,
    includeTransactions: IncludeTransactions
) -> RpcRequest<GetBlockByHashResult, T::Future>

pub fn eth_getBlockByNumber(
    &mut self,
    blockNumber: BlockNumber,
    includeTransactions: IncludeTransactions
) -> RpcRequest<GetBlockByNumberResult, T::Future>

pub fn eth_getBlockTransactionCountByHash(
    &mut self,
    blockHash: BlockHash
) -> RpcRequest<BlockTransactionCountByHash, T::Future>

pub fn eth_getBlockTransactionCountByNumber(
    &mut self,
    blockNumber: BlockNumber
) -> RpcRequest<BlockTransactionCountByHash, T::Future>

pub fn eth_getCode(
    &mut self,
    address: Address,
    blockNumber: BlockNumber
) -> RpcRequest<Bytes, T::Future>

pub fn eth_getFilterChanges(
    &mut self,
    filterId: FilterId
) -> RpcRequest<LogResult, T::Future>

pub fn eth_getFilterLogs(
    &mut self,
    filterId: FilterId
) -> RpcRequest<Logs, T::Future>

pub fn eth_getRawTransactionByHash(
    &mut self,
    transactionHash: TransactionHash
) -> RpcRequest<RawTransactionByHash, T::Future>

pub fn eth_getRawTransactionByBlockHashAndIndex(
    &mut self,
    blockHash: BlockHash,
    index: Index
) -> RpcRequest<RawTransaction, T::Future>

pub fn eth_getRawTransactionByBlockNumberAndIndex(
    &mut self,
    blockNumber: BlockNumber,
    index: Index
) -> RpcRequest<RawTransaction, T::Future>

pub fn eth_getLogs(&mut self, filter: Filter) -> RpcRequest<Logs, T::Future>

pub fn eth_getStorageAt(
    &mut self,
    address: Address,
    key: Key,
    blockNumber: BlockNumber
) -> RpcRequest<DataWord, T::Future>

pub fn eth_getTransactionByBlockHashAndIndex(
    &mut self,
    blockHash: BlockHash,
    index: Index
) -> RpcRequest<TransactionResult, T::Future>

pub fn eth_getTransactionByBlockNumberAndIndex(
    &mut self,
    blockNumber: BlockNumber,
    index: Index
) -> RpcRequest<TransactionResult, T::Future>

pub fn eth_getTransactionByHash(
    &mut self,
    transactionHash: TransactionHash
) -> RpcRequest<TransactionResult, T::Future>

pub fn eth_getTransactionCount(
    &mut self,
    address: Address,
    blockNumber: BlockNumber
) -> RpcRequest<TransactionCount, T::Future>

pub fn eth_getTransactionReceipt(
    &mut self,
    transactionHash: TransactionHash
) -> RpcRequest<TransactionReceiptResult, T::Future>

pub fn eth_getUncleByBlockHashAndIndex(
    &mut self,
    blockHash: BlockHash,
    index: Index
) -> RpcRequest<Uncle, T::Future>

pub fn eth_getUncleByBlockNumberAndIndex(
    &mut self,
    uncleBlockNumber: UncleBlockNumber,
    index: Index
) -> RpcRequest<UncleResult, T::Future>

pub fn eth_getUncleCountByBlockHash(
    &mut self,
    blockHash: BlockHash
) -> RpcRequest<UncleCountResult, T::Future>

pub fn eth_getUncleCountByBlockNumber(
    &mut self,
    blockNumber: BlockNumber
) -> RpcRequest<UncleCountResult, T::Future>

pub fn eth_getProof(
    &mut self,
    address: Address,
    storageKeys: StorageKeys,
    blockNumber: BlockNumber
) -> RpcRequest<Account, T::Future>

pub fn eth_getWork(&mut self) -> RpcRequest<Work, T::Future>

pub fn eth_hashrate(&mut self) -> RpcRequest<HashesPerSecond, T::Future>

pub fn eth_mining(&mut self) -> RpcRequest<Mining, T::Future>

pub fn eth_newBlockFilter(&mut self) -> RpcRequest<FilterId, T::Future>

pub fn eth_newFilter(
    &mut self,
    filter: Filter
) -> RpcRequest<FilterId, T::Future>

pub fn eth_newPendingTransactionFilter(
    &mut self
) -> RpcRequest<FilterId, T::Future>

pub fn eth_protocolVersion(&mut self) -> RpcRequest<ProtocolVersion, T::Future>

pub fn eth_sendRawTransaction(
    &mut self,
    signedTransactionData: SignedTransactionData
) -> RpcRequest<TransactionHash, T::Future>

pub fn eth_submitHashrate(
    &mut self,
    hashRate: HashRate,
    id: Id
) -> RpcRequest<SubmitHashRateSuccess, T::Future>

pub fn eth_submitWork(
    &mut self,
    nonce: Nonce,
    powHash: PowHash,
    mixHash: MixHash
) -> RpcRequest<SolutionValid, T::Future>

pub fn eth_syncing(&mut self) -> RpcRequest<Syncing, T::Future>

pub fn eth_uninstallFilter(
    &mut self,
    filterId: FilterId
) -> RpcRequest<FilterUninstalledSuccess, T::Future>