arbtrace_filter | Arbitrum

Arbitrum API method that allows to retrieve internal transaction data by defining a specific filter object. Arbitrum via Chainstack.

POST /66f812de2a6724a75a51f60dd6f2a154

arbtrace_filter

cURL

curl --request POST \
  --url https://nd-954-882-037.p2pify.com/66f812de2a6724a75a51f60dd6f2a154 \
  --header 'Content-Type: application/json' \
  --data '
{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "arbtrace_filter",
  "params": [
    {
      "fromBlock": "0xE4E1C0",
      "toBlock": "0xE4E1C2"
    }
  ]
}
'

200

{
  "jsonrpc": "<string>",
  "id": 123,
  "result": {}
}

Arbitrum API method that allows to retrieve internal transaction data by defining a specific filter object. This method is a powerful tool for gaining insight into the intricate operations of complex transactions, particularly those associated with smart contracts. It provides you with the capability to seamlessly access all internal transactions connected to a particular address within a predefined block range.

Learn how to deploy a node with the debug and trace API methods enabled.

Blocks older than 22,207,815 were added to the chain before the Nitro migration and cannot be queried with Geth debug_* methods. Starting from block 22,207,815, Arbitrum migrated to Nitro which made Geth debug_* methods available for newer blocks.

Use the arbtrace_filter method for calling blocks prior to 22,207,815.

Get your own node endpoint today

Start for free and get your app to production levels immediately. No credit card required.

You can sign up with your GitHub, X, Google, or Microsoft account.

Parameters

• object — the filter object used for specifying the following filter criteria:
  • fromBlock — (optional) specifies the starting block from which to retrieve data.
  • toBlock — (optional) specifies the ending block until which data should be retrieved.
  • fromaddress — (optional) array of addresses of the senders from which the transactions should be filtered.
  • toaddress — (optional) array of addresses of the receivers to which the transactions should be filtered.
  • after — (optional) specifies the offset trace number to start retrieving traces.
  • count — (optional) specifies the number of traces to display in a batch.

Response

• array — represents the block traces, which consist of the following fields (note that all return types are hexadecimal representations unless otherwise stated):
• action — represents the ParityTrace object, which provides details on the following:
  • from — indicates the address of the sender.
  • callType — specifies the type of method used, such as call or delegatecall.
  • gas — represents the gas provided by the sender, encoded in hexadecimal.
  • input — contains the data sent along with the transaction.
  • to — specifies the address of the receiver.
  • value — indicates the value sent with this transaction, encoded as an integer in hexadecimal.
• blockHash — provides the hash of the block where this transaction was included.
• blockNumber — represents the block number in which this transaction was included.
• result — refers to the ParityTraceResult object, which includes the following information:
  • gasUsed — represents the amount of gas used by this specific transaction alone.
  • output — contains the value returned by the contract call. It includes the actual value sent by the RETURN method. If the RETURN method was not executed, the output is empty bytes.
• subtraces — represents the traces of contract calls made by the transaction.
• traceAddress — specifies the list of addresses where the call executed, including the address of the parents and the order of the current sub-call.
• transactionHash — refers to the hash of the transaction.
• transactionPosition — indicates the position of the transaction.
• type — specifies the type of method used, such as call or create.

arbtrace_filter code examples

ethers.js

const ethers = require('ethers');
const NODE_URL = "YOUR_CHAINSTACK_ENDPOINT";
const provider = new ethers.JsonRpcProvider(NODE_URL);

const arbtraceFilter = async () => {
    const filter = {
        "fromBlock": "0xE4E1C0",
        "toBlock": "0xE4E1C2",
        "fromaddress": ["0x9e6ef7f75ad88d4edb4c9925c94b769c5b0d6281"],
      };

    const traces = await provider.send("arbtrace_filter", [filter]);
    console.log(traces);
};

arbtraceFilter();

Use case

The arbtrace_filter method on the Arbitrum blockchain allows you to retrieve detailed traces of smart contract execution. Think of traces as a step-by-step account of what happens when a smart contract is called or interacts with other contracts.

With this method, you can specify filter criteria, such as the range of blocks you’re interested in. When you invoke the arbtrace_filter method, it returns traces that match your criteria.

Traces are useful for various purposes. For example, you can debug smart contract transactions by analyzing the sequence of function calls, state changes, and events emitted during execution. This helps you identify and fix issues in your contract’s logic.

Traces also provide insights into gas consumption, allowing you to optimize gas usage in your contracts by identifying gas-intensive operations.

Body

application/json

id · integer · default: 1

jsonrpc · string · default: 2.0

method · string · default: arbtrace_filter

params · object[]

Show child attributes

Response

200 - application/json

The result of the arbtrace_filter method.

jsonrpc · string

id · integer

result · object