> ## 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.
# eth_call | Arbitrum
> Arbitrum API method that enables instant execution of a new message call without requiring the creation of a transaction on the blockchain.
Arbitrum API method that enables instant execution of a new message call without requiring the creation of a transaction on the blockchain. This can be useful for testing and debugging by simulating transfers or smart contract transactions and retrieving data from the blockchain.
**Disclaimer**
The interactive example in this page uses `eth_call` to call the `owner` method from the [Uniswap V3: Factory smart contract on Arbitrum](https://arbiscan.io/address/0x1F98431c8aD98523631AE4a59f267346ea31F984#code). It returns the address owning the smart contract.
When called against a block older than the latest \~128 blocks, this method is treated as an archive request (2 RUs instead of 1 RU). See [request units](/docs/request-units#evm-methods-affected-by-block-age).
## Parameters
* `object` — the transaction call object:
* `from` — (optional) the string of the address used to send the transaction.
* `to` — the string of 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](https://ethereum.org/en/developers/docs/intro-to-ether/#denominations).
* `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 as a string of the hash of the method signature and encoded parameters. See the [Ethereum Contract ABI](https://solidity.readthedocs.io/en/latest/abi-spec.html).
* `quantity or tag` — the integer of a block encoded as hexadecimal or the string with:
* `latest` — the most recent block in the blockchain and the current state of the blockchain at the most recent block
* `earliest` — the earliest available or genesis block
* `pending` — the pending state and transactions block. The current state of transactions that have been broadcast to the network but have not yet been included in a block.
See the [default block parameter](https://eth.wiki/json-rpc/API#the-default-block-parameter).
### State override (optional)
`eth_call` accepts an optional third parameter: a state override set that changes account state for this call only. Nothing is written to the chain. The set is an object keyed by account address, and each address can override:
* `balance` — the account balance in wei, hex-encoded
* `nonce` — the account nonce, hex-encoded
* `code` — the bytecode to run at the address
* `state` — storage slot values that replace the account's entire storage
* `stateDiff` — storage slot values to change, keeping the rest of the storage
This example puts bytecode that returns `42` at an unused address, then calls that address:
```bash theme={"system"}
curl --request POST \
--url CHAINSTACK_NODE_URL \
--header 'Content-Type: application/json' \
--data '{
"jsonrpc": "2.0",
"id": 1,
"method": "eth_call",
"params": [
{ "to": "0x00000000000000000000000000000000c0ffee42", "data": "0x" },
"latest",
{ "0x00000000000000000000000000000000c0ffee42": { "code": "0x602a60005260206000f3" } }
]
}'
```
```json theme={"system"}
{
"jsonrpc": "2.0",
"id": 1,
"result": "0x000000000000000000000000000000000000000000000000000000000000002a"
}
```
## Response
* `data` — the result of executing the specified call on the Ethereum Virtual Machine (EVM), encoded as a hexadecimal string.
## `eth_call` code examples
The following code snippets provide a clear demonstration of how to simulate a standard ETH transfer between two accounts. Note that when using `eth_call` to simulate a transfer or a smart contract transaction, the sender account must have a sufficient balance to cover the associated gas fee.
```javascript ethers.js theme={"system"}
const ethers = require('ethers');
const NODE_URL = "CHAINSTACK_NODE_URL";
const provider = new ethers.providers.JsonRpcProvider(NODE_URL);
const simulateTransfer = async () => {
try {
// Define the accounts to transfer between
const fromAddress = "0x28165971E4d592CA6C45A3786786Ec2f6b4b8D23";
const toAddress = "0x19e7e376e7c213b7e7e7e46cc70a5dd086daff2a";
// Define the value to transfer
const value = ethers.utils.parseEther("100");
// Build transaction object
const transactionObject = {
from: fromAddress,
to: toAddress,
gasLimit: ethers.utils.hexlify(21000),
value: value
}
// Use eth_call to simulate the transfer on the latest block
const result = await provider.call(transactionObject);
console.log(`Result: ${result}`);
} catch (error) {
console.error(`Error: ${error.message}`);
}
}
simulateTransfer();
```
```python web3.py theme={"system"}
from web3 import Web3
node_url = "CHAINSTACK_NODE_URL"
web3 = Web3(Web3.HTTPProvider(node_url))
# Define the accounts to transfer between
from_address = web3.to_checksum_address('0x28165971E4d592CA6C45A3786786Ec2f6b4b8D23')
to_address = web3.to_checksum_address('0x19e7e376e7c213b7e7e7e46cc70a5dd086daff2a')
# Define the value to transfer (in Ether)
value = web3.to_wei(1, 'ether')
# Build the transaction object
transaction = {
'from': from_address,
'to': to_address,
'gas': 21000, # 21000 is the standard for a regular transfer
'value': value,
'data': '',
}
# Use eth_call to simulate the transfer
result = web3.eth.call(transaction, 'latest')
print(result)
```
Executing this code will produce a return value of `0x`, indicating a successful transaction. This implies that the transaction will be executed without any errors when the code is used to send the transaction.
## Use case
A common use case for `eth_call` is calling smart contract functions. For example, interact with an ERC-20 token smart contract deployed on the Arbitrum network and retrieve the balance of a specific account.
The following code uses the ethers.js library to call the `balanceOf` function of the [UNI token smart contract](https://arbiscan.io/token/0xfa7f8980b0f1e64a2062791cc3b0871572f1f7f0#readProxyContract) on the Arbitrum network.
```javascript index.js theme={"system"}
const ethers = require("ethers");
const NODE_URL = "CHAINSTACK_NODE_URL";
const provider = new ethers.providers.JsonRpcProvider(NODE_URL);
// Contract address and ABI for the token
const CONTRACT_ADDRESS = "0xFa7F8980b0f1E64A2062791cc3b0871572f1F7f0";
const ABI = [
{
"constant": true,
"inputs": [
{
"name": "_owner",
"type": "address"
}
],
"name": "balanceOf",
"outputs": [
{
"name": "balance",
"type": "uint256"
}
],
"payable": false,
"stateMutability": "view",
"type": "function"
}
];
// Asynchronously fetches the balance of an account for the given address
async function getAccountBalance(address) {
try {
// Create a new contract instance
const contract = new ethers.Contract(CONTRACT_ADDRESS, ABI, provider);
// Call the balanceOf function to retrieve the account balance in wei using eth_call
const balanceInWei = await contract.balanceOf(address);
// Convert the balance from wei to ether
const balanceInEth = ethers.formatEther(balanceInWei);
// Log the account balance in ether to the console
console.log(`The account balance for address ${address} is: ${balanceInEth} UNI`);
} catch (error) {
console.error("Error occurred while fetching account balance:", error);
}
}
// Call the getAccountBalance function with a sample account address
getAccountBalance("0x1b72bac3772050fdcaf468cce7e20deb3cb02d89");
```
The `getAccountBalance` function is called with the address of the account whose balance we want to retrieve. This function creates a new contract instance, calls the `balanceOf` function of the smart contract with the provided address, and retrieves the account balance in wei. The balance is then converted to ether using the `formatEther` function of the `ethers` object.
Finally, the account balance is printed on the console for easy viewing.
## OpenAPI
````yaml openapi/arbitrum_node_api/execute_transactions/eth_call.json POST /5b8d22690a57f293b3a1ed8758014e35
openapi: 3.0.0
info:
title: Chainstack Node API
version: 1.0.0
description: This is an API for interacting with a Chainstack node.
servers:
- url: https://nd-000-364-211.p2pify.com
security: []
paths:
/5b8d22690a57f293b3a1ed8758014e35:
post:
tags:
- transactions info
summary: eth_call
operationId: ethCall
requestBody:
required: true
content:
application/json:
schema:
type: object
properties:
jsonrpc:
type: string
default: '2.0'
method:
type: string
default: eth_call
id:
type: integer
default: 1
params:
type: array
items:
type: object
title: Call object
properties:
to:
type: string
description: The address of the contract to call.
data:
type: string
description: The data to send with the call.
default:
- to: '0x1F98431c8aD98523631AE4a59f267346ea31F984'
data: '0x8da5cb5b'
- latest
responses:
'200':
description: The result of the call.
content:
application/json:
schema:
type: object
properties:
jsonrpc:
type: string
id:
type: integer
result:
type: string
````