> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chainstack.com/llms.txt
> Use this file to discover all available pages before exploring further.
## Submitting Feedback
If you encounter incorrect, outdated, or confusing documentation on this page, submit feedback:
POST https://docs.chainstack.com/feedback
```json
{
"path": "/reference/arbitrum-arbtrace-replayblocktransactions",
"feedback": "Description of the issue"
}
```
Only submit feedback when you have something specific and actionable to report.
# arbtrace_replayBlockTransactions | Arbitrum
Arbitrum API method that replays all the transactions within a specific block and returns the traces. Developers can use the `arbtrace_replayBlockTransactions` method to gain insight into the behavior of smart contracts within a block, analyze gas usage, and optimize their contracts accordingly.
Learn how to [deploy a node](/docs/debug-and-trace-apis#ethereum) 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_replayBlockTransactions` method for calling blocks prior to 22,207,815.
**Get your own node endpoint today**
[Start for free](https://console.chainstack.com/) 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
* `quantity` — the integer of a block, encoded as hexadecimal or the string.
* `array` — an array identifying the type of tracer and its configuration:
* `trace` — tracer that captures information on all call frames executed during a transaction. The resulting nested list of call frames is organized into a tree structure that reflects the way the Ethereum Virtual Machine works and can be used for debugging and analysis purposes.
## Response
* `output` — the data returned as a result of the transaction, encoded in hexadecimal format.
* `stateDiff` — reveals changes to the state resulting from the execution of the given transaction.
* `trace` — the basic trace of specific information.
* `action` — the operation to be performed on the recipient.
* `from` — the address initiating the transaction.
* `callType` — the type of method, such as `call` or `delegatecall`.
* `gas` — the units of gas supplied by the sender, encoded in hexadecimal format.
* `input` — the data transmitted along with the transaction, typically used for interaction with smart contracts.
* `to` — the recipient's address. If it's a contract creation transaction, this field is `null`.
* `value` — the amount sent with the transaction, encoded as a hexadecimal.
* `result` — the value of the gas price used, encoded as hexadecimal.
* `gasUsed` — the total amount of gas used by all the transactions in the block, encoded as hexadecimal.
* `output` — the return value from the contract call, encoded in hexadecimal. If the `RETURN` method isn't executed, the output will be empty bytes.
* `subtraces` — a list of contract calls made by the transaction, each represented as a nested `call`frame object.
* `traceAddress` — a list of addresses where the call was executed, the addresses of the parent calls, and the order of the current sub-call.
* `type` — the value of the method, such as `call` or `create`.
* `vmTrace` — a comprehensive trace of the virtual machine's state during the execution of a given transaction, including any sub-calls.
* `destroyedContracts` — a list of the smart contract destroyed during the block execution; `null` if no contract was destroyed.
## `arbtrace_replayBlockTransactions` code examples
```javascript web3.js theme={"system"}
const Web3 = require("web3");
const NODE_URL = "YOUR_CHAINSTACK_ENDPOINT";
const web3 = new Web3(NODE_URL);
// Define the arbtrace_get custom method
web3.extend({
property: 'arbtrace',
methods: [{
name: 'replayBlockTransactions',
call: 'arbtrace_replayBlockTransactions',
params: 2,
}],
});
async function replayBlockTransactions() {
const block = "0xE4E1C0";
const traceOptions = ["trace"];
try {
const result = await web3.arbtrace.replayBlockTransactions(block, traceOptions);
console.log(result);
} catch (error) {
console.error("Error:", error);
}
}
replayBlockTransactions();
```
```javascript ethers.js theme={"system"}
const ethers = require('ethers');
const NODE_URL = "YOUR_CHAINSTACK_ENDPOINT";
const provider = new ethers.JsonRpcProvider(NODE_URL);
const arbtraceReplayBlockTransactions = async () => {
const block = '0xE4E1C0'
const tracer = 'trace';
const traces = await provider.send("arbtrace_replayBlockTransactions", [block, [tracer]]);
console.log(traces);
};
arbtraceReplayBlockTransactions();
```
```python web3.py theme={"system"}
from web3 import Web3
node_url = "YOUR_CHAINSTACK_ENDPOINT"
web3 = Web3.HTTPProvider(node_url)
block = "0xE4E1C0";
traceOptions = ["trace"];
response = web3.provider.make_request('arbtrace_replayBlockTransactions', [transactionHash, traceOptions])
print(response)
```
## Use case
The `arbtrace_replayBlockTransactions` allows you to replay the transactions within a specific block and retrieve detailed execution traces for each transaction. It is particularly useful for analyzing the state changes and interactions that occurred during the execution of transactions within a block.
Here are the key points to understand about the `arbtrace_replayBlockTransactions` method:
* Retrieving execution traces — the method replays the transactions within a block and returns execution traces for each transaction. These traces provide a detailed account of the state changes, internal transactions, and events triggered during the execution.
* Block-level analysis — the method focuses on a specific block and replays all the transactions within that block. It is different from individual transaction tracing methods, as it provides a comprehensive view of the interactions and effects of multiple transactions within a single block.
* Contextual understanding — by using `arbtrace_replayBlockTransactions`, developers can gain a deeper understanding of the sequence and effects of transactions within a block. This can be valuable for debugging complex interactions, analyzing reentrancy issues, or understanding the overall impact of transactions on the blockchain state.
## OpenAPI
````yaml /openapi/arbitrum_node_api/debug_and_trace/arbtrace_replayBlockTransactions.json POST /66f812de2a6724a75a51f60dd6f2a154
openapi: 3.0.0
info:
title: Chainstack Node API
version: 1.0.3
description: >-
This is an API for interacting with a Chainstack node using the
arbtrace_replayBlockTransactions method.
servers:
- url: https://nd-954-882-037.p2pify.com
security: []
paths:
/66f812de2a6724a75a51f60dd6f2a154:
post:
tags:
- upload
summary: arbtrace_replayBlockTransactions
operationId: arbtraceReplayBlockTransactions
requestBody:
required: true
content:
application/json:
schema:
type: object
properties:
id:
type: integer
default: 1
jsonrpc:
type: string
default: '2.0'
method:
type: string
default: arbtrace_replayBlockTransactions
params:
type: array
items:
anyOf:
- type: string
title: Block Identifier
- type: array
items:
type: string
title: Options Array
default:
- '0xE4E1C0'
- - trace
responses:
'200':
description: The replayed block transactions' traces.
content:
application/json:
schema:
type: object
properties:
jsonrpc:
type: string
id:
type: integer
result:
type: object
````