Ethereum: How to calculate transaction size before sending (older non-Segwit versions – P2PKH/P2SH)

Calculating Transaction Size Before Sending on Ethereum

As a site owner who uses Bitcoin and wants to prevent users from exceeding bandwidth limits when sending transactions, you are in a good position to understand how Ethereum works. In this article, we will look at the concept of calculating transaction size before sending via the RPC API.

Why Calculate Transaction Size?

In legacy non-segwit (LNW) blockchains such as Ethereum Classic (ETC), Bitcoin Cash (BCH), and others, the size of a transaction is determined by its payload. To prevent users from exceeding bandwidth limits, it is necessary to calculate the estimated transaction size before sending.

Legacy Non-sequel Block Height

Before calculating the transaction size, you need to know the height of the block the transaction will be sent on. You can get this information by using the eth_blockNumber() function in the RPC API or by querying a Bitcoin index file such as btindex.dat.

Here is an example of calculating the block height:

const blockchain = {
blockHeight: null,
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 estimated transaction size by adding the following components:

• Transaction type: The txType field specifies the transaction type (e.g. send, receive, etc.).

• Input: If your site uses P2PKH or P2SH transactions, you need to calculate the estimated input size.

• Output: If your site uses a different output format, you may need to adjust this calculation accordingly.

Here is an example of how to estimate the transaction size for a send transaction using P2PKH:

const txType = 'send';
const inputDataSize = 0; // for simplicity, assume 0 bytes
// Estimate the transaction size (in kB)
const estimateSize = inputDataSize + 10; // add additional data (e.g. headers, padding)

Sample code

Here is a simple example of how to estimate the size of a transaction using Node.js and the ethers.js library:

const ethers = require('ethers');
async function calculatorTransactionSize(blockHeight) {
const blockchain = await getBlockchain();
const txType = 'send';
const inputDataSize = 0; // for simplicity, assume 0 bytes
// Estimate the size of the transaction (in kB)
const estimateSize = inputDataSize + 10; // add additional data (e.g. headers, padding)
return estimatedSize;
}
async function getBlockchain() {
const response = await fetch('
const data = JSON.parse(response.text);
return blockchain;
}

Best Practices

When calculating transaction size before sending, remember:

• Round up to the nearest kilobyte (kB) for most transactions.

• Add additional data (e.g. headers, padding) as a minimum estimate.

• Consider using a more complex estimation algorithm if you need accurate results.

By following these guidelines and understanding how Ethereum works, you can ensure that your site’s users don’t hit bandwidth limits when sending transactions. Happy coding!