Struct DebugApi 

pub struct DebugApi<Eth: RpcNodeCore> { /* private fields */ }

debug API implementation.

This type provides the functionality for handling debug related requests.

Implementations

impl<Eth> DebugApi<Eth>

where Eth: RpcNodeCore,

pub fn new( eth_api: Eth, blocking_task_guard: BlockingTaskGuard, executor: &Runtime, stream: impl Stream<Item = ConsensusEngineEvent<Eth::Primitives>> + Send + Unpin + 'static, ) -> Self

Create a new instance of the DebugApi

pub fn eth_api(&self) -> &Eth

Access the underlying Eth API.

pub fn provider(&self) -> &Eth::Provider

Access the underlying provider.

impl<Eth> DebugApi<Eth>

where Eth: TraceExt,

pub async fn debug_trace_raw_block( &self, rlp_block: Bytes, opts: GethDebugTracingOptions, ) -> Result<Vec<TraceResult>, Eth::Error>

Replays the given block and returns the trace of each transaction.

This expects a rlp encoded block

Note, the parent of this block must be present, or it will fail.

The block is supplied by the caller, so its replay is bounded by a timeout of 30 seconds: no transaction starts after it expires, the request then fails with EthApiError::ExecutionTimedOut. The replay retains its tracing permit until the running transaction finishes.

pub async fn debug_trace_block( &self, block_id: BlockId, opts: GethDebugTracingOptions, ) -> Result<Vec<TraceResult>, Eth::Error>

Replays a block and returns the trace of each transaction.

pub async fn debug_trace_transaction( &self, tx_hash: B256, opts: GethDebugTracingOptions, ) -> Result<GethTrace, Eth::Error>

Trace the transaction according to the provided options.

Ref: https://geth.ethereum.org/docs/developers/evm-tracing/built-in-tracers

pub async fn debug_trace_call( &self, call: RpcTxReq<Eth::NetworkTypes>, block_id: Option<BlockId>, opts: GethDebugTracingCallOptions, ) -> Result<GethTrace, Eth::Error>

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.

If tx_index is provided in opts, the call will be traced at the state after executing transactions up to the specified index within the block (0-indexed). If not provided, then uses the post-state (default behavior).

Differences compare to eth_call:

• debug_traceCall executes with enabled basefee check, eth_call does not: https://github.com/paradigmxyz/reth/issues/6240

pub async fn debug_trace_call_many( &self, bundles: Vec<Bundle<RpcTxReq<Eth::NetworkTypes>>>, state_context: Option<StateContext>, opts: Option<GethDebugTracingCallOptions>, ) -> Result<Vec<Vec<GethTrace>>, Eth::Error>

The debug_traceCallMany method lets you run an eth_callMany within the context of the given block execution using the first n transactions in the given block as base. Each following bundle increments block number by 1 and block timestamp by 12 seconds

pub async fn debug_execution_witness_by_block_hash( &self, hash: B256, mode: Option<ExecutionWitnessMode>, ) -> Result<ExecutionWitness, Eth::Error>

Generates an execution witness for the given block hash. see Self::debug_execution_witness for more info.

pub async fn debug_execution_witness( &self, block_id: BlockId, mode: Option<ExecutionWitnessMode>, ) -> Result<ExecutionWitness, Eth::Error>

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.

pub async fn debug_execution_witness_for_block( &self, block: Arc<RecoveredBlock<ProviderBlock<Eth::Provider>>>, mode: ExecutionWitnessMode, ) -> Result<ExecutionWitness, Eth::Error>

Generates an execution witness, using the given recovered block.

pub async fn debug_account_at( &self, block_id: BlockId, tx_index: Index, address: Address, ) -> Result<Option<Account>, Eth::Error>

Returns account information, including the storage root, after replaying the block through the transaction at the given index.

pub async fn debug_account_info_at( &self, block_id: BlockId, tx_index: Index, address: Address, ) -> Result<Option<AccountInfo>, Eth::Error>

Returns account information after replaying the block through the transaction at the given index.

pub async fn debug_code_by_hash( &self, hash: B256, block_id: Option<BlockId>, ) -> Result<Option<Bytes>, Eth::Error>

Returns the code associated with a given hash at the specified block ID. If no code is found, it returns None. If no block ID is provided, it defaults to the latest block.

pub async fn intermediate_roots( &self, block_hash: B256, ) -> Result<Vec<B256>, Eth::Error>

Executes a block and returns the state root after each transaction.

The block is either canonical or a bad block the engine rejected. Execution stops at the first transaction that is invalid on top of its predecessors, so the result for a bad block holds the roots before that transaction.

Trait Implementations

impl<Eth: RpcNodeCore> Clone for DebugApi<Eth>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Eth: RpcNodeCore> Debug for DebugApi<Eth>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Eth> DebugApiServer<<<Eth as EthApiTypes>::NetworkTypes as RpcTypes>::TransactionRequest> for DebugApi<Eth>

where Eth: EthTransactions + TraceExt,

async fn raw_header(&self, block_id: BlockId) -> RpcResult<Bytes>

Handler for debug_getRawHeader

async fn raw_block(&self, block_id: BlockId) -> RpcResult<Bytes>

Handler for debug_getRawBlock

async fn raw_block_access_list(&self, block_id: BlockId) -> RpcResult<Bytes>

Handler for debug_getRawBlockAccessList

async fn raw_transaction(&self, hash: B256) -> RpcResult<Option<Bytes>>

Handler for debug_getRawTransaction

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

Returns the bytes of the transaction for the given hash.

async fn raw_transactions(&self, block_id: BlockId) -> RpcResult<Vec<Bytes>>

Handler for debug_getRawTransactions Returns the bytes of the transaction for the given hash.

async fn raw_receipts(&self, block_id: BlockId) -> RpcResult<Vec<Bytes>>

Handler for debug_getRawReceipts

async fn bad_blocks(&self) -> RpcResult<Vec<Value>>

Handler for debug_getBadBlocks

async fn debug_clear_txpool(&self) -> RpcResult<()>

Handler for debug_clearTxpool

async fn debug_subscribe( &self, pending: PendingSubscriptionSink, subscription: String, start_exclusive: BlockNumberOrTag, end_inclusive: BlockNumberOrTag, opts: Option<GethDebugTracingOptions>, ) -> SubscriptionResult

Handler for debug_subscribe("traceChain", ...).

async fn debug_trace_block( &self, rlp_block: Bytes, opts: Option<GethDebugTracingOptions>, ) -> RpcResult<Vec<TraceResult>>

Handler for debug_traceBlock

async fn debug_trace_block_by_hash( &self, block: B256, opts: Option<GethDebugTracingOptions>, ) -> RpcResult<Vec<TraceResult>>

Handler for debug_traceBlockByHash

async fn debug_trace_block_by_number( &self, block: BlockNumberOrTag, opts: Option<GethDebugTracingOptions>, ) -> RpcResult<Vec<TraceResult>>

Handler for debug_traceBlockByNumber

async fn debug_trace_transaction( &self, tx_hash: B256, opts: Option<GethDebugTracingOptions>, ) -> RpcResult<GethTrace>

Handler for debug_traceTransaction

async fn debug_trace_call( &self, request: RpcTxReq<Eth::NetworkTypes>, block_id: Option<BlockId>, opts: Option<GethDebugTracingCallOptions>, ) -> RpcResult<GethTrace>

Handler for debug_traceCall

async fn debug_execution_witness( &self, block: BlockId, mode: Option<ExecutionWitnessMode>, ) -> RpcResult<ExecutionWitness>

Handler for debug_executionWitness

async fn debug_execution_witness_by_block_hash( &self, hash: B256, mode: Option<ExecutionWitnessMode>, ) -> RpcResult<ExecutionWitness>

Handler for debug_executionWitnessByBlockHash

async fn debug_account_at( &self, block_id: BlockId, tx_index: Index, address: Address, ) -> RpcResult<Option<Account>>

Handler for debug_accountAt

async fn debug_account_info_at( &self, block_id: BlockId, tx_index: Index, address: Address, ) -> RpcResult<Option<AccountInfo>>

Handler for debug_accountInfoAt

async fn debug_db_get(&self, key: String) -> RpcResult<Option<Bytes>>

debug_db_get - database key lookup

Currently supported:

• Contract bytecode associated with a code hash. The key format is: <0x63><code_hash>

  • Prefix byte: 0x63 (required)
  • Code hash: 32 bytes

  Must be provided as either:

  • Hex string: “0x63…” (66 hex characters after 0x)
  • Raw byte string: raw byte string (33 bytes)

  See Geth impl: https://github.com/ethereum/go-ethereum/blob/737ffd1bf0cbee378d0111a5b17ae4724fb2216c/core/rawdb/schema.go#L120

async fn debug_trace_call_many( &self, bundles: Vec<Bundle<RpcTxReq<Eth::NetworkTypes>>>, state_context: Option<StateContext>, opts: Option<GethDebugTracingCallOptions>, ) -> RpcResult<Vec<Vec<GethTrace>>>

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.

async fn debug_account_range( &self, _block_number: BlockNumberOrTag, _start: Bytes, _max_results: u64, _nocode: bool, _nostorage: bool, _incompletes: bool, ) -> RpcResult<()>

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).

