Aleo

Leo is a statically-typed language with a syntax inspired by Rust and JavaScript, designed for safety and clarity. Programs are organized into circuits, which are functions that define the constraints for a zero-knowledge proof. Key structural elements include:

• Program Scope: The main container for functions, structs, and records.
• Functions: Define the application's logic and proof statements.
• Records: Privacy-focused data structures that hold encrypted user state.
• Transitions: Public functions that update the network state, taking input records and producing outputs.

The record is Leo's fundamental unit of private state, analogous to an account in other blockchains. Records are encrypted data structures stored off-chain by users and contain:

• An owner field, specifying who can spend the record.
• A payload of private data (e.g., token balances).
• A nonce for encryption.
• A commitment (cm) and serial number (sn) for zero-knowledge verification. Programs consume input records and produce output records, enabling private state transitions without revealing underlying data on-chain.

Leo abstracts the complexity of zkSNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge). When a Leo program is executed, the Leo compiler does the following:

1. Compiles the high-level code into Aleo Instructions (AVM).
2. Generates a proving key and verification key for the circuit.
3. Creates a proof that a private computation was executed correctly, without revealing the private inputs. This allows developers to write private applications without being cryptography experts.

Development is managed through the Leo Command-Line Interface (CLI), which handles the entire lifecycle of a zkApp. Core commands include:

• leo new: Creates a new project with a standard structure.
• leo build: Compiles the program, generating proving/verification keys and an AVM bytecode file.
• leo run: Executes the program locally with sample inputs, generating a proof and producing a transaction.
• leo execute: Broadcasts the transaction to the Aleo network. The workflow enforces a clean separation between private computation (off-chain) and public verification (on-chain).

Leo code compiles down to Aleo Instructions, the assembly-like bytecode for the Aleo Virtual Machine (AVM). This is the executable format that validators run to verify zero-knowledge proofs. The AVM defines operations for:

• Record Management: split, join, fee.
• Logic & Arithmetic: Basic operations over the Aleo's prime field.
• Program Calls: Interaction with other on-chain programs. Understanding the AVM is key for auditing and optimizing low-level Leo program behavior.

A simple Leo program demonstrating a private transfer of token.aleo.

leoCopy
program token.aleo {
    // Define a record structure for the token.
    record Token {
        owner: address,
        amount: u64,
    }

    // Public transition function to transfer tokens.
    transition transfer_private(
        sender: Token,
        receiver: address,
        amount: u64
    ) -> (Token, Token) {
        // Ensure the sender owns the record and has sufficient balance.
        let remaining: u64 = sender.amount - amount;

        // Create a new record for the sender with the remaining balance.
        let sender_new: Token = Token {
            owner: sender.owner,
            amount: remaining,
        };

        // Create a new record for the receiver.
        let receiver_new: Token = Token {
            owner: receiver,
            amount: amount,
        };

        // Output the two new records.
        return (sender_new, receiver_new);
    }
}

This function consumes one input record and produces two new output records, keeping all balances private.

The cryptographic core of Aleo, enabling private computation. zkSNARKs (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) allow a prover to demonstrate knowledge of a secret (like a transaction's details) without revealing the secret itself. This is fundamental for:

• Private transactions that hide amounts and participants.
• Private smart contracts where logic and state are not publicly visible.
• Off-chain computation with on-chain verification, reducing network load.

The low-level, assembly-like virtual machine that executes programs compiled from Leo. The Aleo Virtual Machine (AVM) operates on Aleo Instructions, which are the fundamental opcodes for private computation. It is responsible for:

• Executing the zero-knowledge proof generation for private state transitions.
• Managing the transition from one private state to another within a program.
• Interfacing with the consensus layer to record proof verification on-chain.

The execution environment for zero-knowledge applications, distinct from the consensus layer (snarkOS). snarkVM is the engine that runs the Aleo Instructions generated by the Leo compiler. It is focused on:

• Proving execution: Generating a ZKP that a program ran correctly with given private inputs.
• Verifying execution: Efficiently checking the validity of a proof.
• This separation of execution (snarkVM) from settlement (snarkOS) is key to Aleo's scalability model.

The native token and unit of account for the Aleo network. Aleo Credits are used to pay for transaction fees, which are fundamentally different from other blockchains. Fees are paid to:

• Provers: For generating the zero-knowledge proofs that validate private state transitions. This incentivizes specialized computing power.
• Validators: For including and verifying transactions in a block via consensus. This model aligns incentives for both the computation (proving) and the security (validation) of the network.

Aleo's consensus mechanism that combines proof-of-work with useful computation. Miners compete to generate valid zk-SNARK proofs for recent transactions, which secures the network and batches transaction verification. This mechanism:

• Incentivizes proof generation, a critical network service.
• Reduces on-chain data footprint through proof aggregation.
• Provides a transition path to more energy-efficient consensus post-initial distribution.

A network of nodes (provers) specialized in generating zero-knowledge proofs for applications. This separates the roles of execution/proving from consensus/validation, creating a scalable marketplace for computation. Provers:

• Earn fees for generating proofs off-chain.
• Enable resource-intensive applications without requiring end-users to have powerful hardware.
• Enhance network scalability by parallelizing proof generation.

The design paradigm central to Aleo, where privacy is a default, programmable feature of the application layer. Unlike privacy coins or mixers, Aleo allows developers to define exactly what data is public, private, or disclosed under certain conditions within a smart contract. This enables:

• Compliance-friendly applications with audit trails.
• Flexible privacy models (e.g., private DeFi, identity credentials).
• User-controlled data disclosure.