Program Types

pub struct ProgramCore<N: Network> {
    /// The ID of the program
    id: ProgramID<N>,
    /// Declared imports
    imports: IndexMap<ProgramID<N>, Import<N>>,
    /// Program components (mappings, structs, records, closures, functions)
    components: IndexMap<ProgramLabel<N>, ProgramDefinition>,
    /// Optional constructor
    constructor: Option<ConstructorCore<N>>,
    /// Declared mappings
    mappings: IndexMap<Identifier<N>, Mapping<N>>,
    /// Declared structs
    structs: IndexMap<Identifier<N>, StructType<N>>,
    /// Declared record types
    records: IndexMap<Identifier<N>, RecordType<N>>,
    /// Declared closures
    closures: IndexMap<Identifier<N>, ClosureCore<N>>,
    /// Declared functions
    functions: IndexMap<Identifier<N>, FunctionCore<N>>,
}

pub fn new(id: ProgramID<N>) -> Result<Self>

impl FromStr for Program<N> {
    fn from_str(s: &str) -> Result<Self>
}

use snarkvm_synthesizer_program::Program;
use snarkvm_console::network::MainnetV0;

let source = r"
program token.aleo;

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

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

let program = Program::<MainnetV0>::from_str(source)?;

pub fn id(&self) -> &ProgramID<N>

pub fn imports(&self) -> &IndexMap<ProgramID<N>, Import<N>>

pub fn mappings(&self) -> &IndexMap<Identifier<N>, Mapping<N>>

pub fn structs(&self) -> &IndexMap<Identifier<N>, StructType<N>>

pub fn records(&self) -> &IndexMap<Identifier<N>, RecordType<N>>

pub fn closures(&self) -> &IndexMap<Identifier<N>, Closure<N>>

pub fn functions(&self) -> &IndexMap<Identifier<N>, Function<N>>

pub fn credits() -> Result<Self>

pub fn is_reserved_keyword(name: &str) -> bool

pub struct FunctionCore<N: Network> {
    /// The function name
    name: Identifier<N>,
    /// The input statements
    inputs: IndexSet<Input<N>>,
    /// The instructions
    instructions: Vec<Instruction<N>>,
    /// The output statements
    outputs: IndexSet<Output<N>>,
    /// Optional finalize logic
    finalize_logic: Option<FinalizeCore<N>>,
}

pub fn new(name: Identifier<N>) -> Self

pub const fn name(&self) -> &Identifier<N>

pub const fn inputs(&self) -> &IndexSet<Input<N>>

pub fn input_types(&self) -> Vec<ValueType<N>>

pub fn instructions(&self) -> &[Instruction<N>]

pub const fn outputs(&self) -> &IndexSet<Output<N>>

pub fn output_types(&self) -> Vec<ValueType<N>>

pub const fn finalize_logic(&self) -> Option<&FinalizeCore<N>>

pub struct ClosureCore<N: Network> {
    /// The closure name
    name: Identifier<N>,
    /// The input statements
    inputs: IndexSet<Input<N>>,
    /// The instructions
    instructions: Vec<Instruction<N>>,
    /// The output statements
    outputs: IndexSet<Output<N>>,
}

pub fn new(name: Identifier<N>) -> Self

pub const fn name(&self) -> &Identifier<N>

pub const fn inputs(&self) -> &IndexSet<Input<N>>

pub fn instructions(&self) -> &[Instruction<N>]

pub const fn outputs(&self) -> &IndexSet<Output<N>>

pub fn output_types(&self) -> Vec<RegisterType<N>>

pub enum Instruction<N: Network> {
    Abs(Abs<N>),
    AbsWrapped(AbsWrapped<N>),
    Add(Add<N>),
    AddWrapped(AddWrapped<N>),
    And(And<N>),
    AssertEq(AssertEq<N>),
    AssertNeq(AssertNeq<N>),
    Call(Call<N>),
    Cast(Cast<N>),
    CastLossy(CastLossy<N>),
    CommitBHP256(CommitBHP256<N>),
    // ... many more instruction types
}

function compute:
    input r0 as field.private;
    input r1 as field.private;
    add r0 r1 into r2;              // Add instruction
    mul r2 10field into r3;          // Mul instruction
    hash.bhp256 r3 into r4;          // HashBHP256 instruction
    output r4 as field.private;