async fn debug_chaindb_compact(&self) -> RpcResult<()>

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

async fn debug_chain_config(&self) -> RpcResult<ChainConfig>

Returns the current chain config.

async fn debug_chaindb_property(&self, _property: String) -> RpcResult<()>

Returns leveldb properties of the key-value database.

async fn debug_code_by_hash( &self, hash: B256, block_id: Option<BlockId>, ) -> RpcResult<Option<Bytes>>

Returns the code associated with a given hash at the specified block ID. If no block ID is provided, it defaults to the latest block.

async fn debug_db_ancient(&self, _kind: String, _number: u64) -> RpcResult<()>

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:

async fn debug_db_ancients(&self) -> RpcResult<()>

Returns the number of ancient items in the ancient store.

async fn debug_dump_block(&self, _number: BlockId) -> RpcResult<()>

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

async fn debug_free_os_memory(&self) -> RpcResult<()>

Forces garbage collection.

async fn debug_gc_stats(&self) -> RpcResult<()>

Returns garbage collection statistics.

async fn debug_get_accessible_state( &self, _from: BlockNumberOrTag, _to: BlockNumberOrTag, ) -> RpcResult<()>

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.

async fn debug_get_modified_accounts_by_hash( &self, _start_hash: B256, _end_hash: B256, ) -> RpcResult<()>

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.

