How Dime Works: Deep Dive into State Transitions & Execution

Technical Overview: The Transaction Lifecycle

To understand the internal mechanics of Dime, we must follow the lifecycle of a single state transition from client generation to global ledger finality.

+---------------+     +------------------+     +--------------------+
|  1. Client    | --> |  2. RPC Ingress  | --> |  3. Mempool &      |
|  Signing      |     |  & Verification  |     |  Gossip Broadcast  |
+---------------+     +------------------+     +--------------------+
                                                         |
                                                         v
+---------------+     +------------------+     +--------------------+
|  6. State     | <-- |  5. Consensus    | <-- |  4. Block Leader   |
|  Commitment   |     |  Voting & Final  |     |  Assembly          |
+---------------+     +------------------+     +--------------------+

Step 1: Deterministic Signing on the Client

Before any data enters the network, it is constructed and signed locally on the client machine.

• The client constructs an instruction payload containing the sender address, destination, nonce (counter to prevent replay attacks), and execution parameters.
• The payload is hashed using a cryptographic hashing algorithm.
• The client signs the hash using their private key, producing an elliptic curve signature.

Key Architectural Principle: The private key never leaves the client device. Only the public signature and the payload are transmitted across the network.

Step 2: RPC Ingress & Initial Filtering

The signed transaction is sent via HTTP POST or WebSocket to a JSON-RPC endpoint hosted by a network node.

1. The node validates the format, byte length, and signature validity.
2. It checks whether the account nonce is sequential and verifies that the account has sufficient state balance to pay for network processing.
3. If valid, the node places the transaction into its local mempool (memory pool of pending transactions).

Step 3: Peer-to-Peer Gossip Propagation

The receiving node broadcasts the transaction to its connected peers using an optimized Gossip Protocol:

• Rather than sending data blindly to every computer in the world, each node forwards messages to a random subset of connected peers.
• Within milliseconds, the transaction propagates across hundreds of geographically dispersed nodes.

Step 4: Block Assembly & State Execution

During a designated time slice (slot), a designated leader node collects pending transactions from the mempool and executes them sequentially or concurrently:

• Transactions modify account balances and state variables.
• The node generates a cryptographic state commitment root (such as a Merkle or Patricia Trie root) representing the updated database snapshot.
• The leader packages the batch into a candidate block and broadcasts it to all active validator nodes.

Step 5: Validator Voting & Finality

Upon receiving the candidate block:

• Validator nodes re-execute the transactions locally to confirm that their calculated state root matches the leader’s proposal exactly.
• If identical, validators broadcast their cryptographic vote.
• When supermajority agreement (e.g., greater than two-thirds of active stake) is reached, the block is finalized and appended to the immutable history.

Summary & Architectural Trade-offs

The Dime architecture balances throughput, validation latency, and hardware accessibility. By decoupling transaction gossip from consensus voting and utilizing deterministic state updates, the protocol achieves rapid finality while maintaining verifiable cryptographic security.