The Complete Guide to Leo Programming Language for Private Smart…

The Complete Guide to Leo Programming Language for Private Smart Contracts

March 31st, 2025

Leo is a domain-specific programming language for building private smart contracts on the Aleo blockchain. Designed with developer ergonomics and security in mind, it combines:

Static typing (Rust-like syntax)
Built-in zk-SNARKs support
Full integration with Aleo Virtual Machine (snarkVM)

Installing Leo

Requirements:

Rust 1.65+

Ubuntu 20.04+/macOS Monterey+

curl -L https://aleo.org/install_leo.sh | bash

leo --version

2. Leo Project Structure

Standard project layout:

my_contract/
├── program.json       # Configuration
├── inputs/            # Input data
│   └── hello.in       # Sample input file
├── src/
│   └── main.leo       # Main code
└── outputs/           # Generated files

3. Core Syntax

3.1. Data Types

// Primitive types
let boolean: bool = true;
let integer: u32 = 42;
let field: field = 0x1234field; // Finite field element
let group: group = 0x1234group; // Elliptic curve

// Composite types
struct Person {
    age: u8,
    address: address
}

// Arrays
let arr: [u8; 3] = [1, 2, 3];

3.2. Functions and Private Computation

function private add_one(private x: u32) -> u32 {
    return x + 1;
}

// Public wrapper function
function add_one_public(x: u32) -> u32 {
    return add_one(x);
}

3.3. Control Flow

function max(a: u32, b: u32) -> u32 {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

4. Working with Private Data

4.1. Encryption/Decryption

// Data encryption
function encrypt_data(
    private data: field,
    public key: group
) -> field {
    let encrypted = data + hash_to_field(key);
    return encrypted;
}

4.2. Age Verification Proof

struct Citizen {
    age: u8,
    ssn_hash: field
}

function verify_age(
    private citizen: Citizen,
    public min_age: u8
) -> bool {
    return citizen.age >= min_age;
}

5. Complete Example: Private Auction

program private_auction.aleo {
    // Auction state
    struct Auction {
        highest_bid: u64,
        bidder: address,
        is_open: bool
    }

    // Place bid
    transition bid(
        private current_auction: Auction,
        private new_bid: u64,
        private bidder: address
    ) -> Auction {
        // Validate conditions
        assert(current_auction.is_open);
        assert(new_bid > current_auction.highest_bid);

        // Update state
        let new_auction = Auction {
            highest_bid: new_bid,
            bidder: bidder,
            is_open: true
        };

        return new_auction;
    }

    // Close auction
    transition close(
        private auction: Auction,
        public owner: address
    ) -> (address, u64) {
        assert(auction.is_open);
        let closed_auction = Auction {
            is_open: false,
            ..auction
        };

        return (auction.bidder, auction.highest_bid);
    }
}