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<BlockV1, 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<ReceiptGasInfoV1>, 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<ContractResultV1<ExecReturnValueV1, 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: CodeV1,
        data: Vec<u8>,
        salt: Option<[u8; 32]>,
    ) -> Result<ContractResultV1<InstantiateReturnValueV1, Balance>, ApiError> { ... }
    fn eth_transact(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransactionV1,
    ) -> Result<Result<EthTransactInfoV1<Balance>, EthTransactError>, ApiError> { ... }
    fn eth_transact_with_config(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransactionV1,
        config: DryRunConfigV1<Moment>,
    ) -> Result<Result<EthTransactInfoV1<Balance>, EthTransactError>, ApiError> { ... }
    fn eth_estimate_gas(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransactionV1,
        config: DryRunConfigV1<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<Result<CodeUploadReturnValueV1<Balance>, DispatchError>, 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: TracerTypeV1,
    ) -> Result<Vec<(u32, TraceV1)>, ApiError> { ... }
    fn trace_tx(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        block: Block,
        tx_index: u32,
        config: TracerTypeV1,
    ) -> Result<Option<TraceV1>, ApiError> { ... }
    fn trace_call(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransactionV1,
        config: TracerTypeV1,
    ) -> Result<Result<TraceV1, EthTransactError>, ApiError> { ... }
    fn trace_call_with_config(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        tx: GenericTransactionV1,
        tracer_type: TracerTypeV1,
        config: TracingConfigV1,
    ) -> Result<Result<TraceV1, 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> { ... }
    fn version_declarations(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
    ) -> Result<ReviveRuntimeApiVersionDeclarations, ApiError> { ... }
    fn eth_block_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: BlockVersionedInputPayload,
    ) -> Result<BlockVersionedOutputPayload, ApiError> { ... }
    fn eth_block_hash_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: BlockHashVersionedInputPayload,
    ) -> Result<BlockHashVersionedOutputPayload, ApiError> { ... }
    fn eth_receipt_data_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: ReceiptDataVersionedInputPayload,
    ) -> Result<ReceiptDataVersionedOutputPayload, ApiError> { ... }
    fn block_gas_limit_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: BlockGasLimitVersionedInputPayload,
    ) -> Result<BlockGasLimitVersionedOutputPayload, ApiError> { ... }
    fn max_extrinsic_weight_in_gas_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: MaxExtrinsicWeightInGasVersionedInputPayload,
    ) -> Result<MaxExtrinsicWeightInGasVersionedOutputPayload, ApiError> { ... }
    fn balance_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: BalanceVersionedInputPayload,
    ) -> Result<BalanceVersionedOutputPayload, ApiError> { ... }
    fn gas_price_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: GasPriceVersionedInputPayload,
    ) -> Result<GasPriceVersionedOutputPayload, ApiError> { ... }
    fn nonce_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: NonceVersionedInputPayload,
    ) -> Result<NonceVersionedOutputPayload<Nonce>, ApiError> { ... }
    fn call_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: CallVersionedInputPayload<AccountId, Balance>,
    ) -> Result<CallVersionedOutputPayload<Balance>, ApiError> { ... }
    fn instantiate_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: InstantiateVersionedInputPayload<AccountId, Balance>,
    ) -> Result<InstantiateVersionedOutputPayload<Balance>, ApiError> { ... }
    fn eth_transact_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: TransactVersionedInputPayload<Moment>,
    ) -> Result<Result<TransactVersionedOutputPayload<Balance>, EthTransactError>, ApiError> { ... }
    fn eth_estimate_gas_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: EstimateGasVersionedInputPayload<Moment>,
    ) -> Result<Result<EstimateGasVersionedOutputPayload, EthTransactError>, ApiError> { ... }
    fn eth_pre_dispatch_weight_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: PreDispatchWeightVersionedInputPayload,
    ) -> Result<Result<PreDispatchWeightVersionedOutputPayload, EthTransactError>, ApiError> { ... }
    fn upload_code_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: UploadCodeVersionedInputPayload<AccountId, Balance>,
    ) -> Result<Result<UploadCodeVersionedOutputPayload<Balance>, DispatchError>, ApiError> { ... }
    fn get_storage_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: GetStorageVersionedInputPayload,
    ) -> Result<Result<GetStorageVersionedOutputPayload, ContractAccessError>, ApiError> { ... }
    fn runtime_pallets_address_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: RuntimePalletsAddressVersionedInputPayload,
    ) -> Result<RuntimePalletsAddressVersionedOutputPayload, ApiError> { ... }
    fn code_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: CodeVersionedInputPayload,
    ) -> Result<CodeVersionedOutputPayload, ApiError> { ... }
    fn account_id_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: AccountIdVersionedInputPayload,
    ) -> Result<AccountIdVersionedOutputPayload<AccountId>, ApiError> { ... }
    fn new_balance_with_dust_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: NewBalanceWithDustVersionedInputPayload,
    ) -> Result<Result<NewBalanceWithDustVersionedOutputPayload<Balance>, BalanceConversionError>, ApiError> { ... }
    fn block_author_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: BlockAuthorVersionedInputPayload,
    ) -> Result<BlockAuthorVersionedOutputPayload, ApiError> { ... }
    fn address_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: AddressVersionedInputPayload<AccountId>,
    ) -> Result<AddressVersionedOutputPayload, ApiError> { ... }
    fn trace_block_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: TraceBlockVersionedInputPayload<Block>,
    ) -> Result<TraceBlockVersionedOutputPayload, ApiError> { ... }
    fn trace_tx_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: TraceTxVersionedInputPayload<Block>,
    ) -> Result<TraceTxVersionedOutputPayload, ApiError> { ... }
    fn trace_call_versioned(
        &self,
        __runtime_api_at_param__: <Block as BlockT>::Hash,
        input: TraceCallVersionedInputPayload,
    ) -> Result<Result<TraceCallVersionedOutputPayload, EthTransactError>, ApiError> { ... }
}

