program arcanetoken_v2_0.aleo;

struct BalanceKey:
    token_id as u64;
    addr as address;

struct SpenderKey:
    token_id as u64;
    funds_owner as address;
    spender as address;

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

struct ArcaneTokenInfo:
    token_id as u64;
    decimals as u8;
    max_supply as u128;
    admin as address;

mapping arcane_registered_tokens:
    key as u64.public;
    value as ArcaneTokenInfo.public;

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

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

mapping arcane_supplies:
    key as u64.public;
    value as u128.public;

function create_arcane_token:
    input r0 as u64.private;
    input r1 as u8.private;
    input r2 as u128.private;
    cast r0 r1 r2 self.caller into r3 as ArcaneTokenInfo;
    async create_arcane_token r3 into r4;
    output r4 as arcanetoken_v2_0.aleo/create_arcane_token.future;
finalize create_arcane_token:
    input r0 as ArcaneTokenInfo.public;
    contains arcane_registered_tokens[r0.token_id] into r1;
    not r1 into r2;
    assert.eq r2 true;
    set r0 into arcane_registered_tokens[r0.token_id];

function allow:
    input r0 as u64.private;
    input r1 as address.private;
    input r2 as u128.private;
    async allow r0 self.caller r1 r2 into r3;
    output r3 as arcanetoken_v2_0.aleo/allow.future;
finalize allow:
    input r0 as u64.public;
    input r1 as address.public;
    input r2 as address.public;
    input r3 as u128.public;
    contains arcane_registered_tokens[r0] into r4;
    assert.eq r4 true;
    cast r0 r1 r2 into r5 as SpenderKey;
    hash.bhp256 r5 into r6 as field;
    set r3 into arcane_allowances[r6];

function split:
    input r0 as ArcaneToken.record;
    input r1 as address.private;
    input r2 as u128.private;
    input r3 as address.private;
    cast r1 r0.token_id r2 into r4 as ArcaneToken.record;
    sub r0.amount r2 into r5;
    cast r3 r0.token_id r5 into r6 as ArcaneToken.record;
    output r4 as ArcaneToken.record;
    output r6 as ArcaneToken.record;

function mint_private:
    input r0 as u64.private;
    input r1 as address.private;
    input r2 as u128.private;
    cast r1 r0 r2 into r3 as ArcaneToken.record;
    async mint_private r0 self.caller r2 into r4;
    output r3 as ArcaneToken.record;
    output r4 as arcanetoken_v2_0.aleo/mint_private.future;
finalize mint_private:
    input r0 as u64.public;
    input r1 as address.public;
    input r2 as u128.public;
    get arcane_registered_tokens[r0] into r3;
    is.eq r3.admin r1 into r4;
    cast 0field into r5 as address;
    is.eq r3.admin r5 into r6;
    or r4 r6 into r7;
    assert.eq r7 true;
    get.or_use arcane_supplies[r0] 0u128 into r8;
    add r8 r2 into r9;
    is.eq r3.max_supply 0u128 into r10;
    lte r9 r3.max_supply into r11;
    or r10 r11 into r12;
    assert.eq r12 true;
    set r9 into arcane_supplies[r0];

function mint_public:
    input r0 as u64.private;
    input r1 as address.private;
    input r2 as u128.private;
    cast r0 r1 into r3 as BalanceKey;
    hash.bhp256 r3 into r4 as field;
    async mint_public r0 self.caller r4 r2 into r5;
    output r5 as arcanetoken_v2_0.aleo/mint_public.future;
finalize mint_public:
    input r0 as u64.public;
    input r1 as address.public;
    input r2 as field.public;
    input r3 as u128.public;
    get arcane_registered_tokens[r0] into r4;
    is.eq r4.admin r1 into r5;
    cast 0field into r6 as address;
    is.eq r4.admin r6 into r7;
    or r5 r7 into r8;
    assert.eq r8 true;
    get.or_use arcane_balances[r2] 0u128 into r9;
    add r9 r3 into r10;
    set r10 into arcane_balances[r2];
    get.or_use arcane_supplies[r0] 0u128 into r11;
    add r11 r3 into r12;
    is.eq r4.max_supply 0u128 into r13;
    lte r12 r4.max_supply into r14;
    or r13 r14 into r15;
    assert.eq r15 true;
    set r12 into arcane_supplies[r0];

