Arbitrum API method that returns the number of transactions sent from an address at the selected block. This value is also called nonce
. It is an important piece of information, especially to ensure that a transaction is not sent twice.
Get you 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
-
address
β the address to retrieve the transaction count. -
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.
-
Response
quantity
β an integer value identifying the number of transactions sent from an address at the specified block.
eth_getTransactionCount
code examples
eth_getTransactionCount
code examplesconst Web3 = require("web3");
const NODE_URL = "CHAINSTACK_NODE_URL";
const web3 = new Web3(NODE_URL);
async function getTransactionsCount(address, blockId) {
const count = await web3.eth.getTransactionCount(address, blockId)
console.log(count);
}
getTransactionsCount("0x4f4e13B91C31C6DB330e1c375B9c6f86eAeA411E", 'latest')
const ethers = require('ethers');
const NODE_URL = "CHAINSTACK_NODE_URL";
const provider = new ethers.JsonRpcProvider(NODE_URL);
const getNonce = async (address, blockId) => {
const nonce = await provider.send("eth_getTransactionCount", [address, blockId]);
console.log(nonce);
};
getNonce("0x4f4e13B91C31C6DB330e1c375B9c6f86eAeA411E", "latest")
from web3 import Web3
node_url = "CHAINSTACK_NODE_URL"
web3 = Web3(Web3.HTTPProvider(node_url))
print(web3.eth.get_transaction_count("0x4f4e13B91C31C6DB330e1c375B9c6f86eAeA411E", "latest"))
Use case
One of the most common use cases for eth_getTransactionCount
is to create the transaction object built in a script designed to send a transaction. The nonce field is required, and it is retrieved using the eth_getTransactionCount
method.
The following code shows how to build a rawTransction
using web3.js and ethereumjs-tx.
Security notice
You need your private key to sign the transaction; never share your private key with anyone.
On a side note, the private key in this case must be imported without '0x' at the beginning of the string.
const Web3 = require("web3");
const Tx = require("ethereumjs-tx").Transaction;
const NODE_URL = "CHAINSTACK_NODE_URL";
const web3 = new Web3(NODE_URL);
// Initialize private key
const PRIVATE_KEY = Buffer.from("PRIVATE_KEY", "hex");
// Validate input parameters and return an error message if invalid
const validateInputs = (fromAddress, toAddress) => {
if (!web3.utils.isAddress(fromAddress)) {
throw new Error(`Invalid fromAddress: ${fromAddress}`);
}
if (!web3.utils.isAddress(toAddress)) {
throw new Error(`Invalid toAddress: ${toAddress}`);
}
};
// Async function to create a raw transaction
async function createRawTransaction(fromAddress, toAddress, value) {
validateInputs(fromAddress, toAddress);
const nonce = await web3.eth.getTransactionCount(fromAddress);
const gasPrice = await web3.eth.getGasPrice();
const gasLimit = await web3.eth.estimateGas({
from: fromAddress,
to: toAddress,
});
// Build the transaction object
const transactionObject = {
to: toAddress,
gasPrice: web3.utils.toHex(gasPrice),
gasLimit: web3.utils.toHex(gasLimit),
nonce: web3.utils.toHex(nonce),
value: web3.utils.toHex(value),
};
// Create a new transaction object to sign
const tx = new Tx(transactionObject, { chain: 'mainnet' });
// Sign the transaction using the private key
tx.sign(PRIVATE_KEY);
// Serialize and return the signed transaction as a raw transaction
const serializedTx = tx.serialize();
const rawTransaction = `0x${serializedTx.toString('hex')}`;
return rawTransaction;
}
async function main() {
const rawTransaction = await createRawTransaction('0x4f4e13B91C31C6DB330e1c375B9c6f86eAeA411E', "0xe341b2f448eb190495ed4a89c01f20078b26b0f6" , "100000000000000")
console.log(`Raw transaction: ${rawTransaction}`)
}
main()
In summary, the code creates a valid raw transaction that can be broadcasted to the network.
During the process, the script retrieves important values such as the nonce
, gasPrice
, and gasLimit
, builds a transaction object, and signs it using a private key.
First, the createRawTransaction
function calls validateInputs
to ensure that the fromAddress
and toAddress
parameters are valid addresses. If either of these addresses is invalid, the function throws an error with a descriptive message.
Next, the function makes a call to web3.eth.getTransactionCount
with the fromAddress
as a parameter. This method returns the number of transactions sent from the fromAddress
, and is used as the nonce
for the transaction.
The function retrieves the gasPrice
and gasLimit
for the transaction using web3.eth.getGasPrice
and web3.eth.estimateGas
, respectively. The eth_gasPrice is the amount of gas that the transaction sender is willing to pay per unit of gas consumed by the transaction, while the eth_estimateGas is an estimate of the maximum amount of gas that the transaction will consume.
With the nonce
, gasPrice
, and gasLimit
values, the function builds a transaction object, which includes the toAddress
, gasPrice
, gasLimit
, nonce
, and value
of the transaction. The value is the amount transferred from the fromAddress
to the toAddress
.
The transaction object is then passed to a new Tx
instance, which is signed using the private key. The signed transaction is then serialized and returned as a rawTransaction
, which can be broadcasted to the network to execute the transaction.
Use the eth_getTransactionCount
RPC method yourself
eth_getTransactionCount
RPC method yourself