import credits.aleo;

program teststake1x3.aleo;

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

struct Metadata:
    name as field;
    symbol as field;
    decimals as u8;

struct State:
    total_supply as u64;
    total_reserve as u64;
    total_unstaking as u64;
    total_reward as u64;

struct Settings:
    unstake_wait as u32;
    stake_paused as boolean;
    global_paused as boolean;
    max_reward_per_notify as u64;
    protocol_fee as u16;
    fee_account as address;

struct Unstaking:
    microcredits as u64;
    height as u32;

struct ApprovalKey:
    approver as address;
    spender as address;

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

mapping approvals:
    key as field.public;
    value as u64.public;

mapping metadata:
    key as boolean.public;
    value as Metadata.public;

mapping state:
    key as boolean.public;
    value as State.public;

mapping settings:
    key as boolean.public;
    value as Settings.public;

mapping unstakings:
    key as address.public;
    value as Unstaking.public;

mapping admins:
    key as address.public;
    value as boolean.public;

mapping operators:
    key as address.public;
    value as boolean.public;

mapping stakers:
    key as address.public;
    value as boolean.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 teststake1x3.aleo/transfer_public.future;
finalize transfer_public:
    input r0 as address.public;
    input r1 as address.public;
    input r2 as u64.public;
    get account[r0] into r3;
    sub r3 r2 into r4;
    set r4 into account[r0];
    get.or_use account[r1] 0u64 into r5;
    add r5 r2 into r6;
    set r6 into account[r1];

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

function transfer_private_to_public:
    input r0 as PrivateToken.record;
    input r1 as address.public;
    input r2 as u64.public;
    sub r0.amount r2 into r3;
    cast r0.owner r3 into r4 as PrivateToken.record;
    async transfer_private_to_public r1 r2 into r5;
    output r4 as PrivateToken.record;
    output r5 as teststake1x3.aleo/transfer_private_to_public.future;
finalize transfer_private_to_public:
    input r0 as address.public;
    input r1 as u64.public;
    get.or_use account[r0] 0u64 into r2;
    add r2 r1 into r3;
    set r3 into account[r0];

function transfer_public_to_private:
    input r0 as address.private;
    input r1 as u64.public;
    cast r0 r1 into r2 as PrivateToken.record;
    async transfer_public_to_private self.caller r1 into r3;
    output r2 as PrivateToken.record;
    output r3 as teststake1x3.aleo/transfer_public_to_private.future;
finalize transfer_public_to_private:
    input r0 as address.public;
    input r1 as u64.public;
    get account[r0] into r2;
    sub r2 r1 into r3;
    set r3 into account[r0];

function join:
    input r0 as PrivateToken.record;
    input r1 as PrivateToken.record;
    add r0.amount r1.amount into r2;
    cast r0.owner r2 into r3 as PrivateToken.record;
    output r3 as PrivateToken.record;

function stake:
    input r0 as credits.aleo/credits.record;
    input r1 as u64.public;
    input r2 as address.public;
    assert.neq r1 0u64;
    call credits.aleo/transfer_private_to_public r0 aleo1fgsrqlady5cymzadx4pk32kq2n3208y9mf8jdavk8gpnt9crdgrsswnmwq r1 into r3 r4;
    async stake r4 r1 r2 into r5;
    output r3 as credits.aleo/credits.record;
    output r5 as teststake1x3.aleo/stake.future;
finalize stake:
    input r0 as credits.aleo/transfer_private_to_public.future;
    input r1 as u64.public;
    input r2 as address.public;
    await r0;
    get settings[true] into r3;
    assert.eq r3.stake_paused false;
    assert.eq r3.global_paused false;
    get state[true] into r4;
    is.eq r4.total_reserve 0u64 into r5;
    cast r4.total_reserve into r6 as u128;
    ternary r5 1u128 r6 into r7;
    is.eq r4.total_reserve 0u64 into r8;
    cast r1 into r9 as u128;
    cast r4.total_supply into r10 as u128;
    mul r9 r10 into r11;
    div r11 r7 into r12;
    cast r12 into r13 as u64;
    ternary r8 r1 r13 into r14;
    assert.neq r14 0u64;
    add r4.total_supply r14 into r15;
    add r4.total_reserve r1 into r16;
    cast r15 r16 r4.total_unstaking r4.total_reward into r17 as State;
    set r17 into state[true];
    get.or_use account[r2] 0u64 into r18;
    add r18 r14 into r19;
    set r19 into account[r2];

