Understanding NEO Network in Five Pictures

Many users of NEO blockchain are perhaps not fully aware on how their usual asset transactions (or even Dapp game transaction) are stored on NEO. These 5 pictures may help to make the process clear.

The smiling user here (Figure 1) uses its favorite wallet software to sign and submit a transaction, called Tx A (for example, let’s consider a simple Gas transfer transaction, where A is sending some assets to his friend). But how is Tx A submitted to the network? There are two different protocols that could relay such message: Remote Procedure Call (RPC) or Peer-To-Peer (P2P). There are many open nodes that provide public RPC access (the most usual way by means of “sendrawtransaction” RPC call), which are the red nodes.

Figure 1 — User submits Tx A via public RPC node call “sendrawtransaction”

The RPC nodes (red nodes) store the whole Blockchain (currently a few gigabytes), so they know how to validate it and to propagate it to other P2P nodes (blue nodes) via P2P protocol (see Figure 2).

Figure 2 — Tx A is propagated to other nodes via P2P protocol

But why sending a transaction to the whole network? The objective is to reach “special” nodes, called Consensus Nodes (green). These nodes are ellected via voting (every Neo holder has right to vote) and their public keys are known to the whole network. However, their location is not known, in order to avoid attacks. That’s why everyone keeps retransmitting all messages (see Figure 3).

Figure 3 — Transaction is retransmitted until it reaches the Consensus Nodes (green)

Currently, there are seven ellected Consensus Nodes, and they work together in order to reach consensus over which transactions will be allowed to be put on the next block. This protocol called dBFT is not described here on details, but it consists of three rounds of messages (relayed through the network) that guarantee that network will fully operation even if 1/3 of them are faulty or Byzantine (performing with arbitrary behavior). At every 15 seconds, a new block is proposed by a new consensus node, called speaker (one of the seven nodes). This scheme guarantees that no consensus node is more powerful than the others (see Figure 4).

Figure 4 — Speaker proposes a new block that includes Tx A, via P2P protocol

Finally, after 15 seconds (or more, if transaction takes longer to reach the Consensus Nodes), the user may again use a public RPC call to get information regarding the latest blocks. Neo blockchain guarantees One Block Finality, which is a **very awesome thing** (and unique, not existing on other public blockchains), so as long as the user receives a block that includes its transaction, it can rest assured that his transaction will never be reverted from the blockchain (Figure 5).

Figure 5 — User requests information from specific blocks via RPC call “getblock”

I hope this helps understanding the underlying structure of Neo network, but if you want to dig deeper, you can always look into NEO Docs, neo-project github code, or the Community Yellow Paper (there’s an interesting draft chapter on Neo Network including RPC and P2P protocols: https://github.com/NeoResearch/yellowpaper/blob/master/sections/02_Network.md)

Feel free to comment :)