Trait DebugApiServer

pub trait DebugApiServer:
    Sized
    + Send
    + Sync
    + 'static {
    // Required methods
    fn raw_header<'life0, 'async_trait>(
        &'life0 self,
        block_id: BlockId,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn raw_block<'life0, 'async_trait>(
        &'life0 self,
        block_id: BlockId,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn raw_transaction<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Bytes>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn raw_transactions<'life0, 'async_trait>(
        &'life0 self,
        block_id: BlockId,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Bytes>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn raw_receipts<'life0, 'async_trait>(
        &'life0 self,
        block_id: BlockId,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Bytes>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn bad_blocks<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Block>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_chain<'life0, 'async_trait>(
        &'life0 self,
        start_exclusive: BlockNumberOrTag,
        end_inclusive: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<BlockTraceResult>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_block<'life0, 'async_trait>(
        &'life0 self,
        rlp_block: Bytes,
        opts: Option<GethDebugTracingOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<TraceResult>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_block_by_hash<'life0, 'async_trait>(
        &'life0 self,
        block: B256,
        opts: Option<GethDebugTracingOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<TraceResult>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_block_by_number<'life0, 'async_trait>(
        &'life0 self,
        block: BlockNumberOrTag,
        opts: Option<GethDebugTracingOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<TraceResult>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_transaction<'life0, 'async_trait>(
        &'life0 self,
        tx_hash: B256,
        opts: Option<GethDebugTracingOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<GethTrace>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_call<'life0, 'async_trait>(
        &'life0 self,
        request: TransactionRequest,
        block_id: Option<BlockId>,
        opts: Option<GethDebugTracingCallOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<GethTrace>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_call_many<'life0, 'async_trait>(
        &'life0 self,
        bundles: Vec<Bundle>,
        state_context: Option<StateContext>,
        opts: Option<GethDebugTracingCallOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Vec<GethTrace>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_execution_witness<'life0, 'async_trait>(
        &'life0 self,
        block: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = RpcResult<ExecutionWitness>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_backtrace_at<'life0, 'life1, 'async_trait>(
        &'life0 self,
        location: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn debug_account_range<'life0, 'async_trait>(
        &'life0 self,
        block_number: BlockNumberOrTag,
        start: Bytes,
        max_results: u64,
        nocode: bool,
        nostorage: bool,
        incompletes: bool,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_block_profile<'life0, 'async_trait>(
        &'life0 self,
        file: String,
        seconds: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_chaindb_compact<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_chaindb_property<'life0, 'async_trait>(
        &'life0 self,
        property: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_cpu_profile<'life0, 'async_trait>(
        &'life0 self,
        file: String,
        seconds: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_db_ancient<'life0, 'async_trait>(
        &'life0 self,
        kind: String,
        number: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_db_ancients<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_db_get<'life0, 'async_trait>(
        &'life0 self,
        key: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_dump_block<'life0, 'async_trait>(
        &'life0 self,
        number: BlockId,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_free_os_memory<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_freeze_client<'life0, 'async_trait>(
        &'life0 self,
        node: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_gc_stats<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_get_accessible_state<'life0, 'async_trait>(
        &'life0 self,
        from: BlockNumberOrTag,
        to: BlockNumberOrTag,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_get_modified_accounts_by_hash<'life0, 'async_trait>(
        &'life0 self,
        start_hash: B256,
        end_hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_get_modified_accounts_by_number<'life0, 'async_trait>(
        &'life0 self,
        start_number: u64,
        end_number: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_go_trace<'life0, 'async_trait>(
        &'life0 self,
        file: String,
        seconds: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_intermediate_roots<'life0, 'async_trait>(
        &'life0 self,
        block_hash: B256,
        opts: Option<GethDebugTracingCallOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_mem_stats<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_mutex_profile<'life0, 'async_trait>(
        &'life0 self,
        file: String,
        nsec: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_preimage<'life0, 'async_trait>(
        &'life0 self,
        hash: B256,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_print_block<'life0, 'async_trait>(
        &'life0 self,
        number: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_seed_hash<'life0, 'async_trait>(
        &'life0 self,
        number: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_set_block_profile_rate<'life0, 'async_trait>(
        &'life0 self,
        rate: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_set_gc_percent<'life0, 'async_trait>(
        &'life0 self,
        v: i32,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_set_head<'life0, 'async_trait>(
        &'life0 self,
        number: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_set_mutex_profile_fraction<'life0, 'async_trait>(
        &'life0 self,
        rate: i32,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_set_trie_flush_interval<'life0, 'async_trait>(
        &'life0 self,
        interval: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_stacks<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_standard_trace_bad_block_to_file<'life0, 'async_trait>(
        &'life0 self,
        block: BlockNumberOrTag,
        opts: Option<GethDebugTracingCallOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_standard_trace_block_to_file<'life0, 'async_trait>(
        &'life0 self,
        block: BlockNumberOrTag,
        opts: Option<GethDebugTracingCallOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_start_cpu_profile<'life0, 'async_trait>(
        &'life0 self,
        file: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_start_go_trace<'life0, 'async_trait>(
        &'life0 self,
        file: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_stop_cpu_profile<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_stop_go_trace<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_storage_range_at<'life0, 'async_trait>(
        &'life0 self,
        block_hash: B256,
        tx_idx: usize,
        contract_address: Address,
        key_start: B256,
        max_result: u64,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_trace_bad_block<'life0, 'async_trait>(
        &'life0 self,
        block_hash: B256,
        opts: Option<GethDebugTracingCallOptions>,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_verbosity<'life0, 'async_trait>(
        &'life0 self,
        level: usize,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_vmodule<'life0, 'async_trait>(
        &'life0 self,
        pattern: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_write_block_profile<'life0, 'async_trait>(
        &'life0 self,
        file: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_write_mem_profile<'life0, 'async_trait>(
        &'life0 self,
        file: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn debug_write_mutex_profile<'life0, 'async_trait>(
        &'life0 self,
        file: String,
    ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided method
    fn into_rpc(self) -> RpcModule<Self> { ... }
}

Server trait implementation for the DebugApi RPC API.

Required Methods

fn raw_header<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an RLP-encoded header.

fn raw_block<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = RpcResult<Bytes>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an RLP-encoded block.

fn raw_transaction<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<Option<Bytes>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a EIP-2718 binary-encoded transaction.

If this is a pooled EIP-4844 transaction, the blob sidecar is included.

fn raw_transactions<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Bytes>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an array of EIP-2718 binary-encoded transactions for the given [BlockId].

fn raw_receipts<'life0, 'async_trait>( &'life0 self, block_id: BlockId, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Bytes>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an array of EIP-2718 binary-encoded receipts.

fn bad_blocks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Block>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns an array of recent bad blocks that the client has seen on the network.

fn debug_trace_chain<'life0, 'async_trait>( &'life0 self, start_exclusive: BlockNumberOrTag, end_inclusive: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<BlockTraceResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the structured logs created during the execution of EVM between two blocks (excluding start) as a JSON object.

fn debug_trace_block<'life0, 'async_trait>( &'life0 self, rlp_block: Bytes, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<TraceResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The debug_traceBlock method will return a full stack trace of all invoked opcodes of all transaction that were included in this block.

This expects an rlp encoded block

Note, the parent of this block must be present, or it will fail. For the second parameter see [GethDebugTracingOptions] reference.

fn debug_trace_block_by_hash<'life0, 'async_trait>( &'life0 self, block: B256, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<TraceResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Similar to debug_traceBlock, debug_traceBlockByHash accepts a block hash and will replay the block that is already present in the database. For the second parameter see [GethDebugTracingOptions].

fn debug_trace_block_by_number<'life0, 'async_trait>( &'life0 self, block: BlockNumberOrTag, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<TraceResult>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Similar to debug_traceBlockByHash, debug_traceBlockByNumber accepts a block number [BlockNumberOrTag] and will replay the block that is already present in the database. For the second parameter see [GethDebugTracingOptions].

fn debug_trace_transaction<'life0, 'async_trait>( &'life0 self, tx_hash: B256, opts: Option<GethDebugTracingOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<GethTrace>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The debug_traceTransaction debugging method will attempt to run the transaction in the exact same manner as it was executed on the network. It will replay any transaction that may have been executed prior to this one before it will finally attempt to execute the transaction that corresponds to the given hash.

fn debug_trace_call<'life0, 'async_trait>( &'life0 self, request: TransactionRequest, block_id: Option<BlockId>, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<GethTrace>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The debug_traceCall method lets you run an eth_call within the context of the given block execution using the final state of parent block as the base.

The first argument (just as in eth_call) is a transaction request. The block can optionally be specified either by hash or by number as the second argument. The trace can be configured similar to debug_traceTransaction, see [GethDebugTracingOptions]. The method returns the same output as debug_traceTransaction.

fn debug_trace_call_many<'life0, 'async_trait>( &'life0 self, bundles: Vec<Bundle>, state_context: Option<StateContext>, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<Vec<Vec<GethTrace>>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The debug_traceCallMany method lets you run an eth_callMany within the context of the given block execution using the final state of parent block as the base followed by n transactions.

The first argument is a list of bundles. Each bundle can overwrite the block headers. This will affect all transaction in that bundle. BlockNumber and transaction_index are optional. Transaction_index specifies the number of tx in the block to replay and -1 means all transactions should be replayed. The trace can be configured similar to debug_traceTransaction. State override apply to all bundles.

This methods is similar to many eth_callMany, hence this returns nested lists of traces. Where the length of the outer list is the number of bundles and the length of the inner list (Vec<GethTrace>) is the number of transactions in the bundle.

fn debug_execution_witness<'life0, 'async_trait>( &'life0 self, block: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = RpcResult<ExecutionWitness>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The debug_executionWitness method allows for re-execution of a block with the purpose of generating an execution witness. The witness comprises of a map of all hashed trie nodes to their preimages that were required during the execution of the block, including during state root recomputation.

The first argument is the block number or block hash.

fn debug_backtrace_at<'life0, 'life1, 'async_trait>( &'life0 self, location: &'life1 str, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sets the logging backtrace location. When a backtrace location is set and a log message is emitted at that location, the stack of the goroutine executing the log statement will be printed to stderr.

fn debug_account_range<'life0, 'async_trait>( &'life0 self, block_number: BlockNumberOrTag, start: Bytes, max_results: u64, nocode: bool, nostorage: bool, incompletes: bool, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Enumerates all accounts at a given block with paging capability. maxResults are returned in the page and the items have keys that come after the start key (hashed address).

If incompletes is false, then accounts for which the key preimage (i.e: the address) doesn’t exist in db are skipped. NB: geth by default does not store preimages.

fn debug_block_profile<'life0, 'async_trait>( &'life0 self, file: String, seconds: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Turns on block profiling for the given duration and writes profile data to disk. It uses a profile rate of 1 for most accurate information. If a different rate is desired, set the rate and write the profile manually using debug_writeBlockProfile.

fn debug_chaindb_compact<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Flattens the entire key-value database into a single level, removing all unused slots and merging all keys.

fn debug_chaindb_property<'life0, 'async_trait>( &'life0 self, property: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns leveldb properties of the key-value database.

fn debug_cpu_profile<'life0, 'async_trait>( &'life0 self, file: String, seconds: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Turns on CPU profiling for the given duration and writes profile data to disk.

fn debug_db_ancient<'life0, 'async_trait>( &'life0 self, kind: String, number: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieves an ancient binary blob from the freezer. The freezer is a collection of append-only immutable files. The first argument kind specifies which table to look up data from. The list of all table kinds are as follows:

fn debug_db_ancients<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the number of ancient items in the ancient store.

fn debug_db_get<'life0, 'async_trait>( &'life0 self, key: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the raw value of a key stored in the database.

fn debug_dump_block<'life0, 'async_trait>( &'life0 self, number: BlockId, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieves the state that corresponds to the block number and returns a list of accounts (including storage and code).

fn debug_free_os_memory<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Forces garbage collection.

fn debug_freeze_client<'life0, 'async_trait>( &'life0 self, node: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Forces a temporary client freeze, normally when the server is overloaded.

fn debug_gc_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns garbage collection statistics.

fn debug_get_accessible_state<'life0, 'async_trait>( &'life0 self, from: BlockNumberOrTag, to: BlockNumberOrTag, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the first number where the node has accessible state on disk. This is the post-state of that block and the pre-state of the next block. The (from, to) parameters are the sequence of blocks to search, which can go either forwards or backwards.

Note: to get the last state pass in the range of blocks in reverse, i.e. (last, first).

fn debug_get_modified_accounts_by_hash<'life0, 'async_trait>( &'life0 self, start_hash: B256, end_hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all accounts that have changed between the two blocks specified. A change is defined as a difference in nonce, balance, code hash, or storage hash. With one parameter, returns the list of accounts modified in the specified block.

fn debug_get_modified_accounts_by_number<'life0, 'async_trait>( &'life0 self, start_number: u64, end_number: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns all accounts that have changed between the two blocks specified. A change is defined as a difference in nonce, balance, code hash or storage hash.

fn debug_go_trace<'life0, 'async_trait>( &'life0 self, file: String, seconds: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Turns on Go runtime tracing for the given duration and writes trace data to disk.

fn debug_intermediate_roots<'life0, 'async_trait>( &'life0 self, block_hash: B256, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Executes a block (bad- or canon- or side-), and returns a list of intermediate roots: the stateroot after each transaction.

fn debug_mem_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns detailed runtime memory statistics.

fn debug_mutex_profile<'life0, 'async_trait>( &'life0 self, file: String, nsec: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Turns on mutex profiling for nsec seconds and writes profile data to file. It uses a profile rate of 1 for most accurate information. If a different rate is desired, set the rate and write the profile manually.

fn debug_preimage<'life0, 'async_trait>( &'life0 self, hash: B256, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the preimage for a sha3 hash, if known.

fn debug_print_block<'life0, 'async_trait>( &'life0 self, number: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Retrieves a block and returns its pretty printed form.

fn debug_seed_hash<'life0, 'async_trait>( &'life0 self, number: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<B256>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetches and retrieves the seed hash of the block by number.

fn debug_set_block_profile_rate<'life0, 'async_trait>( &'life0 self, rate: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the rate (in samples/sec) of goroutine block profile data collection. A non-zero rate enables block profiling, setting it to zero stops the profile. Collected profile data can be written using debug_writeBlockProfile.

fn debug_set_gc_percent<'life0, 'async_trait>( &'life0 self, v: i32, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the garbage collection target percentage. A negative value disables garbage collection.

fn debug_set_head<'life0, 'async_trait>( &'life0 self, number: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the current head of the local chain by block number. Note, this is a destructive action and may severely damage your chain. Use with extreme caution.

fn debug_set_mutex_profile_fraction<'life0, 'async_trait>( &'life0 self, rate: i32, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the rate of mutex profiling.

fn debug_set_trie_flush_interval<'life0, 'async_trait>( &'life0 self, interval: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Configures how often in-memory state tries are persisted to disk. The interval needs to be in a format parsable by a time.Duration. Note that the interval is not wall-clock time. Rather it is accumulated block processing time after which the state should be flushed.

fn debug_stacks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns a printed representation of the stacks of all goroutines.

fn debug_standard_trace_bad_block_to_file<'life0, 'async_trait>( &'life0 self, block: BlockNumberOrTag, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Used to obtain info about a block.

fn debug_standard_trace_block_to_file<'life0, 'async_trait>( &'life0 self, block: BlockNumberOrTag, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

This method is similar to debug_standardTraceBlockToFile, but can be used to obtain info about a block which has been rejected as invalid (for some reason).

fn debug_start_cpu_profile<'life0, 'async_trait>( &'life0 self, file: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Turns on CPU profiling indefinitely, writing to the given file.

fn debug_start_go_trace<'life0, 'async_trait>( &'life0 self, file: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Starts writing a Go runtime trace to the given file.

fn debug_stop_cpu_profile<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stops an ongoing CPU profile.

fn debug_stop_go_trace<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stops writing the Go runtime trace.

fn debug_storage_range_at<'life0, 'async_trait>( &'life0 self, block_hash: B256, tx_idx: usize, contract_address: Address, key_start: B256, max_result: u64, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the storage at the given block height and transaction index. The result can be paged by providing a maxResult to cap the number of storage slots returned as well as specifying the offset via keyStart (hash of storage key).

fn debug_trace_bad_block<'life0, 'async_trait>( &'life0 self, block_hash: B256, opts: Option<GethDebugTracingCallOptions>, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Returns the structured logs created during the execution of EVM against a block pulled from the pool of bad ones and returns them as a JSON object. For the second parameter see TraceConfig reference.

fn debug_verbosity<'life0, 'async_trait>( &'life0 self, level: usize, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the logging verbosity ceiling. Log messages with level up to and including the given level will be printed.

fn debug_vmodule<'life0, 'async_trait>( &'life0 self, pattern: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Sets the logging verbosity pattern.

fn debug_write_block_profile<'life0, 'async_trait>( &'life0 self, file: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Writes a goroutine blocking profile to the given file.

fn debug_write_mem_profile<'life0, 'async_trait>( &'life0 self, file: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Writes an allocation profile to the given file.

fn debug_write_mutex_profile<'life0, 'async_trait>( &'life0 self, file: String, ) -> Pin<Box<dyn Future<Output = RpcResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Writes a goroutine blocking profile to the given file.

Provided Methods

fn into_rpc(self) -> RpcModule<Self>

Collects all the methods and subscriptions defined in the trait and adds them into a single RpcModule.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors