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

Calculating Transaction Size Before Sending on Ethereum

As a site owner who uses Bitcoins and wants to prevent users from exceeding their bandwidth limits while sending transactions, you’re in a good position to understand how Ethereum works. In this article, we’ll explore the concept of transaction size calculation before sending via the RPC API.

Why Calculate Transaction Size?

In Legacy Non-Segwit (LNW) blockchains like Ethereum Classic (ETC), Bitcoin Cash (BCH), and others, the size of a transaction is determined by its data payload. To prevent users from exceeding their bandwidth limits, it’s essential to calculate the estimated transaction size before sending.

Legacy Non-Segwit Block Height

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

Here’s an example of how to calculate the block height:

const blockchain = {

  blockHeight: null,

  data: {},

};


// Fetch the latest block

async function getLatestBlock() {

  const response = await fetch('

  const data = JSON.parse(response.text);

  // ...

  blockchain.blockHeight = data[0].height;

}


getLatestBlock();

Calculating Transaction Size

Once you have the block height, you can calculate the estimated transaction size by summing up the following components:

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

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

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

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

const txType = 'send';

const inputDataSize = 0; // assume 0 bytes for simplicity


// Estimate the transaction size (in kB)

const estimatedSize = inputDataSize + 10; // add some extra data (e.g., headers, padding)

Example Code

Here’s a simple example of how to estimate the transaction size 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; // assume 0 bytes for simplicity


  // Estimate the transaction size (in kB)

  const estimatedSize = inputDataSize + 10; // add some extra 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, keep in mind:

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

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

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

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