Calculating Transaction Size Before Sending to Ethereum
As a website owner who uses Bitcoin and wants to prevent users from exceeding bandwidth limits when sending transactions, you may have a good understanding of how Ethereum works. In this article, we will explore the concept of calculating transaction size before sending it via the RPC API.
Why Calculate Transaction Size?
On legacy Non-Segwit (LNW) blockchains such as Ethereum Classic (ETC), Bitcoin Cash (BCH), and others, the transaction size is determined by its payload. To ensure that users do not exceed their bandwidth limits, it is necessary to calculate the expected transaction size before sending.
Legacy Block Height without Segwit
Before calculating the transaction size, you need to know the block height on which the transaction will be sent. You can get this information using the RPC API function eth_blockNumber() or by querying a Bitcoin index file such as btindex.dat.
Here is an example of how to calculate the block height:
const blockchain = {
blockheight: nil,
data: {},
};
// Get the latest block
async function getLatestBlock() {
const response = await fetch('
const data = JSON.parse(response.text);
//...
blockchain.blockHeight = data[0].height;
}
getLatestBlock();
Calculating the transaction size
Once you have the block height, you can calculate the expected transaction size by adding the following components:
- Transaction type: The TxType field specifies the type of transaction (e.g., “send”, “receive”, etc.).
- Input data
: If your site uses P2PKH or P2SH transactions, you need to calculate the expected input data size.
- Output data: If your site uses a different output format, you may need to adjust this calculation accordingly.
Here is an example of calculating the size of a send transaction using P2PKH:
const TXType = 'send';
const inputDataSize = 0; // For simplicity, let's assume 0 bytes
// Approximate transaction size (KB)
const estimated size = inputDataSize + 10; // adding additional data (e.g. headers, padding)
Code example
Here is a simple example of calculating the size of a transaction using Node.js and the ethers.js library:
const ethers = require('ethers');
async function calculateTransactionSize(blockheight) {
const blockchain = await getBlockchain();
const TXType = 'send';
const inputDataSize = 0; // For simplicity, assume 0 bytes
// Approximate transaction size (KB)
const calculatedsize = inputDataSize + 10; // adding additional data (e.g. headers, padding)
return calculatedsize;
}
async function getBlockchain() {
const response = await fetch('
const data = JSON.parse(response.text);
return blockchain;
}
Best Practices
When calculating the transaction size before sending, remember:
- For most transactions, round to the nearest kilobyte (kB).
- Add additional data (e.g. headers, padding) as a minimum estimate.
- If you need accurate results, consider using a more sophisticated estimation algorithm.
By following these guidelines and understanding how Ethereum works, you can ensure that your website users do not exceed their bandwidth limits when sending transactions. Happy coding!