program coffer_v003.aleo;

struct WalletInfo:
    wallet_id as field;
    holder1 as address;
    holder2 as address;
    holder3 as address;
    holder4 as address;
    holder5 as address;
    holder6 as address;
    holder7 as address;
    holder8 as address;
    holder9 as address;
    holder_count as u8;
    threshold as u8;

record WalletHolder:
    owner as address.private;
    owner_id as u8.private;
    wallet as WalletInfo.private;

record PendingTransfer:
    owner as address.private;
    transfer_id as field.private;
    creator as address.private;
    wallet as WalletInfo.private;
    token_id as u64.private;
    amount as u128.private;
    to_address as address.private;
    to_wallet_id as field.private;

record SignedTransfer:
    owner as address.private;
    transfer_id as field.private;
    creator as address.private;
    wallet as WalletInfo.private;
    token_id as u64.private;
    amount as u128.private;
    to_address as address.private;
    to_wallet_id as field.private;
    confirmed as boolean.private;

struct WalletBalanceKey:
    wallet_id as field;
    token_id as u64;

struct TransferStatus:
    confirmation_count as u8;
    rejection_count as u8;
    status as u8;

record Token:
    owner as address.private;
    amount as u128.private;
    token_id as u64.private;

struct TokenInfo:
    token_id as u64;
    max_supply as u128;
    decimals as u8;

mapping wallet_exists:
    key as field.public;
    value as boolean.public;

mapping wallet_balances:
    key as field.public;
    value as u128.public;

mapping transfers:
    key as field.public;
    value as TransferStatus.public;

mapping registered_tokens:
    key as u64.public;
    value as TokenInfo.public;

function create_wallet3:
    input r0 as address.private;
    input r1 as address.private;
    input r2 as address.private;
    input r3 as u8.private;
    input r4 as field.private;
    gt r3 0u8 into r5;
    lte r3 3u8 into r6;
    and r5 r6 into r7;
    assert.eq r7 true;
    is.neq r0 r1 into r8;
    assert.eq r8 true;
    cast r4 r0 r1 r2 aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc 3u8 r3 into r9 as WalletInfo;
    cast r0 1u8 r9 into r10 as WalletHolder.record;
    cast r1 2u8 r9 into r11 as WalletHolder.record;
    cast r2 3u8 r9 into r12 as WalletHolder.record;
    async create_wallet3 r4 into r13;
    output r10 as WalletHolder.record;
    output r11 as WalletHolder.record;
    output r12 as WalletHolder.record;
    output r13 as coffer_v003.aleo/create_wallet3.future;
finalize create_wallet3:
    input r0 as field.public;
    get.or_use wallet_exists[r0] false into r1;
    not r1 into r2;
    assert.eq r2 true;
    set true into wallet_exists[r0];

function create_transfer3:
    input r0 as WalletHolder.record;
    input r1 as u64.private;
    input r2 as u128.private;
    input r3 as address.private;
    input r4 as field.private;
    input r5 as field.private;
    is.eq r0.wallet.holder_count 3u8 into r6;
    assert.eq r6 true;
    is.eq r3 aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc into r7;
    is.eq r4 0field into r8;
    or r7 r8 into r9;
    assert.eq r9 true;
    cast r0.wallet.holder1 r5 r0.owner r0.wallet r1 r2 r3 r4 into r10 as PendingTransfer.record;
    cast r0.wallet.holder2 r5 r0.owner r0.wallet r1 r2 r3 r4 into r11 as PendingTransfer.record;
    cast r0.wallet.holder3 r5 r0.owner r0.wallet r1 r2 r3 r4 into r12 as PendingTransfer.record;
    cast r0.owner r0.owner_id r0.wallet into r13 as WalletHolder.record;
    async create_transfer3 r5 into r14;
    output r13 as WalletHolder.record;
    output r10 as PendingTransfer.record;
    output r11 as PendingTransfer.record;
    output r12 as PendingTransfer.record;
    output r14 as coffer_v003.aleo/create_transfer3.future;
finalize create_transfer3:
    input r0 as field.public;
    contains transfers[r0] into r1;
    not r1 into r2;
    assert.eq r2 true;
    cast 1u8 0u8 0u8 into r3 as TransferStatus;
    set r3 into transfers[r0];

function confirm_transfer:
    input r0 as PendingTransfer.record;
    cast r0.owner r0.transfer_id r0.creator r0.wallet r0.token_id r0.amount r0.to_address r0.to_wallet_id true into r1 as SignedTransfer.record;
    async confirm_transfer r0.transfer_id into r2;
    output r1 as SignedTransfer.record;
    output r2 as coffer_v003.aleo/confirm_transfer.future;
