Skip to main content
POST
/
66f812de2a6724a75a51f60dd6f2a154
debug_traceCall
curl --request POST \
  --url https://nd-954-882-037.p2pify.com/66f812de2a6724a75a51f60dd6f2a154 \
  --header 'Content-Type: application/json' \
  --data '
{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "debug_traceCall",
  "params": [
    {
      "to": "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
      "data": "0x70a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"
    },
    "latest",
    {
      "tracer": "callTracer"
    }
  ]
}
'
{
  "jsonrpc": "<string>",
  "id": 123,
  "result": {}
}
Arbitrum API method that traces the execution of eth_call within the context of a specific block’s execution. This method uses the final state of the parent block as its base and allows developers to trace the execution of a particular call without submitting an on-chain transaction.
Learn how to deploy a node with the debug and trace API methods enabled.
This method is available for post-Nitro blocks only (block 22,207,815 and later). For pre-Nitro blocks, use arbtrace_call instead.
Get you own node endpoint todayStart 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 transaction call object:
    • from — (optional) the address used to send the transaction.
    • to — the address to which the transaction is directed, a wallet or a smart contract.
    • gas — (optional) the maximum amount of gas that can be used by the transaction.
    • gasPrice — (optional) the amount of gas price the sender is willing to pay for each gas unit in Wei.
    • value — (optional) the value sent with this transaction, encoded as hexadecimal.
    • data — (optional) additional data to be sent with the call, usually used to invoke functions from smart contracts.
  • quantity or tag — the block number in hex format or block tag (latest, earliest, pending, safe, finalized).
  • object — (optional) an object identifying the type of tracer and its configuration:
    • 4byteTracer — tracer that captures the function signatures and call data sizes.
    • callTracer — tracer that captures information on all call frames executed during a transaction.
    • prestateTracer — tracer with two modes: prestate and diff.
Find a complete list of available built-in tracers in the debug and trace overview.
You can also use additional configuration parameters:
  • disableStorage — when enabled, prevents tracing of storage changes.
  • disableStack — when enabled, skips tracing of stack changes.
  • enableMemory — when false, prevents tracing of memory changes.
  • enableReturnData — when false, prevents tracing of return data.
  • timeout — timeout period for JavaScript-based tracing calls. Default is 5s.
When using one of the built-in tracers, the enableMemory, disableStorage, disableStack, and enableReturnData settings will not have any effect.When no built-in tracer is selected, the response defaults to the Struct/opcode logger.

Response types

callTracer response

  • object — the callTracer traces object:
    • from — the address of the sender who initiated the transaction.
    • gas — the units of gas included in the transaction by the sender.
    • gasUsed — the total used gas by the call, encoded as hexadecimal.
    • to — the address of the recipient of the transaction. For contract creation transactions, this field is null.
    • input — the optional input data sent with the transaction.
    • output — the return value of the call, encoded as a hexadecimal string.
    • error — an error message in case the execution failed.
    • revertReason — the reason why the transaction was reverted, returned by the smart contract if any.
    • calls — a list of sub-calls made by the contract during the call, each represented as a nested call frame object.

4byteTracer response

  • object — the 4byteTracer traces object:
    • result — a map of the function signature, the call data size, and how many times the function was called.

prestateTracer response

  • object — the prestateTracer traces object:
    • smart contract address — the address of the smart contract associated with the result.
      • balance — the balance of the contract, expressed in Wei and encoded as a hexadecimal string.
      • code — the bytecode of the contract, encoded as a hexadecimal string.
      • nonce — the nonce of the account associated with the contract, represented as an unsigned integer.
      • storage — a map of key-value pairs representing the storage slots of the contract.

debug_traceCall code examples

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

const traceCall = async () => {
  const call = {
    to: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
    data: "0x70a08231000000000000000000000000d8da6bf26964af9d7eed9e03e53415d37aa96045"
  };

  const block = "latest";
  const tracer = { tracer: "callTracer" };
  const traces = await provider.send("debug_traceCall", [call, block, tracer]);
  console.log(traces);
};

traceCall();

Use case

A practical use case for the debug_traceCall method is to simulate and trace a smart contract function call without submitting an actual transaction. Developers can use this to inspect internal calls, verify expected behavior, and debug contract interactions before committing transactions on-chain. This is particularly useful for testing complex DeFi interactions on Arbitrum.

Body

application/json
id
integer
default:1
jsonrpc
string
default:2.0
method
string
default:debug_traceCall
params
object · string · object[]

Response

200 - application/json

The result of the debug trace call.

jsonrpc
string
id
integer
result
object
Last modified on March 13, 2026