function unstake_token:
    input r0 as u64.public;
    assert.neq r0 0u64;
    async unstake_token self.caller r0 into r1;
    output r1 as teststake1x3.aleo/unstake_token.future;
finalize unstake_token:
    input r0 as address.public;
    input r1 as u64.public;
    get settings[true] into r2;
    assert.eq r2.global_paused false;
    get.or_use account[r0] 0u64 into r3;
    sub r3 r1 into r4;
    set r4 into account[r0];
    get state[true] into r5;
    cast r1 into r6 as u128;
    cast r5.total_reserve into r7 as u128;
    mul r6 r7 into r8;
    cast r5.total_supply into r9 as u128;
    div r8 r9 into r10;
    cast r10 into r11 as u64;
    assert.neq r11 0u64;
    sub r5.total_supply r1 into r12;
    sub r5.total_reserve r11 into r13;
    add r5.total_unstaking r11 into r14;
    cast r12 r13 r14 r5.total_reward into r15 as State;
    set r15 into state[true];
    cast 0u64 0u32 into r16 as Unstaking;
    get.or_use unstakings[r0] r16 into r17;
    add r17.microcredits r11 into r18;
    add block.height r2.unstake_wait into r19;
    cast r18 r19 into r20 as Unstaking;
    set r20 into unstakings[r0];

function unstake_aleo:
    input r0 as u64.public;
    assert.neq r0 0u64;
    async unstake_aleo self.caller r0 into r1;
    output r1 as teststake1x3.aleo/unstake_aleo.future;
finalize unstake_aleo:
    input r0 as address.public;
    input r1 as u64.public;
    get settings[true] into r2;
    assert.eq r2.global_paused false;
    get state[true] into r3;
    cast r1 into r4 as u128;
    cast r3.total_supply into r5 as u128;
    mul r4 r5 into r6;
    cast r3.total_reserve into r7 as u128;
    add r6 r7 into r8;
    sub r8 1u128 into r9;
    cast r3.total_reserve into r10 as u128;
    div r9 r10 into r11;
    cast r11 into r12 as u64;
    assert.neq r12 0u64;
    get.or_use account[r0] 0u64 into r13;
    sub r13 r12 into r14;
    set r14 into account[r0];
    sub r3.total_supply r12 into r15;
    sub r3.total_reserve r1 into r16;
    add r3.total_unstaking r1 into r17;
    cast r15 r16 r17 r3.total_reward into r18 as State;
    set r18 into state[true];
    cast 0u64 0u32 into r19 as Unstaking;
    get.or_use unstakings[r0] r19 into r20;
    add r20.microcredits r1 into r21;
    add block.height r2.unstake_wait into r22;
    cast r21 r22 into r23 as Unstaking;
    set r23 into unstakings[r0];

function withdraw:
    input r0 as u64.public;
    input r1 as address.public;
    assert.neq r0 0u64;
    call credits.aleo/transfer_public r1 r0 into r2;
    async withdraw r2 self.caller r0 into r3;
    output r3 as teststake1x3.aleo/withdraw.future;
finalize withdraw:
    input r0 as credits.aleo/transfer_public.future;
    input r1 as address.public;
    input r2 as u64.public;
    await r0;
    get settings[true] into r3;
    assert.eq r3.global_paused false;
    get unstakings[r1] into r4;
    gte block.height r4.height into r5;
    assert.eq r5 true;
    gte r4.microcredits r2 into r6;
    assert.eq r6 true;
    sub r4.microcredits r2 into r7;
    cast r7 r4.height into r8 as Unstaking;
    set r8 into unstakings[r1];
    get state[true] into r9;
    sub r9.total_unstaking r2 into r10;
    cast r9.total_supply r9.total_reserve r10 r9.total_reward into r11 as State;
    set r11 into state[true];