finalize confirm_transfer:
    input r0 as field.public;
    get transfers[r0] into r1;
    add r1.confirmation_count 1u8 into r2;
    cast r2 r1.rejection_count r1.status into r3 as TransferStatus;
    set r3 into transfers[r0];

function reject_transfer:
    input r0 as PendingTransfer.record;
    cast r0.owner r0.transfer_id r0.creator r0.wallet r0.token_id r0.amount r0.to_address r0.to_wallet_id false into r1 as SignedTransfer.record;
    async reject_transfer r0.transfer_id into r2;
    output r1 as SignedTransfer.record;
    output r2 as coffer_v003.aleo/reject_transfer.future;
finalize reject_transfer:
    input r0 as field.public;
    get transfers[r0] into r1;
    add r1.rejection_count 1u8 into r2;
    cast r1.confirmation_count r2 r1.status into r3 as TransferStatus;
    set r3 into transfers[r0];

function execute_confirmed_transfer:
    input r0 as SignedTransfer.record;
    is.eq r0.to_wallet_id 0field into r1;
    is.eq r0.to_address aleo1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq3ljyzc into r2;
    or r1 r2 into r3;
    assert.eq r3 true;
    is.eq r0.to_wallet_id 0field into r4;
    ternary r4 r0.amount 0u128 into r5;
    cast r0.to_address r5 r0.token_id into r6 as Token.record;
    is.eq r0.to_wallet_id 0field into r7;
    cast r0.to_wallet_id r6.token_id into r8 as WalletBalanceKey;
    hash.bhp256 r8 into r9 as field;
    ternary r7 0field r9 into r10;
    cast r0.owner r0.transfer_id r0.creator r0.wallet r0.token_id r0.amount r0.to_address r0.to_wallet_id r0.confirmed into r11 as SignedTransfer.record;
    cast r0.wallet.wallet_id r6.token_id into r12 as WalletBalanceKey;
    hash.bhp256 r12 into r13 as field;
    async execute_confirmed_transfer r0.transfer_id r0.wallet.threshold r13 r0.amount r10 into r14;
    output r11 as SignedTransfer.record;
    output r6 as Token.record;
    output r14 as coffer_v003.aleo/execute_confirmed_transfer.future;
finalize execute_confirmed_transfer:
    input r0 as field.public;
    input r1 as u8.public;
    input r2 as field.public;
    input r3 as u128.public;
    input r4 as field.public;
    get transfers[r0] into r5;
    is.eq r5.status 0u8 into r6;
    assert.eq r6 true;
    gte r5.confirmation_count r1 into r7;
    assert.eq r7 true;
    get wallet_balances[r2] into r8;
    sub r8 r3 into r9;
    set r9 into wallet_balances[r2];
    is.eq r4 0field into r10;
    get.or_use wallet_balances[r4] 0u128 into r11;
    add r11 r3 into r12;
    set r12 into wallet_balances[r4];
    cast r5.confirmation_count r5.rejection_count 1u8 into r13 as TransferStatus;
    set r13 into transfers[r0];

function deposit:
    input r0 as Token.record;
    input r1 as u128.private;
    input r2 as field.private;
    sub r0.amount r1 into r3;
    cast r0.owner r3 r0.token_id into r4 as Token.record;
    cast r2 r0.token_id into r5 as WalletBalanceKey;
    hash.bhp256 r5 into r6 as field;
    async deposit r2 r6 r1 into r7;
    output r4 as Token.record;
    output r7 as coffer_v003.aleo/deposit.future;
finalize deposit:
    input r0 as field.public;
    input r1 as field.public;
    input r2 as u128.public;
    contains wallet_exists[r0] into r3;
    assert.eq r3 true;
    get.or_use wallet_balances[r1] 0u128 into r4;
    add r4 r2 into r5;
    set r5 into wallet_balances[r1];

function create_token:
    input r0 as u64.private;
    input r1 as u8.private;
    input r2 as u128.private;
    cast r0 r2 r1 into r3 as TokenInfo;
    async create_token r3 into r4;
    output r4 as coffer_v003.aleo/create_token.future;
finalize create_token:
    input r0 as TokenInfo.public;
    contains registered_tokens[r0.token_id] into r1;
    not r1 into r2;
    assert.eq r2 true;
    set r0 into registered_tokens[r0.token_id];

function mint_private:
    input r0 as address.private;
    input r1 as u64.private;
    input r2 as u128.private;
    pow 10u128 6u8 into r3;
    mul 1000u128 r3 into r4;
    lte r2 r4 into r5;
    assert.eq r5 true;
    cast r0 r2 r1 into r6 as Token.record;
    async mint_private r1 into r7;
    output r6 as Token.record;
    output r7 as coffer_v003.aleo/mint_private.future;
finalize mint_private:
    input r0 as u64.public;
    get registered_tokens[r0] into r1;

Not implemented