The API used to dry-run contract interactions.

Provided Methods

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

👎Deprecated: Use the versioned equivalent eth_block_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent eth_block_hash_versioned if available on your runtime

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<ReceiptGasInfoV1>, ApiError>

👎Deprecated: Use the versioned equivalent eth_receipt_data_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent block_gas_limit_versioned if available on your runtime

Returns the block gas limit.

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

👎Deprecated: Use the versioned equivalent max_extrinsic_weight_in_gas_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent balance_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent gas_price_versioned if available on your runtime

Returns the gas price.

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

👎Deprecated: Use the versioned equivalent nonce_versioned if available on your runtime

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<ContractResultV1<ExecReturnValueV1, Balance>, ApiError>

👎Deprecated: Use the versioned equivalent call_versioned if available on your runtime

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: CodeV1, data: Vec<u8>, salt: Option<[u8; 32]>, ) -> Result<ContractResultV1<InstantiateReturnValueV1, Balance>, ApiError>

👎Deprecated: Use the versioned equivalent instantiate_versioned if available on your runtime

Instantiate a new contract.

See [crate::Pallet::bare_instantiate].

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

👎Deprecated: Use the versioned equivalent eth_transact_versioned if available on your runtime

Perform an Ethereum call.

See crate::Pallet::dry_run_eth_transact

fn eth_transact_with_config( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, tx: GenericTransactionV1, config: DryRunConfigV1<Moment>, ) -> Result<Result<EthTransactInfoV1<Balance>, EthTransactError>, ApiError>

👎Deprecated: Use the versioned equivalent eth_transact_versioned if available on your runtime

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: GenericTransactionV1, config: DryRunConfigV1<Moment>, ) -> Result<Result<U256, EthTransactError>, ApiError>

👎Deprecated: Use the versioned equivalent eth_estimate_gas_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent eth_pre_dispatch_weight_versioned if available on your runtime

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<Result<CodeUploadReturnValueV1<Balance>, DispatchError>, ApiError>

👎Deprecated: Use the versioned equivalent upload_code_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent get_storage_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent get_storage_versioned if available on your runtime

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: TracerTypeV1, ) -> Result<Vec<(u32, TraceV1)>, ApiError>

👎Deprecated: Use the versioned equivalent trace_block_versioned if available on your runtime

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: TracerTypeV1, ) -> Result<Option<TraceV1>, ApiError>

👎Deprecated: Use the versioned equivalent trace_tx_versioned if available on your runtime

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: GenericTransactionV1, config: TracerTypeV1, ) -> Result<Result<TraceV1, EthTransactError>, ApiError>

👎Deprecated: Use the versioned equivalent trace_call_versioned if available on your runtime

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: GenericTransactionV1, tracer_type: TracerTypeV1, config: TracingConfigV1, ) -> Result<Result<TraceV1, EthTransactError>, ApiError>

