Creating Programs

Learn how to create and compile Aleo programs using snarkVM

This guide walks through creating and compiling Aleo programs with snarkVM. Programs define the logic for zero-knowledge applications on the Aleo blockchain.

Program Structure

Aleo programs are written in the Leo/Aleo language and define functions, mappings, and records. Here’s a basic structure:

program hello.aleo;

mapping account:
    key as address.public;
    value as u64.public;

record token:
    owner as address.private;
    amount as u64.private;

function initialize:
    input r0 as address.private;
    input r1 as u64.private;
    cast r0 r1 into r2 as token.record;
    output r2 as token.record;

Parsing Programs

Use the Program::from_str method to parse program source code:

use snarkvm_synthesizer::Program;
use snarkvm_console::network::MainnetV0;

type CurrentNetwork = MainnetV0;

let program_source = r"
program testing.aleo;

struct message:
    amount as u128;

mapping account:
    key as address.public;
    value as u64.public;

record token:
    owner as address.private;
    amount as u64.private;

function compute:
    input r0 as message.private;
    input r1 as u64.public;
    add r0.amount r1 into r2;
    output r2 as u128.public;
";

// Parse the program
let program = Program::<CurrentNetwork>::from_str(program_source)?;

Program IDs must be unique on the network. Use a descriptive name followed by .aleo.

Validating Programs

Once parsed, you can access program components:

// Get the program ID
let program_id = program.id();
println!("Program ID: {}", program_id);

// Iterate over functions
for (function_name, function) in program.functions() {
    println!("Function: {}", function_name);
}

// Access mappings
for (mapping_name, mapping) in program.mappings() {
    println!("Mapping: {}", mapping_name);
}

Compiling Programs with the VM

The VM compiles programs by generating proving and verifying keys:

Program Imports

Programs can import other programs that are already deployed:

import credits.aleo;

program my_program.aleo;

function transfer_wrapper:
    input r0 as address.public;
    input r1 as u64.public;
    call credits.aleo/transfer_public r0 r1 into r2;
    output r2 as credits.aleo/transfer_public.future;

Imported programs must be deployed to the network before your program can reference them.

Error Handling

Common compilation errors:

match Program::<CurrentNetwork>::from_str(program_source) {
    Ok(program) => {
        println!("Program parsed successfully");
    }
    Err(e) => {
        eprintln!("Parse error: {}", e);
        // Handle specific errors:
        // - Syntax errors in the program
        // - Invalid types or operations
        // - Duplicate definitions
    }
}

Best Practices

Use Meaningful Names

// Good: descriptive function names
function calculate_reward:
    input r0 as u64.public;
    mul r0 100u64 into r1;
    output r1 as u64.public;

// Avoid: unclear abbreviations
function calc_r:
    input r0 as u64.public;
    mul r0 100u64 into r1;
    output r1 as u64.public;

Document Complex Logic

Include comments in your program source to explain complex operations, especially in finalize blocks.

Test Incrementally

Start with simple functions and test them before adding complexity. Use the VM to execute test cases.

Optimize for Constraints

Zero-knowledge proofs have computational costs. Minimize operations in functions to reduce proving time:

• Avoid unnecessary multiplications
• Use efficient data structures
• Keep functions focused and modular

Program Editions

Starting with consensus version V9, programs support editions for upgrades:

program my_program.aleo;

constructor:
    assert.eq edition 1u16;

This allows deploying updated versions of programs while maintaining the same program ID.

Next Steps

• Learn about deploying programs to the network
• Explore executing transactions with your programs
• Understand managing records created by your programs