pub struct FinalizeCore<N: Network> {
    /// The finalize name (matches function name)
    name: Identifier<N>,
    /// The input statements
    inputs: IndexSet<Input<N>>,
    /// The commands (like instructions but for state)
    commands: Vec<Command<N>>,
}

pub enum Command<N: Network> {
    Instruction(Instruction<N>),  // Regular instruction
    Contains(Contains<N>),        // Check if key exists in mapping
    Get(Get<N>),                  // Read from mapping
    GetOrUse(GetOrUse<N>),       // Read from mapping with default
    Set(Set<N>),                  // Write to mapping
    Remove(Remove<N>),            // Delete from mapping
    RandChaCha(RandChaCha<N>),   // Generate random value
    Position(Position<N>),        // Get position in committee
    Branch(Branch<N>),            // Conditional execution
}

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

function transfer_public:
    input r0 as address.public;
    input r1 as u64.public;
    async transfer_public self.caller r0 r1 into r2;
    output r2 as token.aleo/transfer_public.future;

finalize transfer_public:
    input r0 as address.public;  // sender
    input r1 as address.public;  // recipient
    input r2 as u64.public;      // amount
    
    // Deduct from sender
    get balances[r0] into r3;
    sub r3 r2 into r4;
    set r4 into balances[r0];
    
    // Add to recipient
    get.or_use balances[r1] 0u64 into r5;
    add r5 r2 into r6;
    set r6 into balances[r1];

pub struct Mapping<N: Network> {
    /// The mapping name
    name: Identifier<N>,
    /// The key type
    key_type: PlaintextType<N>,
    /// The value type
    value_type: PlaintextType<N>,
}

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

mapping metadata:
    key as field.public;
    value as TokenInfo.public;

struct TokenInfo:
    name as u128.public;
    symbol as u128.public;
    decimals as u8.public;

pub struct Input<N: Network> {
    register: Register<N>,
    value_type: ValueType<N>,  // or RegisterType<N> for closures
}

pub struct Output<N: Network> {
    register: Register<N>,
    value_type: ValueType<N>,  // or RegisterType<N> for closures
}

pub enum ValueType<N: Network> {
    /// A constant value
    Constant(PlaintextType<N>),
    /// A public value
    Public(PlaintextType<N>),
    /// A private value
    Private(PlaintextType<N>),
    /// A record
    Record(Identifier<N>),
    /// An external record
    ExternalRecord(Locator<N>),
    /// A future (for async finalize)
    Future(Locator<N>),
}

pub enum PlaintextType<N: Network> {
    /// A literal type (field, u64, etc.)
    Literal(LiteralType),
    /// A struct type
    Struct(Identifier<N>),
    /// An external struct from another program
    ExternalStruct(Locator<N>),
    /// An array type
    Array(ArrayType<N>),
}

pub enum RegisterType<N: Network> {
    /// A plaintext type
    Plaintext(PlaintextType<N>),
    /// A record
    Record(Identifier<N>),
    /// An external record
    ExternalRecord(Locator<N>),
    /// A future
    Future(Locator<N>),
}

pub fn to_checksum(&self) -> Result<[U8<N>; 32]>

program token.aleo;

// Struct definition
struct TokenInfo:
    name as u128.public;
    symbol as u128.public;
    decimals as u8.public;

// Record definition
record token:
    owner as address.private;
    amount as u64.private;

// Mapping definition
mapping balances:
    key as address.public;
    value as u64.public;

mapping info:
    key as u8.public;
    value as TokenInfo.public;

// Closure (helper function)
closure validate_amount:
    input r0 as u64.private;
    gt r0 0u64 into r1;
    assert.eq r1 true;

// Function with finalize
function transfer_public:
    input r0 as address.public;
    input r1 as u64.public;
    call validate_amount r1;
    async transfer_public self.caller r0 r1 into r2;
    output r2 as token.aleo/transfer_public.future;

finalize transfer_public:
    input r0 as address.public;  // sender
    input r1 as address.public;  // recipient  
    input r2 as u64.public;      // amount
    
    get balances[r0] into r3;
    sub r3 r2 into r4;
    set r4 into balances[r0];
    
    get.or_use balances[r1] 0u64 into r5;
    add r5 r2 into r6;
    set r6 into balances[r1];