function withdraw_private:
    input r0 as u64.public;
    input r1 as address.private;
    assert.neq r0 0u64;
    call credits.aleo/transfer_public_to_private r1 r0 into r2 r3;
    async withdraw_private r3 self.caller r0 into r4;
    output r2 as credits.aleo/credits.record;
    output r4 as teststake1x3.aleo/withdraw_private.future;
finalize withdraw_private:
    input r0 as credits.aleo/transfer_public_to_private.future;
    input r1 as address.public;
    input r2 as u64.public;
    await r0;
    get settings[true] into r3;
    assert.eq r3.global_paused false;
    get unstakings[r1] into r4;
    gte block.height r4.height into r5;
    assert.eq r5 true;
    gte r4.microcredits r2 into r6;
    assert.eq r6 true;
    sub r4.microcredits r2 into r7;
    cast r7 r4.height into r8 as Unstaking;
    set r8 into unstakings[r1];
    get state[true] into r9;
    sub r9.total_unstaking r2 into r10;
    cast r9.total_supply r9.total_reserve r10 r9.total_reward into r11 as State;
    set r11 into state[true];

function approve_public:
    input r0 as address.public;
    input r1 as u64.public;
    cast self.caller r0 into r2 as ApprovalKey;
    hash.bhp256 r2 into r3 as field;
    async approve_public r3 r1 into r4;
    output r4 as teststake1x3.aleo/approve_public.future;
finalize approve_public:
    input r0 as field.public;
    input r1 as u64.public;
    get.or_use approvals[r0] 0u64 into r2;
    sub 18446744073709551615u64 r2 into r3;
    lt r1 r3 into r4;
    add.w r2 r1 into r5;
    ternary r4 r5 18446744073709551615u64 into r6;
    set r6 into approvals[r0];

function unapprove_public:
    input r0 as address.public;
    input r1 as u64.public;
    cast self.caller r0 into r2 as ApprovalKey;
    hash.bhp256 r2 into r3 as field;
    async unapprove_public r3 r1 into r4;
    output r4 as teststake1x3.aleo/unapprove_public.future;
finalize unapprove_public:
    input r0 as field.public;
    input r1 as u64.public;
    get approvals[r0] into r2;
    gt r2 r1 into r3;
    sub.w r2 r1 into r4;
    ternary r3 r4 0u64 into r5;
    set r5 into approvals[r0];

function transfer_from_public:
    input r0 as address.public;
    input r1 as address.public;
    input r2 as u64.public;
    cast r0 self.caller into r3 as ApprovalKey;
    hash.bhp256 r3 into r4 as field;
    async transfer_from_public r4 r0 r1 r2 into r5;
    output r5 as teststake1x3.aleo/transfer_from_public.future;
finalize transfer_from_public:
    input r0 as field.public;
    input r1 as address.public;
    input r2 as address.public;
    input r3 as u64.public;
    get approvals[r0] into r4;
    sub r4 r3 into r5;
    set r5 into approvals[r0];
    get account[r1] into r6;
    sub r6 r3 into r7;
    set r7 into account[r1];
    get.or_use account[r2] 0u64 into r8;
    add r8 r3 into r9;
    set r9 into account[r2];

function notify_reward:
    input r0 as u64.public;
    input r1 as u64.public;
    assert.neq r1 0u64;
    async notify_reward self.caller r0 r1 into r2;
    output r2 as teststake1x3.aleo/notify_reward.future;
finalize notify_reward:
    input r0 as address.public;
    input r1 as u64.public;
    input r2 as u64.public;
    get settings[true] into r3;
    assert.eq r3.global_paused false;
    get operators[r0] into r4;
    assert.eq r4 true;
    lte r2 r3.max_reward_per_notify into r5;
    assert.eq r5 true;
    get state[true] into r6;
    assert.eq r6.total_reward r1;
    lt r2 r6.total_reserve into r7;
    assert.eq r7 true;
    cast r6.total_reserve into r8 as u128;
    mul r8 10000u128 into r9;
    cast r2 into r10 as u128;
    cast r3.protocol_fee into r11 as u128;
    sub 10000u128 r11 into r12;
    mul r10 r12 into r13;
    add r9 r13 into r14;
    cast r3.protocol_fee into r15 as u128;
    cast r2 into r16 as u128;
    mul r15 r16 into r17;
    cast r6.total_supply into r18 as u128;
    mul r17 r18 into r19;
    div r19 r14 into r20;
    cast r20 into r21 as u64;
    add r6.total_supply r21 into r22;
    add r6.total_reserve r2 into r23;
    add r6.total_reward r2 into r24;
    cast r22 r23 r6.total_unstaking r24 into r25 as State;
    set r25 into state[true];
    get.or_use account[r3.fee_account] 0u64 into r26;
    add r26 r21 into r27;
    set r27 into account[r3.fee_account];

