Ethereum: Client: How are transactions purged from the transaction pool when included in blocks (where in the client codebase?)

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

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

In this article, we will focus on the transaction pool clearing process 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 deleting 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 in the eth_blockstore module that commits work to a block. It takes three arguments:

• data: Data for the new block, including transaction identifiers and values.

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

• gas_price: The gas price used during transaction verification.

The function clears transactions from the pool, 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 top up the remaining balance with gas.

fillTransactions()

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

• txs: List of transactions to be added to the block.

• balance: Current balance in the Ethereum account.

• gasPrice: Gas price used during transaction verification.

The function iterates over 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 available balance and fees.

fillFee():

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

In the client code base

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 file src/main.cpp, a similar implementation is provided for clearing transactions.

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

In summary, client codebases perform different steps to clean up transactions from the pool:

• commitWork() checks if transactions are valid and can be added to blocks.

• fillTransactions(): iterates over each transaction, calculating its costs and available funds.

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

4.