1. CREATION    → A function outputs a new record
2. ENCRYPTION  → Record is encrypted to the owner's address
3. ON-CHAIN    → Encrypted ciphertext stored in the ledger
4. DISCOVERY   → Owner scans the chain to find their records (using view key)
5. DECRYPTION  → Owner decrypts the record to see its contents
6. CONSUMPTION → Record is used as input to a function (destroyed)
7. NULLIFY     → A serial number is published (prevents replay)
8. NEW RECORDS → Function creates new records as outputs

program auction.aleo {
    @noupgrade
    async constructor() {}

    record Bid {
        owner: address,       // The auctioneer holds all bids
        bidder: address,      // Who placed the bid
        amount: u64,          // Bid amount (hidden from others)
    }

    // Place a bid — creates a record owned by the AUCTIONEER
    // The bidder's amount is hidden from other bidders
    transition place_bid(
        bidder: address,
        amount: u64,
        auctioneer: address,
    ) -> Bid {
        // Verify the caller is the bidder
        assert_eq(self.caller, bidder);

        return Bid {
            owner: auctioneer,     // Auctioneer holds the bid record
            bidder: bidder,
            amount: amount,
        };
    }

    // Resolve two bids — auctioneer compares them privately
    transition resolve(
        first: Bid,
        second: Bid,
    ) -> Bid {
        // Only the auctioneer (record owner) can call this
        assert_eq(self.caller, first.owner);

        // Return the higher bid, now owned by the auctioneer
        if first.amount >= second.amount {
            return Bid {
                owner: first.owner,
                bidder: first.bidder,
                amount: first.amount,
            };
        } else {
            return Bid {
                owner: second.owner,
                bidder: second.bidder,
                amount: second.amount,
            };
        }
    }

    // Finish auction — transfer winning bid record to the winner
    transition finish(winning_bid: Bid) -> Bid {
        // Only the auctioneer can finish
        assert_eq(self.caller, winning_bid.owner);

        // Transfer ownership to the winner
        return Bid {
            owner: winning_bid.bidder,
            bidder: winning_bid.bidder,
            amount: winning_bid.amount,
        };
    }
}

program vote.aleo {
    @noupgrade
    async constructor() {}

    // Public proposal state
    struct Proposal {
        title: field,
        content: field,
        proposer: address,
    }

    mapping proposals: field => Proposal;
    mapping agree_votes: field => u64;
    mapping disagree_votes: field => u64;

    // Private voting capability
    record Ticket {
        owner: address,
        pid: field,   // proposal ID
    }

    // Create a new proposal (public)
    async transition propose(public info: Proposal) -> Future {
        let pid: field = BHP256::hash_to_field(info);
        return finalize_propose(pid, info);
    }

    async function finalize_propose(pid: field, info: Proposal) {
        Mapping::set(proposals, pid, info);
        Mapping::set(agree_votes, pid, 0u64);
        Mapping::set(disagree_votes, pid, 0u64);
    }

    // Issue a voting ticket to a voter (private)
    transition new_ticket(public pid: field, voter: address) -> Ticket {
        return Ticket {
            owner: voter,
            pid: pid,
        };
    }

    // Cast an "agree" vote (consumes ticket, increments public tally)
    async transition agree(ticket: Ticket) -> Future {
        let pid: field = ticket.pid;
        return finalize_agree(pid);
    }

    async function finalize_agree(pid: field) {
        let current: u64 = Mapping::get_or_use(agree_votes, pid, 0u64);
        Mapping::set(agree_votes, pid, current + 1u64);
    }

    // Cast a "disagree" vote
    async transition disagree(ticket: Ticket) -> Future {
        let pid: field = ticket.pid;
        return finalize_disagree(pid);
    }

    async function finalize_disagree(pid: field) {
        let current: u64 = Mapping::get_or_use(disagree_votes, pid, 0u64);
        Mapping::set(disagree_votes, pid, current + 1u64);
    }
}

program commit_reveal.aleo {
    @noupgrade
    async constructor() {}

    mapping commitments: address => field;
    mapping revealed_values: address => u64;

    // Phase 1: COMMIT — hash the secret value with a random salt
    async transition commit(public commitment_hash: field) -> Future {
        let sender: address = self.caller;
        return finalize_commit(sender, commitment_hash);
    }

    async function finalize_commit(sender: address, commitment_hash: field) {
        // Store the commitment (hash of secret + salt)
        Mapping::set(commitments, sender, commitment_hash);
    }

    // Phase 2: REVEAL — provide the original value and salt
    async transition reveal(
        public secret_value: u64,
        public salt: scalar,
    ) -> Future {
        let sender: address = self.caller;
        return finalize_reveal(sender, secret_value, salt);
    }

    async function finalize_reveal(
        sender: address,
        secret_value: u64,
        salt: scalar,
    ) {
        // Recompute the commitment from the revealed values
        let recomputed: field = BHP256::commit_to_field(secret_value, salt);

        // Verify it matches the stored commitment
        let stored: field = Mapping::get(commitments, sender);
        assert_eq(recomputed, stored);

        // Store the revealed value
        Mapping::set(revealed_values, sender, secret_value);

        // Clean up the commitment
        Mapping::remove(commitments, sender);
    }
}

1. User chooses secret_value = 42u64
2. User generates random salt (scalar)
3. User computes commitment = BHP256::commit_to_field(42u64, salt)
4. User calls commit(commitment)
5. Later, user calls reveal(42u64, salt)

Private Key → Compute Key → View Key → Address
     ↓              ↓            ↓          ↓
  Full control  Proving only  Read-only  Public ID

// BAD: amount is now publicly visible on-chain!
async transition bad_transfer(
    token: Token,
    receiver: address,
    public amount: u64,  // This is PUBLIC — everyone sees it!
) -> (Token, Future) { ... }

// GOOD: keep amount private
transition good_transfer(
    token: Token,
    receiver: address,
    amount: u64,  // Private by default
) -> (Token, Token) { ... }

// BAD: everyone can see every user's balance
mapping balances: address => u64;

// GOOD: use records for private balances
record Token { owner: address, amount: u64 }

// BAD: private data becomes public mapping values
async transition bad_log(token: Token) -> Future {
    let amount: u64 = token.amount;
    let caller: address = self.caller;
    return finalize_bad_log(caller, amount); // Amount is now PUBLIC!
}

async function finalize_bad_log(caller: address, amount: u64) {
    Mapping::set(logs, caller, amount);
}

// BAD: self.caller could be an intermediate program, not the user
transition admin_only() {
    assert_eq(self.caller, ADMIN_ADDRESS);
}

// GOOD: use self.signer for user-level access control
transition admin_only() {
    assert_eq(self.signer, ADMIN_ADDRESS);
}

// BAD: amount is visible on-chain in the transaction
record Token {
    owner: address,
    public amount: u64,  // Anyone can see this!
}

// GOOD: keep amount private
record Token {
    owner: address,
    amount: u64,  // Private by default
}