function pull_aleo:
    input r0 as u64.public;
    call credits.aleo/transfer_public self.caller r0 into r1;
    async pull_aleo r1 self.caller into r2;
    output r2 as teststake1x3.aleo/pull_aleo.future;
finalize pull_aleo:
    input r0 as credits.aleo/transfer_public.future;
    input r1 as address.public;
    await r0;
    get settings[true] into r2;
    assert.eq r2.global_paused false;
    get stakers[r1] into r3;
    assert.eq r3 true;

function update_settings:
    input r0 as Settings.public;
    async update_settings self.caller r0 into r1;
    output r1 as teststake1x3.aleo/update_settings.future;
finalize update_settings:
    input r0 as address.public;
    input r1 as Settings.public;
    get admins[r0] into r2;
    assert.eq r2 true;
    lte r1.protocol_fee 10000u16 into r3;
    assert.eq r3 true;
    set r1 into settings[true];

function set_staker:
    input r0 as address.public;
    input r1 as boolean.public;
    async set_staker self.caller r0 r1 into r2;
    output r2 as teststake1x3.aleo/set_staker.future;
finalize set_staker:
    input r0 as address.public;
    input r1 as address.public;
    input r2 as boolean.public;
    get admins[r0] into r3;
    assert.eq r3 true;
    set r2 into stakers[r1];

function set_operator:
    input r0 as address.public;
    input r1 as boolean.public;
    async set_operator self.caller r0 r1 into r2;
    output r2 as teststake1x3.aleo/set_operator.future;
finalize set_operator:
    input r0 as address.public;
    input r1 as address.public;
    input r2 as boolean.public;
    get admins[r0] into r3;
    assert.eq r3 true;
    set r2 into operators[r1];

function set_admin:
    input r0 as address.public;
    input r1 as boolean.public;
    assert.neq self.caller r0;
    async set_admin self.caller r0 r1 into r2;
    output r2 as teststake1x3.aleo/set_admin.future;
finalize set_admin:
    input r0 as address.public;
    input r1 as address.public;
    input r2 as boolean.public;
    get admins[r0] into r3;
    assert.eq r3 true;
    set r2 into admins[r1];

function emergency_withdraw:
    input r0 as u64.public;
    call credits.aleo/transfer_public self.caller r0 into r1;
    async emergency_withdraw r1 self.caller into r2;
    output r2 as teststake1x3.aleo/emergency_withdraw.future;
finalize emergency_withdraw:
    input r0 as credits.aleo/transfer_public.future;
    input r1 as address.public;
    await r0;
    get admins[r1] into r2;
    assert.eq r2 true;

function init:
    input r0 as address.public;
    assert.eq self.caller aleo18jfrqsz4m853grpgzflrlzdkcm9art926668g80vd9ruyzv8rsqqlchzyj;
    async init r0 into r1;
    output r1 as teststake1x3.aleo/init.future;
finalize init:
    input r0 as address.public;
    contains metadata[true] into r1;
    not r1 into r2;
    assert.eq r2 true;
    cast 394103260206656316532079field 126943148918095field 6u8 into r3 as Metadata;
    set r3 into metadata[true];
    set true into admins[aleo18jfrqsz4m853grpgzflrlzdkcm9art926668g80vd9ruyzv8rsqqlchzyj];
    set true into operators[aleo18jfrqsz4m853grpgzflrlzdkcm9art926668g80vd9ruyzv8rsqqlchzyj];
    cast 0u64 0u64 0u64 0u64 into r4 as State;
    set r4 into state[true];
    cast 360u32 false false 1000000000u64 1000u16 r0 into r5 as Settings;
    set r5 into settings[true];

Not implemented