One is MonadBFT consensus algorithm created by Monad, and the other is local mempool #Monad #ETH

Let’s talk about the consensus algorithm first. The figure shows the most traditional synchronous BFT algorithm:

(i) C acts as a client and sends the block transaction message to master node 0 (request)

(ii) 0, as the master node, sends a message to 1, 2, and 3, telling them, “I agree with the transactions in this block. Do you agree?” (pre-prepare/proposed)

(iii) 3 does nothing and does not respond, but 1 and 2 also tell the other 3 nodes that they agree with 0’s proposal. At this point, most nodes actually agree with 0. (prepare/voted)

(iv) 0, 1, and 2 will simultaneously notify other nodes, 'I am going to execute the transactions in this block and write them to the entire state!' At this point, the transaction is completed and finally confirmed (commit/finalized).

(v) 0 tells C, your transaction is finished (reply).

Everyone will find that this process is relatively slow; one block must be finally confirmed before the next block can be confirmed.

As shown in the figure, MonadBFT has transformed traditional BFT into an asynchronous form.

(i) A, as the main node, informs other validating nodes of the message for block N (block N proposed).

(ii) B, as the main node, informs other validating nodes of the message for block N+1, while other nodes prepare for block N (block N+1 proposed, block N voted).

(iii) C, as the main node, informs other validating nodes of the message for block N+2, while other nodes commit block N and prepare for block N+1 (block N+2 proposed, block N+1 voted, block N finalized).

And so on in a similar fashion.

Monad's mechanism for asynchronously reaching Byzantine consensus actually references the HotStuff algorithm.

Let's talk about local mempool again.

Traditional mempools, like BTC and ETH, have a global state storage pool, where everyone tries to reach state consensus as much as possible through P2P Gossip protocols. Moreover, in these two blockchains, the 'next block proposer' is fundamentally unknown or difficult to attack. Bitcoin uses nonce random number calculations, while Ethereum uses RANDAO random numbers and VDF time locks. The reason is that if everyone knows in advance who the next block proposer is, a DOS attack can be launched.

However, Monad believes that many high-performance blockchains, such as those using Tendermint consensus, have validators taking turns as block producers in a fixed order, and the next block producer can naturally see this order directly.

Thus, Monad allows each validator to maintain their own local mempool and only forwards transactions to the nodes 'about to become the block producer (leader)' when submitting transactions. This means that transactions do not need to be broadcasted and retransmitted multiple times across the entire network, but go directly to the relevant leader, significantly reducing redundant network communication.

Clients only need to send transactions to the nodes that will 'become the block producers in the next few rounds,' allowing them to receive these transactions in advance, store them in their local mempool, and directly package them when it's their turn to produce a block.

This way, transactions can be packed into blocks faster, significantly reducing propagation time in the network.

A few days ago, when Monad just opened its testnet, it sparked widespread discussion.

As of now, the Monad testnet has a total of 57 validators responsible for proposing and validating blocks, with an average network TPS exceeding 100, and the official claim of reaching up to 10,000 TPS.

The introduction of MonadDB makes EVM fully compatible, allowing Ethereum programs to transition seamlessly. Monad is undoubtedly a genuine star project; everyone can try interacting with the testnet, and you might achieve significant results.