async fn debug_get_modified_accounts_by_number( &self, _start_number: u64, _end_number: u64, ) -> RpcResult<()>

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.

async fn debug_intermediate_roots( &self, block_hash: B256, _opts: Option<GethDebugTracingCallOptions>, ) -> RpcResult<Vec<B256>>

Executes a canonical or bad block, and returns a list of intermediate roots: the stateroot after each transaction up to the first invalid one.

async fn debug_mem_stats(&self) -> RpcResult<()>

Returns detailed runtime memory statistics.

async fn debug_preimage(&self, _hash: B256) -> RpcResult<()>

Returns the preimage for a sha3 hash, if known.

async fn debug_print_block(&self, _number: u64) -> RpcResult<()>

Retrieves a block and returns its pretty printed form.

async fn debug_seed_hash(&self, _number: u64) -> RpcResult<B256>

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

async fn debug_set_gc_percent(&self, _v: i32) -> RpcResult<()>

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

async fn debug_set_head(&self, _number: U64) -> RpcResult<()>

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.

async fn debug_set_trie_flush_interval( &self, _interval: String, ) -> RpcResult<()>

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.

async fn debug_standard_trace_bad_block_to_file( &self, _block: BlockNumberOrTag, _opts: Option<GethDebugTracingCallOptions>, ) -> RpcResult<()>

Used to obtain info about a block.

async fn debug_standard_trace_block_to_file( &self, _block: BlockNumberOrTag, _opts: Option<GethDebugTracingCallOptions>, ) -> RpcResult<()>

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).

async fn debug_state_root_with_updates( &self, hashed_state: HashedPostState, block_id: Option<BlockId>, ) -> RpcResult<(B256, TrieUpdates)>

Returns the state root of the HashedPostState on top of the state for the given block with trie updates.

async fn debug_storage_range_at( &self, _block_hash: B256, _tx_idx: usize, _contract_address: Address, _key_start: B256, _max_result: u64, ) -> RpcResult<()>

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).

async fn debug_trace_bad_block( &self, block_hash: B256, opts: Option<GethDebugTracingCallOptions>, ) -> RpcResult<Vec<TraceResult>>

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 into_rpc(self) -> RpcModule<Self>

where TxReq: Send + Sync + 'static + DeserializeOwned,

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

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 8 bytes