function burn_private:
    input r0 as ArcaneToken.record;
    input r1 as u128.private;
    cast r0.owner r0.token_id r1 into r2 as ArcaneToken.record;
    async burn_private r0.token_id r1 into r3;
    output r2 as ArcaneToken.record;
    output r3 as arcanetoken_v2_0.aleo/burn_private.future;
finalize burn_private:
    input r0 as u64.public;
    input r1 as u128.public;
    get arcane_registered_tokens[r0] into r2;
    get.or_use arcane_supplies[r0] 0u128 into r3;
    sub r3 r1 into r4;
    is.eq r2.max_supply 0u128 into r5;
    gte r4 0u128 into r6;
    or r5 r6 into r7;
    assert.eq r7 true;
    set r4 into arcane_supplies[r0];

function transfer_public_from:
    input r0 as u64.private;
    input r1 as address.private;
    input r2 as address.private;
    input r3 as u128.private;
    cast r0 r1 into r4 as BalanceKey;
    hash.bhp256 r4 into r5 as field;
    cast r0 r2 into r6 as BalanceKey;
    hash.bhp256 r6 into r7 as field;
    cast r0 r1 self.caller into r8 as SpenderKey;
    hash.bhp256 r8 into r9 as field;
    async transfer_public_from r5 r7 r9 r3 into r10;
    output r10 as arcanetoken_v2_0.aleo/transfer_public_from.future;
finalize transfer_public_from:
    input r0 as field.public;
    input r1 as field.public;
    input r2 as field.public;
    input r3 as u128.public;
    get arcane_balances[r0] into r4;
    sub r4 r3 into r5;
    set r5 into arcane_balances[r0];
    get.or_use arcane_balances[r1] 0u128 into r6;
    add r6 r3 into r7;
    set r7 into arcane_balances[r1];
    get.or_use arcane_allowances[r2] 0u128 into r8;
    gte r8 r3 into r9;
    assert.eq r9 true;

function transfer_public:
    input r0 as u64.private;
    input r1 as address.public;
    input r2 as u128.public;
    cast r0 self.caller into r3 as BalanceKey;
    hash.bhp256 r3 into r4 as field;
    cast r0 r1 into r5 as BalanceKey;
    hash.bhp256 r5 into r6 as field;
    async transfer_public r4 r6 r2 into r7;
    output r7 as arcanetoken_v2_0.aleo/transfer_public.future;
finalize transfer_public:
    input r0 as field.public;
    input r1 as field.public;
    input r2 as u128.public;
    get arcane_balances[r0] into r3;
    sub r3 r2 into r4;
    set r4 into arcane_balances[r0];
    get.or_use arcane_balances[r1] 0u128 into r5;
    add r5 r2 into r6;
    set r6 into arcane_balances[r1];

function transfer_private:
    input r0 as ArcaneToken.record;
    input r1 as address.private;
    input r2 as u128.private;
    cast r1 r0.token_id r2 into r3 as ArcaneToken.record;
    sub r0.amount r2 into r4;
    cast r0.owner r0.token_id r4 into r5 as ArcaneToken.record;
    output r3 as ArcaneToken.record;
    output r5 as ArcaneToken.record;

function transfer_private_to_public:
    input r0 as ArcaneToken.record;
    input r1 as address.private;
    input r2 as u128.private;
    sub r0.amount r2 into r3;
    cast r0.owner r0.token_id r3 into r4 as ArcaneToken.record;
    cast r0.token_id r1 into r5 as BalanceKey;
    hash.bhp256 r5 into r6 as field;
    async transfer_private_to_public r6 r2 into r7;
    output r4 as ArcaneToken.record;
    output r7 as arcanetoken_v2_0.aleo/transfer_private_to_public.future;
finalize transfer_private_to_public:
    input r0 as field.public;
    input r1 as u128.public;
    get.or_use arcane_balances[r0] 0u128 into r2;
    add r2 r1 into r3;
    set r3 into arcane_balances[r0];

function transfer_public_to_private:
    input r0 as u64.private;
    input r1 as address.private;
    input r2 as u128.private;
    cast r1 r0 r2 into r3 as ArcaneToken.record;
    cast r0 self.caller into r4 as BalanceKey;
    hash.bhp256 r4 into r5 as field;
    async transfer_public_to_private r5 r2 into r6;
    output r3 as ArcaneToken.record;
    output r6 as arcanetoken_v2_0.aleo/transfer_public_to_private.future;
finalize transfer_public_to_private:
    input r0 as field.public;
    input r1 as u128.public;
    get arcane_balances[r0] into r2;
    sub r2 r1 into r3;
    set r3 into arcane_balances[r0];

Not implemented