👎Deprecated: Use the versioned equivalent trace_call_versioned if available on your runtime

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

Like Self::trace_call, but accepts a [TracingConfigV1] that can carry state overrides. The config must be the last argument for backwards compatibility.

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

👎Deprecated: Use the versioned equivalent block_author_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent address_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent account_id_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent runtime_pallets_address_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent code_versioned if available on your runtime

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>

👎Deprecated: Use the versioned equivalent new_balance_with_dust_versioned if available on your runtime

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

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

fn eth_block_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: BlockVersionedInputPayload, ) -> Result<BlockVersionedOutputPayload, ApiError>

fn eth_block_hash_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: BlockHashVersionedInputPayload, ) -> Result<BlockHashVersionedOutputPayload, ApiError>

fn eth_receipt_data_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: ReceiptDataVersionedInputPayload, ) -> Result<ReceiptDataVersionedOutputPayload, ApiError>

fn block_gas_limit_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: BlockGasLimitVersionedInputPayload, ) -> Result<BlockGasLimitVersionedOutputPayload, ApiError>

fn max_extrinsic_weight_in_gas_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: MaxExtrinsicWeightInGasVersionedInputPayload, ) -> Result<MaxExtrinsicWeightInGasVersionedOutputPayload, ApiError>

fn balance_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: BalanceVersionedInputPayload, ) -> Result<BalanceVersionedOutputPayload, ApiError>

fn gas_price_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: GasPriceVersionedInputPayload, ) -> Result<GasPriceVersionedOutputPayload, ApiError>

fn nonce_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: NonceVersionedInputPayload, ) -> Result<NonceVersionedOutputPayload<Nonce>, ApiError>

fn call_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: CallVersionedInputPayload<AccountId, Balance>, ) -> Result<CallVersionedOutputPayload<Balance>, ApiError>

fn instantiate_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: InstantiateVersionedInputPayload<AccountId, Balance>, ) -> Result<InstantiateVersionedOutputPayload<Balance>, ApiError>

fn eth_transact_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: TransactVersionedInputPayload<Moment>, ) -> Result<Result<TransactVersionedOutputPayload<Balance>, EthTransactError>, ApiError>

fn eth_estimate_gas_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: EstimateGasVersionedInputPayload<Moment>, ) -> Result<Result<EstimateGasVersionedOutputPayload, EthTransactError>, ApiError>

fn eth_pre_dispatch_weight_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: PreDispatchWeightVersionedInputPayload, ) -> Result<Result<PreDispatchWeightVersionedOutputPayload, EthTransactError>, ApiError>

fn upload_code_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: UploadCodeVersionedInputPayload<AccountId, Balance>, ) -> Result<Result<UploadCodeVersionedOutputPayload<Balance>, DispatchError>, ApiError>

fn get_storage_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: GetStorageVersionedInputPayload, ) -> Result<Result<GetStorageVersionedOutputPayload, ContractAccessError>, ApiError>

fn runtime_pallets_address_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: RuntimePalletsAddressVersionedInputPayload, ) -> Result<RuntimePalletsAddressVersionedOutputPayload, ApiError>

fn code_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: CodeVersionedInputPayload, ) -> Result<CodeVersionedOutputPayload, ApiError>

fn account_id_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: AccountIdVersionedInputPayload, ) -> Result<AccountIdVersionedOutputPayload<AccountId>, ApiError>

fn new_balance_with_dust_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: NewBalanceWithDustVersionedInputPayload, ) -> Result<Result<NewBalanceWithDustVersionedOutputPayload<Balance>, BalanceConversionError>, ApiError>

fn block_author_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: BlockAuthorVersionedInputPayload, ) -> Result<BlockAuthorVersionedOutputPayload, ApiError>

fn address_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: AddressVersionedInputPayload<AccountId>, ) -> Result<AddressVersionedOutputPayload, ApiError>

fn trace_block_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: TraceBlockVersionedInputPayload<Block>, ) -> Result<TraceBlockVersionedOutputPayload, ApiError>

fn trace_tx_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: TraceTxVersionedInputPayload<Block>, ) -> Result<TraceTxVersionedOutputPayload, ApiError>

fn trace_call_versioned( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, input: TraceCallVersionedInputPayload, ) -> Result<Result<TraceCallVersionedOutputPayload, EthTransactError>, ApiError>

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 = 2u32

The version of the runtime api.

Implementors