logos-execution-zone/test_programs/guest/src/bin/simple_balance_transfer.rs

use lee_core::program::{AccountPostState, Claim, ProgramInput, ProgramOutput, read_lee_inputs};

type Instruction = u128;

fn main() {
    let (
        ProgramInput {
            self_program_id,
            caller_program_id,
            pre_states,
            instruction: balance,
        },
        instruction_words,
    ) = read_lee_inputs::<Instruction>();

    if let Ok([account_pre]) = <[_; 1]>::try_from(pre_states.clone()) {
        let account_post =
            AccountPostState::new_claimed_if_default(account_pre.account, Claim::Authorized);

        ProgramOutput::new(
            self_program_id,
            caller_program_id,
            instruction_words,
            pre_states,
            vec![account_post],
        )
        .write();
        return;
    }

    let Ok([sender_pre, receiver_pre]) = <[_; 2]>::try_from(pre_states) else {
        return;
    };

    let mut sender_post = sender_pre.account.clone();
    let mut receiver_post = receiver_pre.account.clone();
    sender_post.balance = sender_post
        .balance
        .checked_sub(balance)
        .expect("Not enough balance to transfer");
    receiver_post.balance = receiver_post
        .balance
        .checked_add(balance)
        .expect("Overflow when adding balance");

    ProgramOutput::new(
        self_program_id,
        caller_program_id,
        instruction_words,
        vec![sender_pre, receiver_pre],
        vec![
            AccountPostState::new_claimed_if_default(sender_post, Claim::Authorized),
            AccountPostState::new_claimed_if_default(receiver_post, Claim::Authorized),
        ],
    )
    .write();
}