Introduction: Deconstructing High-Performance Distributed Ledgers
To understand how high-throughput blockchain networks function, one must look beyond high-level buzzwords and examine the fundamental computational model. Traditional blockchains frequently process state transitions sequentially: each transaction must wait for the preceding one to execute in order to avoid read-write conflicts on shared global storage.
Luno approaches state transition mechanics through an explicit data dependency framework, allowing thousands of transactions to execute simultaneously across multi-core processor architectures. In this guide, we break down the three fundamental pillars of the network: Accounts, Programs (Smart Contracts), and the Transaction Execution Pipeline.
1. The Account Model: State as Data Records
Unlike traditional account-balance ledgers or UTXO (Unspent Transaction Output) models, Luno models everything on-chain as an Account. An account is essentially a structured memory address on the distributed ledger containing:
- Public Key (
PubKey): The 32-byte Ed25519 cryptographic address uniquely identifying the account. - Lamport/Micro-Balance: The native unit of value held within the account, used to fund operations and maintain state storage.
- Owner Program ID: The specific program (executable code) authorized to modify the internal data of this account.
- Data Byte Array: An arbitrary-length binary buffer holding application state (e.g., token balances, voting records, validator settings).
- Executable Flag: A boolean value indicating whether the account contains compiled binary code (a Program) or state data.
┌───────────────────────────────────────────────────┐
│ Luno Account Model │
├───────────────────────────────────────────────────┤
│ PubKey: 32-byte Ed25519 Address │
│ Balance: Numerical Value Buffer │
│ Owner Program: Authorized Executable ID │
│ Executable Flag: true | false │
│ Data Payload: [0x4a, 0x12, 0xff, ... (Borsh)] │
│ Rent/Storage: Exempt / Epoch Allocated │
└───────────────────────────────────────────────────┘
A critical architectural distinction is that programs do not store internal state inside themselves. Instead, programs are stateless executable logic that accept accounts as inputs, deserialize their data payloads, apply mathematical logic, and write updated state back into the accounts.
2. Transactions and Explicit Account Declarations
When a client crafts a transaction on Luno, the payload must explicitly declare every single account that the transaction intends to read from or write to.
Why Explicit Declarations Matter
In traditional virtual machines, the runtime discovers which storage slots are accessed dynamically while the code is running. This creates a synchronization bottleneck: the scheduler cannot know in advance whether Transaction B will conflict with Transaction A, forcing sequential processing.
By requiring transactions to declare their read and write sets upfront, Luno’s scheduler can instantly determine whether two transactions are independent:
- Transaction 1: Reads Account A, Writes Account B
- Transaction 2: Reads Account C, Writes Account D
- Execution Result: Both transactions execute concurrently across separate CPU cores without race conditions.
3. The Instruction Lifecycle
[Client Application]
│
▼ (Signs with Ed25519 Private Key)
[Signed Transaction Payload]
│
▼ (Dispatched via RPC to Current Slot Leader)
[Leader TPU (Transaction Processing Unit)]
├── 1. Signature Verification (GPU / Multi-threaded)
├── 2. Banking Stage (Parallel Account Conflict Scheduling)
└── 3. Execution Pipeline (Invokes Owner Programs)
│
▼ (State State Changes Committed)
[Pipelined Block Broadcast to Validator Mesh]
- Signature Verification: Incoming transaction signatures are verified in bulk using high-throughput vectorized cryptographic routines.
- Banking & Scheduling: The scheduler allocates non-conflicting transactions to available hardware threads.
- Execution: The virtual runtime executes the compiled bytecode, updating account data buffers and checking that cryptographic invariants hold.
- Broadcast: Successful state changes are packaged into streaming block chunks and immediately transmitted across the validator gossip network.
Summary & Next Steps
By separating executable code from state data and demanding explicit memory access declarations, Luno achieves deterministic parallel execution. For a deeper study of how transactions are authenticated and protected, explore our guide on Cryptographic Key Custody & Security Protocols.
