Ethereum: Client: How transactions are cleaned from transaction pool as they’re included into blocks (where in client codebase?)

How ​​​​Ethereum Transactions Are Cleared from the Transaction Pool in the Client Codebase

As we delve deeper into the intricacies of the Ethereum client codebases, specifically Geth, cpp-Ethereum, and OpenEthereum, it is essential to understand how transactions are processed within the blockchain. A critical aspect of the client is handling the transaction pool, where incoming transactions are added to blocks for verification and validation.

In this article, we will focus on the process of clearing transactions from the transaction pool in the client codebase, highlighting specific functions and their roles.

Client Codebase Overview

Ethereum client codebases provide a comprehensive implementation of the Ethereum Virtual Machine (EVM) architecture. They are responsible for:

• Transaction Management: Handling incoming transactions, including verification and validation.

• Block Management: Creating new blocks, updating existing ones, and removing them from the blockchain.

Clearing Transactions from the Transaction Pool

Let’s dive into how transactions are processed in the client codebase.

commitWork

commitWork is a function within the eth_blockstore module that commits work for the block. It takes three arguments:

• data: The data for the new block, including transaction IDs and amounts.

• index: The index of the first unspent entry (UI) in the transaction.

• gas_price: The gas price used during transaction verification.

The function clears transactions from the pool by removing them if they do not have enough funds to cover their costs. Specifically, it calls two functions:

• fillTransactions(): This function is responsible for filling the transaction pool with new transactions that can be added to blocks.

• checkFees() and fillFee(): These functions are used to check transaction fees and fill any remaining balance with gas.

fillTransactions()

fillTransactions() is a critical function in purging transactions from the pool. It takes three arguments:

• txs: A list of transactions to be added to the block.

• balance: The current balance in the Ethereum account.

• gasPrice: The gas price used during transaction verification.

The function iterates through each transaction, calculating its costs and available funds. If a transaction has insufficient funds or does not have enough UIs to cover its costs, it is removed from the pool.

checkFees()

checkFees() is called after fillTransactions() to calculate the total transaction fees. It returns an array of fee ranges, allowing the client to decide which transactions should be added to blocks based on their balance and available fees.

fillFee():

fillFee() calculates the remaining balance in the Ethereum account after adding new transactions to the pool. It is used to determine whether any additional transactions can be added or not.

In the Client Codebase

In Geth, cpp-Ethereum, and OpenEthereum, these functions are implemented as follows:

• Geth: In the eth_blockstore module (src/main.rs), commitWork() is called directly from the fillTransactions() function.

• cpp-Ethereum: In the src/main.cpp file, a similar implementation is provided to clear transactions.

• OpenEthereum: The OpenEthereum codebase provides an even more detailed explanation of these functions in its source code (src/main.rs) and implementation (src/eth_blockstore.rs).

In summary, the client codebases perform several steps to clear transactions from the pool:

• commitWork() checks for valid transactions that can be added to blocks.

• fillTransactions(): Iterates through each transaction, calculating its costs and available funds.

• checkFees() calculates the total transaction fees and determines which ones should be added to blocks.

4.