Trait ReviveApi 

pub trait ReviveApi<Block: BlockT, AccountId, Balance, Nonce, BlockNumber, Moment>: Core<Block>
where
    AccountId: Codec,
    Balance: Codec,
    Nonce: Codec,
    BlockNumber: Codec,
    Moment: Codec,
{
    // Provided methods
    fn eth_block(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<EthBlock, ApiError> { ... }
    fn eth_block_hash(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        number: U256,
    ) -> Result<Option<H256>, ApiError> { ... }
    fn eth_receipt_data(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<Vec<ReceiptGasInfo>, ApiError> { ... }
    fn block_gas_limit(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<U256, ApiError> { ... }
    fn max_extrinsic_weight_in_gas(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<U256, ApiError> { ... }
    fn balance(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        address: H160,
    ) -> Result<U256, ApiError> { ... }
    fn gas_price(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<U256, ApiError> { ... }
    fn nonce(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        address: H160,
    ) -> Result<Nonce, ApiError> { ... }
    fn call(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        origin: AccountId,
        dest: H160,
        value: Balance,
        gas_limit: Option<Weight>,
        storage_deposit_limit: Option<Balance>,
        input_data: Vec<u8>,
    ) -> Result<ContractResult<ExecReturnValue, Balance>, ApiError> { ... }
    fn instantiate(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        origin: AccountId,
        value: Balance,
        gas_limit: Option<Weight>,
        storage_deposit_limit: Option<Balance>,
        code: Code,
        data: Vec<u8>,
        salt: Option<[u8; 32]>,
    ) -> Result<ContractResult<InstantiateReturnValue, Balance>, ApiError> { ... }
    fn eth_transact(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransaction,
    ) -> Result<Result<EthTransactInfo<Balance>, EthTransactError>, ApiError> { ... }
    fn eth_transact_with_config(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransaction,
        config: DryRunConfig<Moment>,
    ) -> Result<Result<EthTransactInfo<Balance>, EthTransactError>, ApiError> { ... }
    fn eth_estimate_gas(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransaction,
        config: DryRunConfig<Moment>,
    ) -> Result<Result<U256, EthTransactError>, ApiError> { ... }
    fn eth_pre_dispatch_weight(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: Vec<u8>,
    ) -> Result<Result<Weight, EthTransactError>, ApiError> { ... }
    fn upload_code(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        origin: AccountId,
        code: Vec<u8>,
        storage_deposit_limit: Option<Balance>,
    ) -> Result<CodeUploadResult<Balance>, ApiError> { ... }
    fn get_storage(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        address: H160,
        key: [u8; 32],
    ) -> Result<GetStorageResult, ApiError> { ... }
    fn get_storage_var_key(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        address: H160,
        key: Vec<u8>,
    ) -> Result<GetStorageResult, ApiError> { ... }
    fn trace_block(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        block: Block,
        config: TracerType,
    ) -> Result<Vec<(u32, Trace)>, ApiError> { ... }
    fn trace_tx(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        block: Block,
        tx_index: u32,
        config: TracerType,
    ) -> Result<Option<Trace>, ApiError> { ... }
    fn trace_call(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransaction,
        config: TracerType,
    ) -> Result<Result<Trace, EthTransactError>, ApiError> { ... }
    fn trace_call_with_config(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransaction,
        tracer_type: TracerType,
        config: TracingConfig,
    ) -> Result<Result<Trace, EthTransactError>, ApiError> { ... }
    fn block_author(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<H160, ApiError> { ... }
    fn address(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        account_id: AccountId,
    ) -> Result<H160, ApiError> { ... }
    fn account_id(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        address: H160,
    ) -> Result<AccountId, ApiError> { ... }
    fn runtime_pallets_address(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<H160, ApiError> { ... }
    fn code(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        address: H160,
    ) -> Result<Vec<u8>, ApiError> { ... }
    fn new_balance_with_dust(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        balance: U256,
    ) -> Result<Result<(Balance, u32), BalanceConversionError>, ApiError> { ... }
}

The API used to dry-run contract interactions.

Provided Methods

fn eth_block( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<EthBlock, ApiError>

Returns the current ETH block.

This is one block behind the substrate block.

fn eth_block_hash( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, number: U256, ) -> Result<Option<H256>, ApiError>

Returns the ETH block hash for the given block number.

fn eth_receipt_data( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<Vec<ReceiptGasInfo>, ApiError>

The details needed to reconstruct the receipt information offchain.

Note

Each entry corresponds to the appropriate Ethereum transaction in the current block.

fn block_gas_limit( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<U256, ApiError>

Returns the block gas limit.

fn max_extrinsic_weight_in_gas( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<U256, ApiError>

Returns the block gas limit as calculated from the weights.

fn balance( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, address: H160, ) -> Result<U256, ApiError>

Returns the free balance of the given [H160] address, using EVM decimals.

fn gas_price( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<U256, ApiError>

Returns the gas price.

fn nonce( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, address: H160, ) -> Result<Nonce, ApiError>

Returns the nonce of the given [H160] address.

fn call( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, origin: AccountId, dest: H160, value: Balance, gas_limit: Option<Weight>, storage_deposit_limit: Option<Balance>, input_data: Vec<u8>, ) -> Result<ContractResult<ExecReturnValue, Balance>, ApiError>

Perform a call from a specified account to a given contract.

See crate::Pallet::bare_call.

fn instantiate( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, origin: AccountId, value: Balance, gas_limit: Option<Weight>, storage_deposit_limit: Option<Balance>, code: Code, data: Vec<u8>, salt: Option<[u8; 32]>, ) -> Result<ContractResult<InstantiateReturnValue, Balance>, ApiError>

Instantiate a new contract.

See [crate::Pallet::bare_instantiate].

fn eth_transact( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, tx: GenericTransaction, ) -> Result<Result<EthTransactInfo<Balance>, EthTransactError>, ApiError>

Perform an Ethereum call.

Deprecated use v2 version instead. See crate::Pallet::dry_run_eth_transact

fn eth_transact_with_config( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, tx: GenericTransaction, config: DryRunConfig<Moment>, ) -> Result<Result<EthTransactInfo<Balance>, EthTransactError>, ApiError>

Perform an Ethereum call.

See crate::Pallet::dry_run_eth_transact

fn eth_estimate_gas( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, tx: GenericTransaction, config: DryRunConfig<Moment>, ) -> Result<Result<U256, EthTransactError>, ApiError>

Estimates the amount of gas that a transactions requires.

This function estimates the gas of the transaction according to the same binary search algorithm that’s implemented in Geth. It stops when with an acceptable error ratio of 1.5% so that the algorithm terminates early.

fn eth_pre_dispatch_weight( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, tx: Vec<u8>, ) -> Result<Result<Weight, EthTransactError>, ApiError>

Return the pre-dispatch weight booked for the signed Ethereum transaction payload.

fn upload_code( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, origin: AccountId, code: Vec<u8>, storage_deposit_limit: Option<Balance>, ) -> Result<CodeUploadResult<Balance>, ApiError>

Upload new code without instantiating a contract from it.

See crate::Pallet::bare_upload_code.

fn get_storage( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, address: H160, key: [u8; 32], ) -> Result<GetStorageResult, ApiError>

Query a given storage key in a given contract.

Returns Ok(Some(Vec<u8>)) if the storage value exists under the given key in the specified account and Ok(None) if it doesn’t. If the account specified by the address doesn’t exist, or doesn’t have a contract then Err is returned.

fn get_storage_var_key( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, address: H160, key: Vec<u8>, ) -> Result<GetStorageResult, ApiError>

Query a given variable-sized storage key in a given contract.

Returns Ok(Some(Vec<u8>)) if the storage value exists under the given key in the specified account and Ok(None) if it doesn’t. If the account specified by the address doesn’t exist, or doesn’t have a contract then Err is returned.

fn trace_block( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, block: Block, config: TracerType, ) -> Result<Vec<(u32, Trace)>, ApiError>

Traces the execution of an entire block and returns call traces.

This is intended to be called through state_call to replay the block from the parent block.

See eth-rpc debug_traceBlockByNumber for usage.

fn trace_tx( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, block: Block, tx_index: u32, config: TracerType, ) -> Result<Option<Trace>, ApiError>

Traces the execution of a specific transaction within a block.

This is intended to be called through state_call to replay the block from the parent hash up to the transaction.

See eth-rpc debug_traceTransaction for usage.

fn trace_call( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, tx: GenericTransaction, config: TracerType, ) -> Result<Result<Trace, EthTransactError>, ApiError>

Dry run and return the trace of the given call.

See eth-rpc debug_traceCall for usage.

fn trace_call_with_config( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, tx: GenericTransaction, tracer_type: TracerType, config: TracingConfig, ) -> Result<Result<Trace, EthTransactError>, ApiError>

Dry run and return the trace of the given call with additional configuration.

Like Self::trace_call, but accepts a TracingConfig that can carry state overrides and future extensibility. The config must be the last argument for backwards compatibility — see TracingConfig documentation.

fn block_author( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<H160, ApiError>

The address of the validator that produced the current block.

fn address( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, account_id: AccountId, ) -> Result<H160, ApiError>

Get the H160 address associated to this account id

fn account_id( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, address: H160, ) -> Result<AccountId, ApiError>

Get the account id associated to this H160 address.

fn runtime_pallets_address( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, ) -> Result<H160, ApiError>

The address used to call the runtime’s pallets dispatchables

fn code( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, address: H160, ) -> Result<Vec<u8>, ApiError>

The code at the specified address taking pre-compiles into account.

fn new_balance_with_dust( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, balance: U256, ) -> Result<Result<(Balance, u32), BalanceConversionError>, ApiError>

Construct the new balance and dust components of this EVM balance.

Trait Implementations

impl<Block: BlockT, AccountId, Balance, Nonce, BlockNumber, Moment> RuntimeApiInfo for dyn ReviveApi<Block, AccountId, Balance, Nonce, BlockNumber, Moment>

const ID: [u8; 8]

The identifier of the runtime api.

const VERSION: u32 = 1u32

The version of the runtime api.

Implementors