TOKEN
Module0xd47b…3db2
- Move path
- 0x361d…7ffc::TOKEN
- Functions
- 134118 public, 41 entry
- Structs
- 26
- Friend modules
- pool
Bytecode3823 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 361dd589b98e8fcda9a7ee53b85efabef3569d00416640d2faa516e3801d7ffc.TOKEN {
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::bcs;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::ed25519;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::math;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::sui;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::url;
use 361dd589b98e8fcda9a7ee53b85efabef3569d00416640d2faa516e3801d7ffc::permission;
use 361dd589b98e8fcda9a7ee53b85efabef3569d00416640d2faa516e3801d7ffc::ratio;
use 361dd589b98e8fcda9a7ee53b85efabef3569d00416640d2faa516e3801d7ffc::sbalance;
use 361dd589b98e8fcda9a7ee53b85efabef3569d00416640d2faa516e3801d7ffc::utils;
struct TOKEN has drop {
dummy_field: bool
}
struct StakedToken has store, key {
id: UID,
balance: SBalance<TOKEN>,
profit: SBalance<TOKEN>,
start_epoch: u64,
end_epoch: u64,
boost: u128
}
struct LinearUnlockStakedToken has key {
id: UID,
origin_id: ID,
inner: StakedToken
}
struct TestToken has drop {
dummy_field: bool
}
struct TestBNB has drop {
dummy_field: bool
}
struct TestBTC has drop {
dummy_field: bool
}
struct TestDAI has drop {
dummy_field: bool
}
struct TestETH has drop {
dummy_field: bool
}
struct TestSOL has drop {
dummy_field: bool
}
struct TestUSDC has drop {
dummy_field: bool
}
struct TestUSDT has drop {
dummy_field: bool
}
struct TokenBank has key {
id: UID,
version: u64,
owner: address,
balance: SBalance<TOKEN>,
admin_balance: Balance<TOKEN>,
early_unlock_fee: Ratio,
stats_liquidity_mine_amount: u64,
token_farm_ids: vector<ID>,
token_ido_ids: vector<ID>,
token_airdrop_ids: vector<ID>
}
struct TokenAirdrop has key {
id: UID,
version: u64,
verify_id: ID,
public_key: vector<u8>,
bank_id: ID,
owner: address,
free_amount: u64,
name: vector<u8>,
address_table: Table<address, u8>,
balance: SBalance<TOKEN>,
allow_duplicate: bool
}
struct TokenFarmIndexValue has copy, drop, store {
profit: u64,
boost_multiplier: u64
}
struct TokenFarm has key {
id: UID,
version: u64,
bank_id: ID,
base_epochs: u64,
min_stake_index: u64,
stake_index_table: Table<u64, TokenFarmIndexValue>,
total_stake_amount: u64,
total_stake_boost: u128
}
struct TokenIdo has key {
id: UID,
version: u64,
bank_id: ID,
name: vector<u8>,
price_e9: u64,
is_public: bool,
whitelists: Table<address, u8>,
is_whitelists_editable: bool,
collect: Balance<SUI>,
balance: SBalance<TOKEN>
}
struct TestTokenSupply has key {
id: UID,
version: u64,
supply: Supply<TestToken>,
supply_bnb: Supply<TestBNB>,
supply_btc: Supply<TestBTC>,
supply_dai: Supply<TestDAI>,
supply_eth: Supply<TestETH>,
supply_sol: Supply<TestSOL>,
supply_usdc: Supply<TestUSDC>,
supply_usdt: Supply<TestUSDT>
}
struct TokenCap has key {
id: UID,
treasury_cap: TreasuryCap<TOKEN>,
token_bank_permission: Permission<TokenBank>,
token_airdrop_permission: Permission<TokenAirdrop>,
token_farm_permission: Permission<TokenFarm>,
token_ido_permission: Permission<TokenIdo>,
bank_id: ID,
coin_metadata_id: ID,
test_token_supply_id: ID
}
struct IncreaseTokenSupplyEvent has copy, drop {
bank_id: ID,
amount: u64
}
struct SendTokenEvent has copy, drop {
token_id: ID,
bank_id: ID,
amount: u64,
recipient: address,
token_type: u8
}
struct ClaimTokenAirdropEvent has copy, drop {
airdrop_id: ID,
amount: u64
}
struct AddTokenIdoWhitelistEvent has copy, drop {
ido_id: ID
}
struct BuyTokenIdoTokenEvent has copy, drop {
ido_id: ID,
in_amount: u64,
out_amount: u64
}
struct StakeTokenEvent has copy, drop {
st_id: ID
}
struct UnlockStakeTokenEvent has copy, drop {
st_id: ID
}
struct UnwrapLinearUnlockStakedTokenEvent has copy, drop {
st_id: ID
}
public(friend) staked_token_add_data<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut StakedToken, Arg1: Ty0, Arg2: Ty1) {
B0:
0MoveLoc[0](Arg0: &mut StakedToken)
1MutBorrowField[0](StakedToken.id: UID)
2MoveLoc[1](Arg1: Ty0)
3MoveLoc[2](Arg2: Ty1)
4Call dynamic_field::add<Ty0, Ty1>(&mut UID, Ty0, Ty1)
5Ret
}
public(friend) staked_token_pop_data<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut StakedToken, Arg1: Ty0): Option<Ty1> {
B0:
0MoveLoc[0](Arg0: &mut StakedToken)
1MutBorrowField[0](StakedToken.id: UID)
2MoveLoc[1](Arg1: Ty0)
3Call dynamic_field::remove_if_exists<Ty0, Ty1>(&mut UID, Ty0): Option<Ty1>
4Ret
}
public staked_token_get_id(Arg0: &StakedToken): ID {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[0](StakedToken.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public staked_token_get_origin_balance_value(Arg0: &StakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
2Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public staked_token_get_origin_profit_value(Arg0: &StakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
2Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public staked_token_get_left_balance_value(Arg0: &StakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public staked_token_get_left_profit_value(Arg0: &StakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public staked_token_get_boost(Arg0: &StakedToken): u128 {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[3](StakedToken.boost: u128)
2ReadRef
3Ret
}
public staked_token_get_start_epoch(Arg0: &StakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[4](StakedToken.start_epoch: u64)
2ReadRef
3Ret
}
public staked_token_get_end_epoch(Arg0: &StakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &StakedToken)
1ImmBorrowField[5](StakedToken.end_epoch: u64)
2ReadRef
3Ret
}
public linear_staked_token_get_id(Arg0: &LinearUnlockStakedToken): ID {
B0:
0MoveLoc[0](Arg0: &LinearUnlockStakedToken)
1ImmBorrowField[6](LinearUnlockStakedToken.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public linear_staked_token_get_origin_balance_value(Arg0: &LinearUnlockStakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &LinearUnlockStakedToken)
1ImmBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
2ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
3Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
4Ret
}
public linear_staked_token_get_origin_profit_value(Arg0: &LinearUnlockStakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &LinearUnlockStakedToken)
1ImmBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
2ImmBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
3Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
4Ret
}
public linear_staked_token_get_left_balance_value(Arg0: &LinearUnlockStakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &LinearUnlockStakedToken)
1ImmBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
2ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
3Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
4Ret
}
public linear_staked_token_get_left_profit_value(Arg0: &LinearUnlockStakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &LinearUnlockStakedToken)
1ImmBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
2ImmBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
3Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
4Ret
}
public linear_staked_token_get_start_epoch(Arg0: &LinearUnlockStakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &LinearUnlockStakedToken)
1ImmBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
2ImmBorrowField[4](StakedToken.start_epoch: u64)
3ReadRef
4Ret
}
public linear_staked_token_get_end_epoch(Arg0: &LinearUnlockStakedToken): u64 {
B0:
0MoveLoc[0](Arg0: &LinearUnlockStakedToken)
1ImmBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
2ImmBorrowField[5](StakedToken.end_epoch: u64)
3ReadRef
4Ret
}
public token_bank_get_id(Arg0: &TokenBank): ID {
B0:
0MoveLoc[0](Arg0: &TokenBank)
1ImmBorrowField[8](TokenBank.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public token_bank_get_owner(Arg0: &TokenBank): address {
B0:
0MoveLoc[0](Arg0: &TokenBank)
1ImmBorrowField[9](TokenBank.owner: address)
2ReadRef
3Ret
}
public token_bank_get_supply(Arg0: &TokenBank): u64 {
B0:
0MoveLoc[0](Arg0: &TokenBank)
1ImmBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
2Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public token_bank_get_balance_value(Arg0: &TokenBank): u64 {
B0:
0MoveLoc[0](Arg0: &TokenBank)
1ImmBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public token_bank_get_public_key(Arg0: &TokenBank): Option<vector<u8>> {
L1: loc0: Option<vector<u8>>
B0:
0CopyLoc[0](Arg0: &TokenBank)
1ImmBorrowField[8](TokenBank.id: UID)
2LdConst[0](u64: 0)
3Call dynamic_field::exists_with_type<u64, vector<u8>>(&UID, u64): bool
4BrFalse(13)
B1:
5MoveLoc[0](Arg0: &TokenBank)
6ImmBorrowField[8](TokenBank.id: UID)
7LdConst[0](u64: 0)
8Call dynamic_field::borrow<u64, vector<u8>>(&UID, u64): &vector<u8>
9ReadRef
10Call option::some<vector<u8>>(vector<u8>): Option<vector<u8>>
11StLoc[1](loc0: Option<vector<u8>>)
12Branch(17)
B2:
13MoveLoc[0](Arg0: &TokenBank)
14Pop
15Call option::none<vector<u8>>(): Option<vector<u8>>
16StLoc[1](loc0: Option<vector<u8>>)
B3:
17MoveLoc[1](loc0: Option<vector<u8>>)
18Ret
}
public token_airdrop_get_id(Arg0: &TokenAirdrop): ID {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[11](TokenAirdrop.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public token_airdrop_get_bank_id(Arg0: &TokenAirdrop): ID {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[12](TokenAirdrop.bank_id: ID)
2ReadRef
3Ret
}
public token_airdrop_get_owner(Arg0: &TokenAirdrop): address {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[13](TokenAirdrop.owner: address)
2ReadRef
3Ret
}
public token_airdrop_get_free_amount(Arg0: &TokenAirdrop): u64 {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[14](TokenAirdrop.free_amount: u64)
2ReadRef
3Ret
}
public token_airdrop_get_name(Arg0: &TokenAirdrop): vector<u8> {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[15](TokenAirdrop.name: vector<u8>)
2ReadRef
3Ret
}
public token_airdrop_get_balance_value(Arg0: &TokenAirdrop): u64 {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[16](TokenAirdrop.balance: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public token_airdrop_get_supply(Arg0: &TokenAirdrop): u64 {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[16](TokenAirdrop.balance: SBalance<TOKEN>)
2Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public token_airdrop_is_free(Arg0: &TokenAirdrop): bool {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[14](TokenAirdrop.free_amount: u64)
2ReadRef
3LdU64(0)
4Gt
5Ret
}
public token_airdrop_has_used_address(Arg0: &TokenAirdrop, Arg1: address): bool {
B0:
0MoveLoc[0](Arg0: &TokenAirdrop)
1ImmBorrowField[17](TokenAirdrop.address_table: Table<address, u8>)
2MoveLoc[1](Arg1: address)
3Call table::contains<address, u8>(&Table<address, u8>, address): bool
4Ret
}
public token_farm_index_value_get_profit(Arg0: &TokenFarmIndexValue): u64 {
B0:
0MoveLoc[0](Arg0: &TokenFarmIndexValue)
1ImmBorrowField[18](TokenFarmIndexValue.profit: u64)
2ReadRef
3Ret
}
public token_farm_index_value_get_boost(Arg0: &TokenFarmIndexValue): u64 {
B0:
0MoveLoc[0](Arg0: &TokenFarmIndexValue)
1ImmBorrowField[19](TokenFarmIndexValue.boost_multiplier: u64)
2ReadRef
3Ret
}
public token_farm_get_id(Arg0: &TokenFarm): ID {
B0:
0MoveLoc[0](Arg0: &TokenFarm)
1ImmBorrowField[20](TokenFarm.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public token_farm_get_bank_id(Arg0: &TokenFarm): ID {
B0:
0MoveLoc[0](Arg0: &TokenFarm)
1ImmBorrowField[21](TokenFarm.bank_id: ID)
2ReadRef
3Ret
}
public token_farm_get_base_epochs(Arg0: &TokenFarm): u64 {
B0:
0MoveLoc[0](Arg0: &TokenFarm)
1ImmBorrowField[22](TokenFarm.base_epochs: u64)
2ReadRef
3Ret
}
public token_farm_has_index_in_stake_index_table(Arg0: &TokenFarm, Arg1: u64): bool {
B0:
0MoveLoc[0](Arg0: &TokenFarm)
1ImmBorrowField[23](TokenFarm.stake_index_table: Table<u64, TokenFarmIndexValue>)
2MoveLoc[1](Arg1: u64)
3Call table::contains<u64, TokenFarmIndexValue>(&Table<u64, TokenFarmIndexValue>, u64): bool
4Ret
}
public token_farm_get_value_for_index(Arg0: &TokenFarm, Arg1: u64): TokenFarmIndexValue {
B0:
0MoveLoc[0](Arg0: &TokenFarm)
1ImmBorrowField[23](TokenFarm.stake_index_table: Table<u64, TokenFarmIndexValue>)
2MoveLoc[1](Arg1: u64)
3Call table::borrow<u64, TokenFarmIndexValue>(&Table<u64, TokenFarmIndexValue>, u64): &TokenFarmIndexValue
4ReadRef
5Ret
}
public token_farm_get_total_stake_amount(Arg0: &TokenFarm): u64 {
B0:
0MoveLoc[0](Arg0: &TokenFarm)
1ImmBorrowField[24](TokenFarm.total_stake_amount: u64)
2ReadRef
3Ret
}
public token_farm_get_total_stake_boost(Arg0: &TokenFarm): u128 {
B0:
0MoveLoc[0](Arg0: &TokenFarm)
1ImmBorrowField[25](TokenFarm.total_stake_boost: u128)
2ReadRef
3Ret
}
public token_ido_get_id(Arg0: &TokenIdo): ID {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[26](TokenIdo.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public token_ido_get_bank_id(Arg0: &TokenIdo): ID {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[27](TokenIdo.bank_id: ID)
2ReadRef
3Ret
}
public token_ido_get_name(Arg0: &TokenIdo): vector<u8> {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[28](TokenIdo.name: vector<u8>)
2ReadRef
3Ret
}
public token_ido_get_price_e9(Arg0: &TokenIdo): u64 {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[29](TokenIdo.price_e9: u64)
2ReadRef
3Ret
}
public token_ido_get_is_public(Arg0: &TokenIdo): bool {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[30](TokenIdo.is_public: bool)
2ReadRef
3Ret
}
public token_ido_get_is_whitelists_editable(Arg0: &TokenIdo): bool {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[31](TokenIdo.is_whitelists_editable: bool)
2ReadRef
3Ret
}
public token_ido_get_collect_value(Arg0: &TokenIdo): u64 {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[32](TokenIdo.collect: Balance<SUI>)
2Call balance::value<SUI>(&Balance<SUI>): u64
3Ret
}
public token_ido_get_balance_value(Arg0: &TokenIdo): u64 {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[33](TokenIdo.balance: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public token_ido_get_supply(Arg0: &TokenIdo): u64 {
B0:
0MoveLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[33](TokenIdo.balance: SBalance<TOKEN>)
2Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
3Ret
}
public token_ido_is_public_or_has_whitelist_address(Arg0: &TokenIdo, Arg1: address): bool {
L2: loc0: bool
B0:
0CopyLoc[0](Arg0: &TokenIdo)
1ImmBorrowField[30](TokenIdo.is_public: bool)
2ReadRef
3BrFalse(9)
B1:
4MoveLoc[0](Arg0: &TokenIdo)
5Pop
6LdTrue
7StLoc[2](loc0: bool)
8Branch(14)
B2:
9MoveLoc[0](Arg0: &TokenIdo)
10ImmBorrowField[34](TokenIdo.whitelists: Table<address, u8>)
11MoveLoc[1](Arg1: address)
12Call table::contains<address, u8>(&Table<address, u8>, address): bool
13StLoc[2](loc0: bool)
B3:
14MoveLoc[2](loc0: bool)
15Ret
}
public token_cap_cp_token_bank_permission(Arg0: &TokenCap): Permission<TokenBank> {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2Call permission::cp<TokenBank>(&Permission<TokenBank>): Permission<TokenBank>
3Ret
}
public token_cap_cp_token_airdrop_permission(Arg0: &TokenCap): Permission<TokenAirdrop> {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[36](TokenCap.token_airdrop_permission: Permission<TokenAirdrop>)
2Call permission::cp<TokenAirdrop>(&Permission<TokenAirdrop>): Permission<TokenAirdrop>
3Ret
}
public token_cap_cp_token_farm_permission(Arg0: &TokenCap): Permission<TokenFarm> {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[37](TokenCap.token_farm_permission: Permission<TokenFarm>)
2Call permission::cp<TokenFarm>(&Permission<TokenFarm>): Permission<TokenFarm>
3Ret
}
public token_cap_cp_token_ido_permission(Arg0: &TokenCap): Permission<TokenIdo> {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[38](TokenCap.token_ido_permission: Permission<TokenIdo>)
2Call permission::cp<TokenIdo>(&Permission<TokenIdo>): Permission<TokenIdo>
3Ret
}
init(Arg0: TOKEN, Arg1: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: TOKEN)
1MoveLoc[1](Arg1: &mut TxContext)
2Call init_impl(TOKEN, &mut TxContext)
3Ret
}
entry public mint_test_token(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[39](TestTokenSupply.supply: Supply<TestToken>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestToken>(&mut Supply<TestToken>, u64, address, &mut TxContext)
6Ret
}
entry public mint_test_token_bnb(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[40](TestTokenSupply.supply_bnb: Supply<TestBNB>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestBNB>(&mut Supply<TestBNB>, u64, address, &mut TxContext)
6Ret
}
entry public mint_test_token_btc(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[41](TestTokenSupply.supply_btc: Supply<TestBTC>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestBTC>(&mut Supply<TestBTC>, u64, address, &mut TxContext)
6Ret
}
entry public mint_test_token_dai(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[42](TestTokenSupply.supply_dai: Supply<TestDAI>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestDAI>(&mut Supply<TestDAI>, u64, address, &mut TxContext)
6Ret
}
entry public mint_test_token_eth(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[43](TestTokenSupply.supply_eth: Supply<TestETH>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestETH>(&mut Supply<TestETH>, u64, address, &mut TxContext)
6Ret
}
entry public mint_test_token_sol(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[44](TestTokenSupply.supply_sol: Supply<TestSOL>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestSOL>(&mut Supply<TestSOL>, u64, address, &mut TxContext)
6Ret
}
entry public mint_test_token_usdc(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[45](TestTokenSupply.supply_usdc: Supply<TestUSDC>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestUSDC>(&mut Supply<TestUSDC>, u64, address, &mut TxContext)
6Ret
}
entry public mint_test_token_usdt(Arg0: &mut TestTokenSupply, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TestTokenSupply)
1MutBorrowField[46](TestTokenSupply.supply_usdt: Supply<TestUSDT>)
2LdU64(100000000)
3MoveLoc[1](Arg1: address)
4MoveLoc[2](Arg2: &mut TxContext)
5Call utils::mint_from_supply<TestUSDT>(&mut Supply<TestUSDT>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[39](TestTokenSupply.supply: Supply<TestToken>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestToken>(&mut Supply<TestToken>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token_bnb(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[40](TestTokenSupply.supply_bnb: Supply<TestBNB>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestBNB>(&mut Supply<TestBNB>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token_btc(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[41](TestTokenSupply.supply_btc: Supply<TestBTC>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestBTC>(&mut Supply<TestBTC>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token_dai(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[42](TestTokenSupply.supply_dai: Supply<TestDAI>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestDAI>(&mut Supply<TestDAI>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token_eth(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[43](TestTokenSupply.supply_eth: Supply<TestETH>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestETH>(&mut Supply<TestETH>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token_sol(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[44](TestTokenSupply.supply_sol: Supply<TestSOL>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestSOL>(&mut Supply<TestSOL>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token_usdc(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[45](TestTokenSupply.supply_usdc: Supply<TestUSDC>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestUSDC>(&mut Supply<TestUSDC>, u64, address, &mut TxContext)
6Ret
}
entry public admin_mint_test_token_usdt(Arg0: &TokenCap, Arg1: &mut TestTokenSupply, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut TestTokenSupply)
1MutBorrowField[46](TestTokenSupply.supply_usdt: Supply<TestUSDT>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: address)
4MoveLoc[4](Arg4: &mut TxContext)
5Call utils::mint_from_supply<TestUSDT>(&mut Supply<TestUSDT>, u64, address, &mut TxContext)
6Ret
}
entry public ttcp(Arg0: TokenCap, Arg1: TokenBank, Arg2: address, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: TokenCap)
1CopyLoc[2](Arg2: address)
2Call transfer::transfer<TokenCap>(TokenCap, address)
3MoveLoc[1](Arg1: TokenBank)
4MoveLoc[2](Arg2: address)
5Call transfer::transfer<TokenBank>(TokenBank, address)
6Ret
}
entry public ttcp2(Arg0: TokenCap, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: TokenCap)
1MoveLoc[1](Arg1: address)
2Call transfer::transfer<TokenCap>(TokenCap, address)
3Ret
}
entry public increase_token_supply(Arg0: &mut TokenCap, Arg1: &mut TokenBank, Arg2: u64, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenCap)
1MoveLoc[1](Arg1: &mut TokenBank)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: &mut TxContext)
4Call do_increase_token_supply(&mut TokenCap, &mut TokenBank, u64, &mut TxContext)
5Ret
}
public deposit_token_supply(Arg0: &mut TokenCap, Arg1: &mut TokenBank, Arg2: vector<Coin<TOKEN>>, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenCap)
1MoveLoc[1](Arg1: &mut TokenBank)
2MoveLoc[2](Arg2: vector<Coin<TOKEN>>)
3MoveLoc[3](Arg3: &mut TxContext)
4Call do_deposit_token_supply(&mut TokenCap, &mut TokenBank, vector<Coin<TOKEN>>, &mut TxContext)
5Ret
}
entry public withdraw_token_bank_admin_balance(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: &mut TxContext)
4Call do_withdraw_token_bank_admin_balance(&Permission<TokenBank>, &mut TokenBank, &mut TxContext)
5Ret
}
entry public send_token(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: u64)
4MoveLoc[3](Arg3: address)
5MoveLoc[4](Arg4: &mut TxContext)
6Call do_send_token(&Permission<TokenBank>, &mut TokenBank, u64, address, &mut TxContext)
7Ret
}
entry public send_token_batch(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: vector<u64>, Arg3: vector<address>, Arg4: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: vector<u64>)
4MoveLoc[3](Arg3: vector<address>)
5MoveLoc[4](Arg4: &mut TxContext)
6Call do_send_token_batch(&Permission<TokenBank>, &mut TokenBank, vector<u64>, vector<address>, &mut TxContext)
7Ret
}
entry public send_staked_token(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: bool, Arg7: address, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: &mut TokenFarm)
4MoveLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: u64)
6MoveLoc[5](Arg5: u64)
7MoveLoc[6](Arg6: bool)
8MoveLoc[7](Arg7: address)
9MoveLoc[8](Arg8: &Clock)
10MoveLoc[9](Arg9: &mut TxContext)
11Call do_send_staked_token(&Permission<TokenBank>, &mut TokenBank, &mut TokenFarm, u64, u64, u64, bool, address, &Clock, &mut TxContext)
12Ret
}
entry public send_staked_token_with_target_epoch(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: bool, Arg7: address, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: &mut TokenFarm)
4MoveLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: u64)
6MoveLoc[5](Arg5: u64)
7MoveLoc[6](Arg6: bool)
8MoveLoc[7](Arg7: address)
9MoveLoc[8](Arg8: &Clock)
10MoveLoc[9](Arg9: &mut TxContext)
11Call do_send_staked_token_with_target_epoch(&Permission<TokenBank>, &mut TokenBank, &mut TokenFarm, u64, u64, u64, bool, address, &Clock, &mut TxContext)
12Ret
}
entry public send_staked_token_batch(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: vector<u64>, Arg4: vector<u64>, Arg5: vector<u64>, Arg6: vector<bool>, Arg7: vector<address>, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: &mut TokenFarm)
4MoveLoc[3](Arg3: vector<u64>)
5MoveLoc[4](Arg4: vector<u64>)
6MoveLoc[5](Arg5: vector<u64>)
7MoveLoc[6](Arg6: vector<bool>)
8MoveLoc[7](Arg7: vector<address>)
9MoveLoc[8](Arg8: &Clock)
10MoveLoc[9](Arg9: &mut TxContext)
11Call do_send_staked_token_batch(&Permission<TokenBank>, &mut TokenBank, &mut TokenFarm, vector<u64>, vector<u64>, vector<u64>, vector<bool>, vector<address>, &Clock, &mut TxContext)
12Ret
}
entry public send_staked_token_with_target_epoch_batch(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: vector<u64>, Arg4: vector<u64>, Arg5: vector<u64>, Arg6: vector<bool>, Arg7: vector<address>, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: &mut TokenFarm)
4MoveLoc[3](Arg3: vector<u64>)
5MoveLoc[4](Arg4: vector<u64>)
6MoveLoc[5](Arg5: vector<u64>)
7MoveLoc[6](Arg6: vector<bool>)
8MoveLoc[7](Arg7: vector<address>)
9MoveLoc[8](Arg8: &Clock)
10MoveLoc[9](Arg9: &mut TxContext)
11Call do_send_staked_token_with_target_epoch_batch(&Permission<TokenBank>, &mut TokenBank, &mut TokenFarm, vector<u64>, vector<u64>, vector<u64>, vector<bool>, vector<address>, &Clock, &mut TxContext)
12Ret
}
entry public create_token_airdrop(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: u64, Arg5: u64, Arg6: bool, Arg7: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: vector<u8>)
4MoveLoc[3](Arg3: vector<u8>)
5MoveLoc[4](Arg4: u64)
6MoveLoc[5](Arg5: u64)
7MoveLoc[6](Arg6: bool)
8MoveLoc[7](Arg7: &mut TxContext)
9Call do_create_token_airdrop(&Permission<TokenBank>, &mut TokenBank, vector<u8>, vector<u8>, u64, u64, bool, &mut TxContext)
10Ret
}
entry public set_token_bank_public_key(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: vector<u8>) {
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1MutBorrowField[8](TokenBank.id: UID)
2LdConst[0](u64: 0)
3Call dynamic_field::remove_if_exists<u64, vector<u8>>(&mut UID, u64): Option<vector<u8>>
4Pop
5MoveLoc[1](Arg1: &mut TokenBank)
6MutBorrowField[8](TokenBank.id: UID)
7LdConst[0](u64: 0)
8MoveLoc[2](Arg2: vector<u8>)
9Call dynamic_field::add<u64, vector<u8>>(&mut UID, u64, vector<u8>)
10Ret
}
entry public create_token_ido(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: vector<u8>, Arg3: u64, Arg4: bool, Arg5: u64, Arg6: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: vector<u8>)
4MoveLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: bool)
6MoveLoc[5](Arg5: u64)
7MoveLoc[6](Arg6: &mut TxContext)
8Call do_create_token_ido(&Permission<TokenBank>, &mut TokenBank, vector<u8>, u64, bool, u64, &mut TxContext)
9Ret
}
entry public close_token_ido(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: &mut TokenIdo, Arg3: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[0](Arg0: &TokenCap)
3ImmBorrowField[38](TokenCap.token_ido_permission: Permission<TokenIdo>)
4MoveLoc[1](Arg1: &mut TokenBank)
5MoveLoc[2](Arg2: &mut TokenIdo)
6MoveLoc[3](Arg3: &mut TxContext)
7Call do_close_token_ido(&Permission<TokenBank>, &Permission<TokenIdo>, &mut TokenBank, &mut TokenIdo, &mut TxContext)
8Ret
}
entry public withdraw_token_ido_collect(Arg0: &TokenCap, Arg1: &mut TokenIdo, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[38](TokenCap.token_ido_permission: Permission<TokenIdo>)
2MoveLoc[1](Arg1: &mut TokenIdo)
3MoveLoc[2](Arg2: &mut TxContext)
4Call do_withdraw_token_ido_collect(&Permission<TokenIdo>, &mut TokenIdo, &mut TxContext)
5Ret
}
entry public change_token_ido_publicity(Arg0: &TokenCap, Arg1: &mut TokenIdo, Arg2: bool, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[38](TokenCap.token_ido_permission: Permission<TokenIdo>)
2MoveLoc[1](Arg1: &mut TokenIdo)
3MoveLoc[2](Arg2: bool)
4MoveLoc[3](Arg3: &mut TxContext)
5Call do_change_token_ido_publicity(&Permission<TokenIdo>, &mut TokenIdo, bool, &mut TxContext)
6Ret
}
entry public change_token_ido_whitelists_editable(Arg0: &TokenCap, Arg1: &mut TokenIdo, Arg2: bool, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[38](TokenCap.token_ido_permission: Permission<TokenIdo>)
2MoveLoc[1](Arg1: &mut TokenIdo)
3MoveLoc[2](Arg2: bool)
4MoveLoc[3](Arg3: &mut TxContext)
5Call do_change_token_ido_whitelists_editable(&Permission<TokenIdo>, &mut TokenIdo, bool, &mut TxContext)
6Ret
}
entry public create_token_farm(Arg0: &TokenCap, Arg1: &mut TokenBank, Arg2: u64, Arg3: u64, Arg4: vector<u64>, Arg5: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &TokenCap)
1ImmBorrowField[35](TokenCap.token_bank_permission: Permission<TokenBank>)
2MoveLoc[1](Arg1: &mut TokenBank)
3MoveLoc[2](Arg2: u64)
4MoveLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: vector<u64>)
6MoveLoc[5](Arg5: &mut TxContext)
7Call do_create_token_farm(&Permission<TokenBank>, &mut TokenBank, u64, u64, vector<u64>, &mut TxContext)
8Ret
}
entry public claim_token_airdrop_token(Arg0: &mut TokenAirdrop, Arg1: u64, Arg2: vector<u8>, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenAirdrop)
1MoveLoc[1](Arg1: u64)
2MoveLoc[2](Arg2: vector<u8>)
3MoveLoc[3](Arg3: &mut TxContext)
4Call do_claim_token_airdrop_token(&mut TokenAirdrop, u64, vector<u8>, &mut TxContext)
5Ret
}
entry public add_token_ido_whitelist(Arg0: &mut TokenIdo, Arg1: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenIdo)
1MoveLoc[1](Arg1: &mut TxContext)
2Call do_add_token_ido_whitelist(&mut TokenIdo, &mut TxContext)
3Ret
}
entry public buy_token_ido_token(Arg0: &mut TokenIdo, Arg1: vector<Coin<SUI>>, Arg2: u64, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenIdo)
1MoveLoc[1](Arg1: vector<Coin<SUI>>)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: &mut TxContext)
4Call do_buy_token_ido_token(&mut TokenIdo, vector<Coin<SUI>>, u64, &mut TxContext)
5Ret
}
entry public stake_token(Arg0: &mut TokenBank, Arg1: &mut TokenFarm, Arg2: Coin<TOKEN>, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenBank)
1MoveLoc[1](Arg1: &mut TokenFarm)
2MoveLoc[2](Arg2: Coin<TOKEN>)
3MoveLoc[3](Arg3: u64)
4MoveLoc[4](Arg4: &Clock)
5MoveLoc[5](Arg5: &mut TxContext)
6Call do_stake_token(&mut TokenBank, &mut TokenFarm, Coin<TOKEN>, u64, &Clock, &mut TxContext)
7Ret
}
entry public unlock_staked_token(Arg0: &mut TokenFarm, Arg1: StakedToken, Arg2: &Clock, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenFarm)
1MoveLoc[1](Arg1: StakedToken)
2MoveLoc[2](Arg2: &Clock)
3MoveLoc[3](Arg3: &mut TxContext)
4Call do_unlock_staked_token(&mut TokenFarm, StakedToken, &Clock, &mut TxContext)
5Ret
}
entry public unlock_linear_unlock_staked_token(Arg0: LinearUnlockStakedToken, Arg1: &Clock, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: LinearUnlockStakedToken)
1MoveLoc[1](Arg1: &Clock)
2MoveLoc[2](Arg2: &mut TxContext)
3Call do_unlock_linear_unlock_staked_token(LinearUnlockStakedToken, &Clock, &mut TxContext)
4Ret
}
entry public unwrap_linear_unlock_staked_token(Arg0: &mut TokenFarm, Arg1: LinearUnlockStakedToken, Arg2: &Clock, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut TokenFarm)
1MoveLoc[1](Arg1: LinearUnlockStakedToken)
2MoveLoc[2](Arg2: &Clock)
3MoveLoc[3](Arg3: &mut TxContext)
4Call do_unwrap_linear_unlock_staked_token(&mut TokenFarm, LinearUnlockStakedToken, &Clock, &mut TxContext)
5Ret
}
create_stake_token(Arg0: &mut TokenFarm, Arg1: Balance<TOKEN>, Arg2: Balance<TOKEN>, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &Clock, Arg7: &mut TxContext): StakedToken {
L8: loc0: u64
L9: loc1: u128
L10: loc2: u64
L11: loc3: UID
L12: loc4: u64
B0:
0CopyLoc[5](Arg5: u64)
1LdU64(0)
2Gt
3BrFalse(5)
B1:
4Branch(13)
B2:
5MoveLoc[0](Arg0: &mut TokenFarm)
6Pop
7MoveLoc[7](Arg7: &mut TxContext)
8Pop
9MoveLoc[6](Arg6: &Clock)
10Pop
11LdConst[3](u64: 14400)
12Abort
B3:
13MoveLoc[7](Arg7: &mut TxContext)
14Call object::new(&mut TxContext): UID
15StLoc[11](loc3: UID)
16MoveLoc[6](Arg6: &Clock)
17Call utils::get_epoch(&Clock): u64
18MoveLoc[3](Arg3: u64)
19Add
20StLoc[12](loc4: u64)
21CopyLoc[12](loc4: u64)
22MoveLoc[4](Arg4: u64)
23Add
24StLoc[10](loc2: u64)
25ImmBorrowLoc[1](Arg1: Balance<TOKEN>)
26Call balance::value<TOKEN>(&Balance<TOKEN>): u64
27StLoc[8](loc0: u64)
28CopyLoc[8](loc0: u64)
29CastU128
30MoveLoc[5](Arg5: u64)
31CastU128
32Mul
33StLoc[9](loc1: u128)
34CopyLoc[0](Arg0: &mut TokenFarm)
35ImmBorrowField[24](TokenFarm.total_stake_amount: u64)
36ReadRef
37MoveLoc[8](loc0: u64)
38Add
39CopyLoc[0](Arg0: &mut TokenFarm)
40MutBorrowField[24](TokenFarm.total_stake_amount: u64)
41WriteRef
42CopyLoc[0](Arg0: &mut TokenFarm)
43ImmBorrowField[25](TokenFarm.total_stake_boost: u128)
44ReadRef
45CopyLoc[9](loc1: u128)
46Add
47MoveLoc[0](Arg0: &mut TokenFarm)
48MutBorrowField[25](TokenFarm.total_stake_boost: u128)
49WriteRef
50MoveLoc[11](loc3: UID)
51MoveLoc[1](Arg1: Balance<TOKEN>)
52Call sbalance::from_balance<TOKEN>(Balance<TOKEN>): SBalance<TOKEN>
53MoveLoc[2](Arg2: Balance<TOKEN>)
54Call sbalance::from_balance<TOKEN>(Balance<TOKEN>): SBalance<TOKEN>
55MoveLoc[12](loc4: u64)
56MoveLoc[10](loc2: u64)
57MoveLoc[9](loc1: u128)
58Pack[1](StakedToken)
59Ret
}
destroy_stake_token(Arg0: &mut TokenFarm, Arg1: StakedToken, Arg2: &Clock, Arg3: &mut TxContext): Balance<TOKEN> {
B0:
0MoveLoc[2](Arg2: &Clock)
1Call utils::get_epoch(&Clock): u64
2ImmBorrowLoc[1](Arg1: StakedToken)
3ImmBorrowField[5](StakedToken.end_epoch: u64)
4ReadRef
5Ge
6BrFalse(8)
B1:
7Branch(12)
B2:
8MoveLoc[0](Arg0: &mut TokenFarm)
9Pop
10LdConst[13](u64: 144010)
11Abort
B3:
12MoveLoc[0](Arg0: &mut TokenFarm)
13MoveLoc[1](Arg1: StakedToken)
14Call destroy_stake_token_force(&mut TokenFarm, StakedToken): Balance<TOKEN>
15Ret
}
destroy_stake_token_force(Arg0: &mut TokenFarm, Arg1: StakedToken): Balance<TOKEN> {
L2: loc0: Balance<TOKEN>
L3: loc1: Balance<TOKEN>
L4: loc2: SBalance<TOKEN>
L5: loc3: u64
L6: loc4: u128
L7: loc5: SBalance<TOKEN>
B0:
0ImmBorrowLoc[1](Arg1: StakedToken)
1ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3StLoc[5](loc3: u64)
4ImmBorrowLoc[1](Arg1: StakedToken)
5ImmBorrowField[3](StakedToken.boost: u128)
6ReadRef
7StLoc[6](loc4: u128)
8CopyLoc[0](Arg0: &mut TokenFarm)
9ImmBorrowField[24](TokenFarm.total_stake_amount: u64)
10ReadRef
11MoveLoc[5](loc3: u64)
12Sub
13CopyLoc[0](Arg0: &mut TokenFarm)
14MutBorrowField[24](TokenFarm.total_stake_amount: u64)
15WriteRef
16CopyLoc[0](Arg0: &mut TokenFarm)
17ImmBorrowField[25](TokenFarm.total_stake_boost: u128)
18ReadRef
19MoveLoc[6](loc4: u128)
20Sub
21MoveLoc[0](Arg0: &mut TokenFarm)
22MutBorrowField[25](TokenFarm.total_stake_boost: u128)
23WriteRef
24MoveLoc[1](Arg1: StakedToken)
25Unpack[1](StakedToken)
26Pop
27Pop
28Pop
29StLoc[7](loc5: SBalance<TOKEN>)
30StLoc[4](loc2: SBalance<TOKEN>)
31Call object::delete(UID)
32MoveLoc[4](loc2: SBalance<TOKEN>)
33Call sbalance::into_balance<TOKEN>(SBalance<TOKEN>): Balance<TOKEN>
34StLoc[2](loc0: Balance<TOKEN>)
35MoveLoc[7](loc5: SBalance<TOKEN>)
36Call sbalance::into_balance<TOKEN>(SBalance<TOKEN>): Balance<TOKEN>
37StLoc[3](loc1: Balance<TOKEN>)
38MutBorrowLoc[2](loc0: Balance<TOKEN>)
39MoveLoc[3](loc1: Balance<TOKEN>)
40Call balance::join<TOKEN>(&mut Balance<TOKEN>, Balance<TOKEN>): u64
41Pop
42MoveLoc[2](loc0: Balance<TOKEN>)
43Ret
}
is_zero_stake_token(Arg0: &StakedToken): bool {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &StakedToken)
1ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3LdU64(0)
4Eq
5BrFalse(13)
B1:
6MoveLoc[0](Arg0: &StakedToken)
7ImmBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
8Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
9LdU64(0)
10Eq
11StLoc[1](loc0: bool)
12Branch(17)
B2:
13MoveLoc[0](Arg0: &StakedToken)
14Pop
15LdFalse
16StLoc[1](loc0: bool)
B3:
17MoveLoc[1](loc0: bool)
18Ret
}
destroy_zero_stake_token(Arg0: StakedToken) {
L1: loc0: SBalance<TOKEN>
L2: loc1: SBalance<TOKEN>
B0:
0ImmBorrowLoc[0](Arg0: StakedToken)
1Call is_zero_stake_token(&StakedToken): bool
2LdTrue
3Eq
4BrFalse(6)
B1:
5Branch(8)
B2:
6LdConst[14](u64: 144011)
7Abort
B3:
8MoveLoc[0](Arg0: StakedToken)
9Unpack[1](StakedToken)
10Pop
11Pop
12Pop
13StLoc[2](loc1: SBalance<TOKEN>)
14StLoc[1](loc0: SBalance<TOKEN>)
15Call object::delete(UID)
16MoveLoc[1](loc0: SBalance<TOKEN>)
17Call sbalance::destroy_zero<TOKEN>(SBalance<TOKEN>)
18MoveLoc[2](loc1: SBalance<TOKEN>)
19Call sbalance::destroy_zero<TOKEN>(SBalance<TOKEN>)
20Ret
}
create_linear_unlock_stake_token(Arg0: Balance<TOKEN>, Arg1: Balance<TOKEN>, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: &Clock, Arg6: &mut TxContext): LinearUnlockStakedToken {
L7: loc0: u128
L8: loc1: u64
L9: loc2: ID
L10: loc3: UID
L11: loc4: StakedToken
L12: loc5: u64
L13: loc6: UID
B0:
0CopyLoc[6](Arg6: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[10](loc3: UID)
3MoveLoc[5](Arg5: &Clock)
4Call utils::get_epoch(&Clock): u64
5MoveLoc[2](Arg2: u64)
6Add
7StLoc[12](loc5: u64)
8CopyLoc[12](loc5: u64)
9MoveLoc[3](Arg3: u64)
10Add
11StLoc[8](loc1: u64)
12ImmBorrowLoc[0](Arg0: Balance<TOKEN>)
13Call balance::value<TOKEN>(&Balance<TOKEN>): u64
14CastU128
15MoveLoc[4](Arg4: u64)
16CastU128
17Mul
18StLoc[7](loc0: u128)
19MoveLoc[10](loc3: UID)
20MoveLoc[0](Arg0: Balance<TOKEN>)
21Call sbalance::from_balance<TOKEN>(Balance<TOKEN>): SBalance<TOKEN>
22MoveLoc[1](Arg1: Balance<TOKEN>)
23Call sbalance::from_balance<TOKEN>(Balance<TOKEN>): SBalance<TOKEN>
24MoveLoc[12](loc5: u64)
25MoveLoc[8](loc1: u64)
26MoveLoc[7](loc0: u128)
27Pack[1](StakedToken)
28StLoc[11](loc4: StakedToken)
29MoveLoc[6](Arg6: &mut TxContext)
30Call object::new(&mut TxContext): UID
31StLoc[13](loc6: UID)
32ImmBorrowLoc[13](loc6: UID)
33Call object::uid_to_inner(&UID): ID
34StLoc[9](loc2: ID)
35MoveLoc[13](loc6: UID)
36MoveLoc[9](loc2: ID)
37MoveLoc[11](loc4: StakedToken)
38Pack[2](LinearUnlockStakedToken)
39Ret
}
transfer_or_destroy_zero_stake_token(Arg0: StakedToken, Arg1: address) {
B0:
0ImmBorrowLoc[0](Arg0: StakedToken)
1Call is_zero_stake_token(&StakedToken): bool
2BrFalse(6)
B1:
3MoveLoc[0](Arg0: StakedToken)
4Call destroy_zero_stake_token(StakedToken)
5Branch(9)
B2:
6MoveLoc[0](Arg0: StakedToken)
7MoveLoc[1](Arg1: address)
8Call transfer::transfer<StakedToken>(StakedToken, address)
B3:
9Ret
}
decrease_linear_unlock_stake_token(Arg0: &mut LinearUnlockStakedToken, Arg1: &Clock, Arg2: &mut TxContext): Balance<TOKEN> {
L3: loc0: bool
L4: loc1: Ratio
L5: loc2: u64
L6: loc3: u64
L7: loc4: Balance<TOKEN>
L8: loc5: u64
L9: loc6: Balance<TOKEN>
L10: loc7: u64
L11: loc8: u64
L12: loc9: u64
L13: loc10: u64
L14: loc11: u64
L15: loc12: Ratio
L16: loc13: u64
L17: loc14: u64
L18: loc15: u64
L19: loc16: &mut StakedToken
L20: loc17: u64
L21: loc18: u64
B0:
0MoveLoc[1](Arg1: &Clock)
1Call utils::get_epoch(&Clock): u64
2StLoc[11](loc8: u64)
3CopyLoc[11](loc8: u64)
4CopyLoc[0](Arg0: &mut LinearUnlockStakedToken)
5ImmBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
6ImmBorrowField[4](StakedToken.start_epoch: u64)
7ReadRef
8Ge
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[0](Arg0: &mut LinearUnlockStakedToken)
12Pop
13LdConst[13](u64: 144010)
14Abort
B3:
15MoveLoc[0](Arg0: &mut LinearUnlockStakedToken)
16MutBorrowField[7](LinearUnlockStakedToken.inner: StakedToken)
17StLoc[19](loc16: &mut StakedToken)
18CopyLoc[19](loc16: &mut StakedToken)
19ImmBorrowField[5](StakedToken.end_epoch: u64)
20ReadRef
21CopyLoc[19](loc16: &mut StakedToken)
22ImmBorrowField[4](StakedToken.start_epoch: u64)
23ReadRef
24Eq
25BrFalse(29)
B4:
26LdTrue
27StLoc[3](loc0: bool)
28Branch(35)
B5:
29CopyLoc[11](loc8: u64)
30CopyLoc[19](loc16: &mut StakedToken)
31ImmBorrowField[5](StakedToken.end_epoch: u64)
32ReadRef
33Ge
34StLoc[3](loc0: bool)
B6:
35MoveLoc[3](loc0: bool)
36BrFalse(42)
B7:
37LdU64(0)
38LdU64(1)
39Call ratio::ratio(u64, u64): Ratio
40StLoc[4](loc1: Ratio)
41Branch(66)
B8:
42MoveLoc[11](loc8: u64)
43CopyLoc[19](loc16: &mut StakedToken)
44ImmBorrowField[5](StakedToken.end_epoch: u64)
45ReadRef
46Call math::min(u64, u64): u64
47CopyLoc[19](loc16: &mut StakedToken)
48ImmBorrowField[4](StakedToken.start_epoch: u64)
49ReadRef
50Sub
51StLoc[16](loc13: u64)
52CopyLoc[19](loc16: &mut StakedToken)
53ImmBorrowField[5](StakedToken.end_epoch: u64)
54ReadRef
55CopyLoc[19](loc16: &mut StakedToken)
56ImmBorrowField[4](StakedToken.start_epoch: u64)
57ReadRef
58Sub
59StLoc[14](loc11: u64)
60CopyLoc[14](loc11: u64)
61MoveLoc[16](loc13: u64)
62Sub
63MoveLoc[14](loc11: u64)
64Call ratio::ratio(u64, u64): Ratio
65StLoc[4](loc1: Ratio)
B9:
66MoveLoc[4](loc1: Ratio)
67StLoc[15](loc12: Ratio)
68CopyLoc[19](loc16: &mut StakedToken)
69ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
70Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
71StLoc[20](loc17: u64)
72CopyLoc[19](loc16: &mut StakedToken)
73ImmBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
74Call sbalance::supply<TOKEN>(&SBalance<TOKEN>): u64
75StLoc[21](loc18: u64)
76CopyLoc[15](loc12: Ratio)
77MoveLoc[20](loc17: u64)
78Call ratio::partial(Ratio, u64): u64
79StLoc[17](loc14: u64)
80MoveLoc[15](loc12: Ratio)
81MoveLoc[21](loc18: u64)
82Call ratio::partial(Ratio, u64): u64
83StLoc[18](loc15: u64)
84CopyLoc[19](loc16: &mut StakedToken)
85ImmBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
86Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
87StLoc[12](loc9: u64)
88CopyLoc[19](loc16: &mut StakedToken)
89ImmBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
90Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
91StLoc[13](loc10: u64)
92CopyLoc[17](loc14: u64)
93CopyLoc[12](loc9: u64)
94Le
95BrFalse(101)
B10:
96MoveLoc[12](loc9: u64)
97MoveLoc[17](loc14: u64)
98Sub
99StLoc[5](loc2: u64)
100Branch(103)
B11:
101LdU64(0)
102StLoc[5](loc2: u64)
B12:
103MoveLoc[5](loc2: u64)
104StLoc[8](loc5: u64)
105CopyLoc[18](loc15: u64)
106CopyLoc[13](loc10: u64)
107Le
108BrFalse(114)
B13:
109MoveLoc[13](loc10: u64)
110MoveLoc[18](loc15: u64)
111Sub
112StLoc[6](loc3: u64)
113Branch(116)
B14:
114LdU64(0)
115StLoc[6](loc3: u64)
B15:
116MoveLoc[6](loc3: u64)
117StLoc[10](loc7: u64)
118CopyLoc[19](loc16: &mut StakedToken)
119MutBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
120MoveLoc[8](loc5: u64)
121Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
122StLoc[7](loc4: Balance<TOKEN>)
123MoveLoc[19](loc16: &mut StakedToken)
124MutBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
125MoveLoc[10](loc7: u64)
126Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
127StLoc[9](loc6: Balance<TOKEN>)
128MutBorrowLoc[7](loc4: Balance<TOKEN>)
129MoveLoc[9](loc6: Balance<TOKEN>)
130Call balance::join<TOKEN>(&mut Balance<TOKEN>, Balance<TOKEN>): u64
131Pop
132MoveLoc[7](loc4: Balance<TOKEN>)
133Ret
}
unwrap_linear_unlock_stake_token(Arg0: &mut TokenFarm, Arg1: LinearUnlockStakedToken, Arg2: &Clock, Arg3: &mut TxContext): StakedToken {
L4: loc0: u64
L5: loc1: Balance<TOKEN>
L6: loc2: u64
L7: loc3: StakedToken
L8: loc4: Balance<TOKEN>
L9: loc5: u64
L10: loc6: u64
B0:
0MoveLoc[1](Arg1: LinearUnlockStakedToken)
1Unpack[2](LinearUnlockStakedToken)
2StLoc[7](loc3: StakedToken)
3Pop
4Call object::delete(UID)
5MutBorrowLoc[7](loc3: StakedToken)
6MutBorrowField[1](StakedToken.balance: SBalance<TOKEN>)
7Call sbalance::split_all<TOKEN>(&mut SBalance<TOKEN>): Balance<TOKEN>
8StLoc[5](loc1: Balance<TOKEN>)
9MutBorrowLoc[7](loc3: StakedToken)
10MutBorrowField[2](StakedToken.profit: SBalance<TOKEN>)
11Call sbalance::split_all<TOKEN>(&mut SBalance<TOKEN>): Balance<TOKEN>
12StLoc[8](loc4: Balance<TOKEN>)
13CopyLoc[2](Arg2: &Clock)
14Call utils::get_epoch(&Clock): u64
15StLoc[9](loc5: u64)
16ImmBorrowLoc[7](loc3: StakedToken)
17ImmBorrowField[5](StakedToken.end_epoch: u64)
18ReadRef
19StLoc[6](loc2: u64)
20CopyLoc[6](loc2: u64)
21CopyLoc[9](loc5: u64)
22Gt
23BrFalse(29)
B1:
24MoveLoc[6](loc2: u64)
25MoveLoc[9](loc5: u64)
26Sub
27StLoc[4](loc0: u64)
28Branch(31)
B2:
29LdU64(0)
30StLoc[4](loc0: u64)
B3:
31MoveLoc[4](loc0: u64)
32StLoc[10](loc6: u64)
33MoveLoc[7](loc3: StakedToken)
34Call destroy_zero_stake_token(StakedToken)
35MoveLoc[0](Arg0: &mut TokenFarm)
36MoveLoc[5](loc1: Balance<TOKEN>)
37MoveLoc[8](loc4: Balance<TOKEN>)
38LdU64(0)
39MoveLoc[10](loc6: u64)
40LdConst[23](u64: 10)
41MoveLoc[2](Arg2: &Clock)
42MoveLoc[3](Arg3: &mut TxContext)
43Call create_stake_token(&mut TokenFarm, Balance<TOKEN>, Balance<TOKEN>, u64, u64, u64, &Clock, &mut TxContext): StakedToken
44Ret
}
send_token_impl(Arg0: &mut TokenBank, Arg1: u64, Arg2: address, Arg3: &mut TxContext) {
L4: loc0: Coin<TOKEN>
L5: loc1: ID
L6: loc2: u64
B0:
0CopyLoc[1](Arg1: u64)
1LdU64(0)
2Eq
3BrFalse(9)
B1:
4MoveLoc[3](Arg3: &mut TxContext)
5Pop
6MoveLoc[0](Arg0: &mut TokenBank)
7Pop
8Ret
B2:
9CopyLoc[0](Arg0: &mut TokenBank)
10ImmBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
11Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
12StLoc[6](loc2: u64)
13CopyLoc[1](Arg1: u64)
14MoveLoc[6](loc2: u64)
15Le
16BrFalse(18)
B3:
17Branch(24)
B4:
18MoveLoc[3](Arg3: &mut TxContext)
19Pop
20MoveLoc[0](Arg0: &mut TokenBank)
21Pop
22LdConst[4](u64: 144001)
23Abort
B5:
24CopyLoc[0](Arg0: &mut TokenBank)
25MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
26CopyLoc[1](Arg1: u64)
27Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
28MoveLoc[3](Arg3: &mut TxContext)
29Call coin::from_balance<TOKEN>(Balance<TOKEN>, &mut TxContext): Coin<TOKEN>
30StLoc[4](loc0: Coin<TOKEN>)
31ImmBorrowLoc[4](loc0: Coin<TOKEN>)
32Call object::borrow_id<Coin<TOKEN>>(&Coin<TOKEN>): &ID
33ReadRef
34StLoc[5](loc1: ID)
35MoveLoc[4](loc0: Coin<TOKEN>)
36CopyLoc[2](Arg2: address)
37Call transfer::public_transfer<Coin<TOKEN>>(Coin<TOKEN>, address)
38MoveLoc[5](loc1: ID)
39MoveLoc[0](Arg0: &mut TokenBank)
40ImmBorrowField[8](TokenBank.id: UID)
41Call object::uid_to_inner(&UID): ID
42MoveLoc[1](Arg1: u64)
43MoveLoc[2](Arg2: address)
44LdConst[24](u8: 0)
45Pack[19](SendTokenEvent)
46Call event::emit<SendTokenEvent>(SendTokenEvent)
47Ret
}
send_staked_token_impl(Arg0: &mut TokenBank, Arg1: &mut TokenFarm, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: bool, Arg6: address, Arg7: &Clock, Arg8: &mut TxContext) {
L9: loc0: Balance<TOKEN>
L10: loc1: ID
L11: loc2: LinearUnlockStakedToken
L12: loc3: ID
L13: loc4: u64
L14: loc5: Balance<TOKEN>
L15: loc6: StakedToken
L16: loc7: ID
B0:
0CopyLoc[0](Arg0: &mut TokenBank)
1ImmBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
2Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
3StLoc[13](loc4: u64)
4CopyLoc[2](Arg2: u64)
5MoveLoc[13](loc4: u64)
6Le
7BrFalse(9)
B1:
8Branch(19)
B2:
9MoveLoc[1](Arg1: &mut TokenFarm)
10Pop
11MoveLoc[8](Arg8: &mut TxContext)
12Pop
13MoveLoc[7](Arg7: &Clock)
14Pop
15MoveLoc[0](Arg0: &mut TokenBank)
16Pop
17LdConst[4](u64: 144001)
18Abort
B3:
19CopyLoc[0](Arg0: &mut TokenBank)
20ImmBorrowField[8](TokenBank.id: UID)
21Call object::uid_to_inner(&UID): ID
22StLoc[10](loc1: ID)
23MoveLoc[0](Arg0: &mut TokenBank)
24MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
25CopyLoc[2](Arg2: u64)
26Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
27StLoc[9](loc0: Balance<TOKEN>)
28Call balance::zero<TOKEN>(): Balance<TOKEN>
29StLoc[14](loc5: Balance<TOKEN>)
30MoveLoc[5](Arg5: bool)
31LdFalse
32Eq
33BrFalse(59)
B4:
34MoveLoc[1](Arg1: &mut TokenFarm)
35MoveLoc[9](loc0: Balance<TOKEN>)
36MoveLoc[14](loc5: Balance<TOKEN>)
37MoveLoc[3](Arg3: u64)
38MoveLoc[4](Arg4: u64)
39LdConst[23](u64: 10)
40MoveLoc[7](Arg7: &Clock)
41MoveLoc[8](Arg8: &mut TxContext)
42Call create_stake_token(&mut TokenFarm, Balance<TOKEN>, Balance<TOKEN>, u64, u64, u64, &Clock, &mut TxContext): StakedToken
43StLoc[15](loc6: StakedToken)
44ImmBorrowLoc[15](loc6: StakedToken)
45ImmBorrowField[0](StakedToken.id: UID)
46Call object::uid_to_inner(&UID): ID
47StLoc[16](loc7: ID)
48MoveLoc[15](loc6: StakedToken)
49CopyLoc[6](Arg6: address)
50Call transfer::transfer<StakedToken>(StakedToken, address)
51MoveLoc[16](loc7: ID)
52MoveLoc[10](loc1: ID)
53MoveLoc[2](Arg2: u64)
54MoveLoc[6](Arg6: address)
55LdConst[24](u8: 0)
56Pack[19](SendTokenEvent)
57Call event::emit<SendTokenEvent>(SendTokenEvent)
58Branch(84)
B5:
59MoveLoc[1](Arg1: &mut TokenFarm)
60Pop
61MoveLoc[9](loc0: Balance<TOKEN>)
62MoveLoc[14](loc5: Balance<TOKEN>)
63MoveLoc[3](Arg3: u64)
64MoveLoc[4](Arg4: u64)
65LdConst[23](u64: 10)
66MoveLoc[7](Arg7: &Clock)
67MoveLoc[8](Arg8: &mut TxContext)
68Call create_linear_unlock_stake_token(Balance<TOKEN>, Balance<TOKEN>, u64, u64, u64, &Clock, &mut TxContext): LinearUnlockStakedToken
69StLoc[11](loc2: LinearUnlockStakedToken)
70ImmBorrowLoc[11](loc2: LinearUnlockStakedToken)
71ImmBorrowField[6](LinearUnlockStakedToken.id: UID)
72Call object::uid_to_inner(&UID): ID
73StLoc[12](loc3: ID)
74MoveLoc[11](loc2: LinearUnlockStakedToken)
75CopyLoc[6](Arg6: address)
76Call transfer::transfer<LinearUnlockStakedToken>(LinearUnlockStakedToken, address)
77MoveLoc[12](loc3: ID)
78MoveLoc[10](loc1: ID)
79MoveLoc[2](Arg2: u64)
80MoveLoc[6](Arg6: address)
81LdConst[25](u8: 1)
82Pack[19](SendTokenEvent)
83Call event::emit<SendTokenEvent>(SendTokenEvent)
B6:
84Ret
}
init_impl(Arg0: TOKEN, Arg1: &mut TxContext) {
L2: loc0: ID
L3: loc1: CoinMetadata<TOKEN>
L4: loc2: ID
L5: loc3: address
L6: loc4: TestTokenSupply
L7: loc5: ID
L8: loc6: TokenBank
L9: loc7: TreasuryCap<TOKEN>
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[5](loc3: address)
4MoveLoc[0](Arg0: TOKEN)
5LdU8(9)
6LdConst[32](vector<u8>: "SSW..)
7LdConst[33](vector<u8>: "Sui..)
8LdConst[34](vector<u8>: "Sui..)
9LdConst[35](vector<u8>: "htt..)
10Call ascii::string(vector<u8>): String
11Call url::new_unsafe(String): Url
12Call option::some<Url>(Url): Option<Url>
13CopyLoc[1](Arg1: &mut TxContext)
14Call coin::create_currency<TOKEN>(TOKEN, u8, vector<u8>, vector<u8>, vector<u8>, Option<Url>, &mut TxContext): TreasuryCap<TOKEN> * CoinMetadata<TOKEN>
15StLoc[3](loc1: CoinMetadata<TOKEN>)
16StLoc[9](loc7: TreasuryCap<TOKEN>)
17CopyLoc[1](Arg1: &mut TxContext)
18Call object::new(&mut TxContext): UID
19LdConst[0](u64: 0)
20CopyLoc[5](loc3: address)
21Call balance::zero<TOKEN>(): Balance<TOKEN>
22Call sbalance::from_balance<TOKEN>(Balance<TOKEN>): SBalance<TOKEN>
23Call balance::zero<TOKEN>(): Balance<TOKEN>
24LdConst[1](u64: 1000)
25LdConst[2](u64: 10000)
26Call ratio::ratio(u64, u64): Ratio
27LdU64(0)
28VecPack(5, 0)
29VecPack(5, 0)
30VecPack(5, 0)
31Pack[11](TokenBank)
32StLoc[8](loc6: TokenBank)
33CopyLoc[1](Arg1: &mut TxContext)
34Call object::new(&mut TxContext): UID
35LdConst[0](u64: 0)
36LdFalse
37Pack[3](TestToken)
38Call balance::create_supply<TestToken>(TestToken): Supply<TestToken>
39LdFalse
40Pack[4](TestBNB)
41Call balance::create_supply<TestBNB>(TestBNB): Supply<TestBNB>
42LdFalse
43Pack[5](TestBTC)
44Call balance::create_supply<TestBTC>(TestBTC): Supply<TestBTC>
45LdFalse
46Pack[6](TestDAI)
47Call balance::create_supply<TestDAI>(TestDAI): Supply<TestDAI>
48LdFalse
49Pack[7](TestETH)
50Call balance::create_supply<TestETH>(TestETH): Supply<TestETH>
51LdFalse
52Pack[8](TestSOL)
53Call balance::create_supply<TestSOL>(TestSOL): Supply<TestSOL>
54LdFalse
55Pack[9](TestUSDC)
56Call balance::create_supply<TestUSDC>(TestUSDC): Supply<TestUSDC>
57LdFalse
58Pack[10](TestUSDT)
59Call balance::create_supply<TestUSDT>(TestUSDT): Supply<TestUSDT>
60Pack[16](TestTokenSupply)
61StLoc[6](loc4: TestTokenSupply)
62ImmBorrowLoc[6](loc4: TestTokenSupply)
63Call object::id<TestTokenSupply>(&TestTokenSupply): ID
64StLoc[7](loc5: ID)
65ImmBorrowLoc[3](loc1: CoinMetadata<TOKEN>)
66Call object::id<CoinMetadata<TOKEN>>(&CoinMetadata<TOKEN>): ID
67StLoc[4](loc2: ID)
68ImmBorrowLoc[8](loc6: TokenBank)
69Call object::id<TokenBank>(&TokenBank): ID
70StLoc[2](loc0: ID)
71MoveLoc[6](loc4: TestTokenSupply)
72Call transfer::share_object<TestTokenSupply>(TestTokenSupply)
73MoveLoc[3](loc1: CoinMetadata<TOKEN>)
74Call transfer::public_freeze_object<CoinMetadata<TOKEN>>(CoinMetadata<TOKEN>)
75MoveLoc[8](loc6: TokenBank)
76Call transfer::share_object<TokenBank>(TokenBank)
77MoveLoc[1](Arg1: &mut TxContext)
78Call object::new(&mut TxContext): UID
79MoveLoc[9](loc7: TreasuryCap<TOKEN>)
80Call permission::new<TokenBank>(): Permission<TokenBank>
81Call permission::new<TokenAirdrop>(): Permission<TokenAirdrop>
82Call permission::new<TokenFarm>(): Permission<TokenFarm>
83Call permission::new<TokenIdo>(): Permission<TokenIdo>
84MoveLoc[2](loc0: ID)
85MoveLoc[4](loc2: ID)
86MoveLoc[7](loc5: ID)
87Pack[17](TokenCap)
88MoveLoc[5](loc3: address)
89Call transfer::transfer<TokenCap>(TokenCap, address)
90Ret
}
public do_increase_token_supply(Arg0: &mut TokenCap, Arg1: &mut TokenBank, Arg2: u64, Arg3: &mut TxContext) {
L4: loc0: Balance<TOKEN>
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[3](Arg3: &mut TxContext)
8Pop
9MoveLoc[0](Arg0: &mut TokenCap)
10Pop
11MoveLoc[1](Arg1: &mut TokenBank)
12Pop
13LdConst[20](u64: 200000)
14Abort
B3:
15CopyLoc[2](Arg2: u64)
16LdU64(0)
17Eq
18BrFalse(26)
B4:
19MoveLoc[3](Arg3: &mut TxContext)
20Pop
21MoveLoc[0](Arg0: &mut TokenCap)
22Pop
23MoveLoc[1](Arg1: &mut TokenBank)
24Pop
25Ret
B5:
26MoveLoc[0](Arg0: &mut TokenCap)
27MutBorrowField[48](TokenCap.treasury_cap: TreasuryCap<TOKEN>)
28CopyLoc[2](Arg2: u64)
29MoveLoc[3](Arg3: &mut TxContext)
30Call coin::mint<TOKEN>(&mut TreasuryCap<TOKEN>, u64, &mut TxContext): Coin<TOKEN>
31Call coin::into_balance<TOKEN>(Coin<TOKEN>): Balance<TOKEN>
32StLoc[4](loc0: Balance<TOKEN>)
33CopyLoc[1](Arg1: &mut TokenBank)
34MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
35MoveLoc[4](loc0: Balance<TOKEN>)
36Call sbalance::increase<TOKEN>(&mut SBalance<TOKEN>, Balance<TOKEN>)
37MoveLoc[1](Arg1: &mut TokenBank)
38ImmBorrowField[8](TokenBank.id: UID)
39Call object::uid_to_inner(&UID): ID
40MoveLoc[2](Arg2: u64)
41Pack[18](IncreaseTokenSupplyEvent)
42Call event::emit<IncreaseTokenSupplyEvent>(IncreaseTokenSupplyEvent)
43Ret
}
public do_deposit_token_supply(Arg0: &mut TokenCap, Arg1: &mut TokenBank, Arg2: vector<Coin<TOKEN>>, Arg3: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[3](Arg3: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13MoveLoc[1](Arg1: &mut TokenBank)
14MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
15MoveLoc[2](Arg2: vector<Coin<TOKEN>>)
16MoveLoc[3](Arg3: &mut TxContext)
17Call utils::merge_coins<TOKEN>(vector<Coin<TOKEN>>, &mut TxContext): Coin<TOKEN>
18Call coin::into_balance<TOKEN>(Coin<TOKEN>): Balance<TOKEN>
19Call sbalance::deposit<TOKEN>(&mut SBalance<TOKEN>, Balance<TOKEN>)
20Ret
}
public do_withdraw_token_bank_admin_balance(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: &mut TxContext) {
L3: loc0: u64
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[2](Arg2: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[1](Arg1: &mut TokenBank)
14ImmBorrowField[49](TokenBank.admin_balance: Balance<TOKEN>)
15Call balance::value<TOKEN>(&Balance<TOKEN>): u64
16StLoc[3](loc0: u64)
17MoveLoc[1](Arg1: &mut TokenBank)
18MutBorrowField[49](TokenBank.admin_balance: Balance<TOKEN>)
19MoveLoc[3](loc0: u64)
20Call balance::split<TOKEN>(&mut Balance<TOKEN>, u64): Balance<TOKEN>
21CopyLoc[2](Arg2: &mut TxContext)
22Call coin::from_balance<TOKEN>(Balance<TOKEN>, &mut TxContext): Coin<TOKEN>
23MoveLoc[2](Arg2: &mut TxContext)
24FreezeRef
25Call tx_context::sender(&TxContext): address
26Call utils::transfer_or_destroy_zero<TOKEN>(Coin<TOKEN>, address)
27Ret
}
public do_send_token(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[4](Arg4: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13MoveLoc[1](Arg1: &mut TokenBank)
14MoveLoc[2](Arg2: u64)
15MoveLoc[3](Arg3: address)
16MoveLoc[4](Arg4: &mut TxContext)
17Call send_token_impl(&mut TokenBank, u64, address, &mut TxContext)
18Ret
}
public do_send_token_batch(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: vector<u64>, Arg3: vector<address>, Arg4: &mut TxContext) {
L5: loc0: u64
L6: loc1: u64
L7: loc2: u64
L8: loc3: u64
L9: loc4: address
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[4](Arg4: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13ImmBorrowLoc[2](Arg2: vector<u64>)
14VecLen(6)
15StLoc[7](loc2: u64)
16ImmBorrowLoc[3](Arg3: vector<address>)
17VecLen(10)
18StLoc[8](loc3: u64)
19CopyLoc[7](loc2: u64)
20MoveLoc[8](loc3: u64)
21Eq
22BrFalse(24)
B4:
23Branch(30)
B5:
24MoveLoc[4](Arg4: &mut TxContext)
25Pop
26MoveLoc[1](Arg1: &mut TokenBank)
27Pop
28LdConst[3](u64: 14400)
29Abort
B6:
30LdU64(0)
31StLoc[6](loc1: u64)
B7:
32CopyLoc[6](loc1: u64)
33CopyLoc[7](loc2: u64)
34Lt
35BrFalse(57)
B8:
36Branch(37)
B9:
37ImmBorrowLoc[2](Arg2: vector<u64>)
38CopyLoc[6](loc1: u64)
39VecImmBorrow(6)
40ReadRef
41StLoc[5](loc0: u64)
42ImmBorrowLoc[3](Arg3: vector<address>)
43CopyLoc[6](loc1: u64)
44VecImmBorrow(10)
45ReadRef
46StLoc[9](loc4: address)
47CopyLoc[1](Arg1: &mut TokenBank)
48MoveLoc[5](loc0: u64)
49MoveLoc[9](loc4: address)
50CopyLoc[4](Arg4: &mut TxContext)
51Call send_token_impl(&mut TokenBank, u64, address, &mut TxContext)
52MoveLoc[6](loc1: u64)
53LdU64(1)
54Add
55StLoc[6](loc1: u64)
56Branch(32)
B10:
57MoveLoc[4](Arg4: &mut TxContext)
58Pop
59MoveLoc[1](Arg1: &mut TokenBank)
60Pop
61Ret
}
public(friend) do_send_liquidity_mine_token(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[4](Arg4: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11MoveLoc[0](Arg0: &Permission<TokenBank>)
12Pop
13LdConst[20](u64: 200000)
14Abort
B3:
15MoveLoc[0](Arg0: &Permission<TokenBank>)
16CopyLoc[1](Arg1: &mut TokenBank)
17CopyLoc[2](Arg2: u64)
18MoveLoc[3](Arg3: address)
19MoveLoc[4](Arg4: &mut TxContext)
20Call do_send_token(&Permission<TokenBank>, &mut TokenBank, u64, address, &mut TxContext)
21CopyLoc[1](Arg1: &mut TokenBank)
22ImmBorrowField[50](TokenBank.stats_liquidity_mine_amount: u64)
23ReadRef
24MoveLoc[2](Arg2: u64)
25Add
26MoveLoc[1](Arg1: &mut TokenBank)
27MutBorrowField[50](TokenBank.stats_liquidity_mine_amount: u64)
28WriteRef
29Ret
}
public do_send_staked_token(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: bool, Arg7: address, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: bool
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(13)
B1:
6CopyLoc[2](Arg2: &mut TokenFarm)
7ImmBorrowField[51](TokenFarm.version: u64)
8ReadRef
9LdConst[0](u64: 0)
10Eq
11StLoc[10](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[10](loc0: bool)
B3:
15MoveLoc[10](loc0: bool)
16BrFalse(18)
B4:
17Branch(28)
B5:
18MoveLoc[2](Arg2: &mut TokenFarm)
19Pop
20MoveLoc[9](Arg9: &mut TxContext)
21Pop
22MoveLoc[8](Arg8: &Clock)
23Pop
24MoveLoc[1](Arg1: &mut TokenBank)
25Pop
26LdConst[20](u64: 200000)
27Abort
B6:
28MoveLoc[1](Arg1: &mut TokenBank)
29MoveLoc[2](Arg2: &mut TokenFarm)
30MoveLoc[3](Arg3: u64)
31MoveLoc[4](Arg4: u64)
32MoveLoc[5](Arg5: u64)
33MoveLoc[6](Arg6: bool)
34MoveLoc[7](Arg7: address)
35MoveLoc[8](Arg8: &Clock)
36MoveLoc[9](Arg9: &mut TxContext)
37Call send_staked_token_impl(&mut TokenBank, &mut TokenFarm, u64, u64, u64, bool, address, &Clock, &mut TxContext)
38Ret
}
public do_send_staked_token_with_target_epoch(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: bool, Arg7: address, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: bool
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(13)
B1:
6CopyLoc[2](Arg2: &mut TokenFarm)
7ImmBorrowField[51](TokenFarm.version: u64)
8ReadRef
9LdConst[0](u64: 0)
10Eq
11StLoc[10](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[10](loc0: bool)
B3:
15MoveLoc[10](loc0: bool)
16BrFalse(18)
B4:
17Branch(28)
B5:
18MoveLoc[2](Arg2: &mut TokenFarm)
19Pop
20MoveLoc[9](Arg9: &mut TxContext)
21Pop
22MoveLoc[8](Arg8: &Clock)
23Pop
24MoveLoc[1](Arg1: &mut TokenBank)
25Pop
26LdConst[20](u64: 200000)
27Abort
B6:
28MoveLoc[1](Arg1: &mut TokenBank)
29MoveLoc[2](Arg2: &mut TokenFarm)
30MoveLoc[3](Arg3: u64)
31CopyLoc[8](Arg8: &Clock)
32MoveLoc[4](Arg4: u64)
33Call utils::get_target_epoch_diff(&Clock, u64): u64
34MoveLoc[5](Arg5: u64)
35MoveLoc[6](Arg6: bool)
36MoveLoc[7](Arg7: address)
37MoveLoc[8](Arg8: &Clock)
38MoveLoc[9](Arg9: &mut TxContext)
39Call send_staked_token_impl(&mut TokenBank, &mut TokenFarm, u64, u64, u64, bool, address, &Clock, &mut TxContext)
40Ret
}
public do_send_staked_token_batch(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: vector<u64>, Arg4: vector<u64>, Arg5: vector<u64>, Arg6: vector<bool>, Arg7: vector<address>, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: bool
L11: loc1: bool
L12: loc2: bool
L13: loc3: bool
L14: loc4: u64
L15: loc5: u64
L16: loc6: u64
L17: loc7: u64
L18: loc8: u64
L19: loc9: u64
L20: loc10: u64
L21: loc11: u64
L22: loc12: bool
L23: loc13: address
L24: loc14: u64
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(13)
B1:
6CopyLoc[2](Arg2: &mut TokenFarm)
7ImmBorrowField[51](TokenFarm.version: u64)
8ReadRef
9LdConst[0](u64: 0)
10Eq
11StLoc[10](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[10](loc0: bool)
B3:
15MoveLoc[10](loc0: bool)
16BrFalse(18)
B4:
17Branch(28)
B5:
18MoveLoc[2](Arg2: &mut TokenFarm)
19Pop
20MoveLoc[9](Arg9: &mut TxContext)
21Pop
22MoveLoc[8](Arg8: &Clock)
23Pop
24MoveLoc[1](Arg1: &mut TokenBank)
25Pop
26LdConst[20](u64: 200000)
27Abort
B6:
28ImmBorrowLoc[3](Arg3: vector<u64>)
29VecLen(6)
30StLoc[17](loc7: u64)
31ImmBorrowLoc[4](Arg4: vector<u64>)
32VecLen(6)
33StLoc[18](loc8: u64)
34ImmBorrowLoc[5](Arg5: vector<u64>)
35VecLen(6)
36StLoc[19](loc9: u64)
37ImmBorrowLoc[6](Arg6: vector<bool>)
38VecLen(14)
39StLoc[20](loc10: u64)
40ImmBorrowLoc[7](Arg7: vector<address>)
41VecLen(10)
42StLoc[21](loc11: u64)
43CopyLoc[17](loc7: u64)
44CopyLoc[18](loc8: u64)
45Eq
46BrFalse(52)
B7:
47MoveLoc[18](loc8: u64)
48CopyLoc[19](loc9: u64)
49Eq
50StLoc[11](loc1: bool)
51Branch(54)
B8:
52LdFalse
53StLoc[11](loc1: bool)
B9:
54MoveLoc[11](loc1: bool)
55BrFalse(61)
B10:
56MoveLoc[19](loc9: u64)
57CopyLoc[20](loc10: u64)
58Eq
59StLoc[12](loc2: bool)
60Branch(63)
B11:
61LdFalse
62StLoc[12](loc2: bool)
B12:
63MoveLoc[12](loc2: bool)
64BrFalse(70)
B13:
65MoveLoc[20](loc10: u64)
66MoveLoc[21](loc11: u64)
67Eq
68StLoc[13](loc3: bool)
69Branch(72)
B14:
70LdFalse
71StLoc[13](loc3: bool)
B15:
72MoveLoc[13](loc3: bool)
73BrFalse(75)
B16:
74Branch(85)
B17:
75MoveLoc[2](Arg2: &mut TokenFarm)
76Pop
77MoveLoc[9](Arg9: &mut TxContext)
78Pop
79MoveLoc[8](Arg8: &Clock)
80Pop
81MoveLoc[1](Arg1: &mut TokenBank)
82Pop
83LdConst[3](u64: 14400)
84Abort
B18:
85LdU64(0)
86StLoc[16](loc6: u64)
B19:
87CopyLoc[16](loc6: u64)
88CopyLoc[17](loc7: u64)
89Lt
90BrFalse(132)
B20:
91Branch(92)
B21:
92ImmBorrowLoc[3](Arg3: vector<u64>)
93CopyLoc[16](loc6: u64)
94VecImmBorrow(6)
95ReadRef
96StLoc[14](loc4: u64)
97ImmBorrowLoc[4](Arg4: vector<u64>)
98CopyLoc[16](loc6: u64)
99VecImmBorrow(6)
100ReadRef
101StLoc[15](loc5: u64)
102ImmBorrowLoc[5](Arg5: vector<u64>)
103CopyLoc[16](loc6: u64)
104VecImmBorrow(6)
105ReadRef
106StLoc[24](loc14: u64)
107ImmBorrowLoc[6](Arg6: vector<bool>)
108CopyLoc[16](loc6: u64)
109VecImmBorrow(14)
110ReadRef
111StLoc[22](loc12: bool)
112ImmBorrowLoc[7](Arg7: vector<address>)
113CopyLoc[16](loc6: u64)
114VecImmBorrow(10)
115ReadRef
116StLoc[23](loc13: address)
117CopyLoc[1](Arg1: &mut TokenBank)
118CopyLoc[2](Arg2: &mut TokenFarm)
119MoveLoc[14](loc4: u64)
120MoveLoc[15](loc5: u64)
121MoveLoc[24](loc14: u64)
122MoveLoc[22](loc12: bool)
123MoveLoc[23](loc13: address)
124CopyLoc[8](Arg8: &Clock)
125CopyLoc[9](Arg9: &mut TxContext)
126Call send_staked_token_impl(&mut TokenBank, &mut TokenFarm, u64, u64, u64, bool, address, &Clock, &mut TxContext)
127MoveLoc[16](loc6: u64)
128LdU64(1)
129Add
130StLoc[16](loc6: u64)
131Branch(87)
B22:
132MoveLoc[2](Arg2: &mut TokenFarm)
133Pop
134MoveLoc[9](Arg9: &mut TxContext)
135Pop
136MoveLoc[8](Arg8: &Clock)
137Pop
138MoveLoc[1](Arg1: &mut TokenBank)
139Pop
140Ret
}
public do_send_staked_token_with_target_epoch_batch(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: &mut TokenFarm, Arg3: vector<u64>, Arg4: vector<u64>, Arg5: vector<u64>, Arg6: vector<bool>, Arg7: vector<address>, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: bool
L11: loc1: bool
L12: loc2: bool
L13: loc3: bool
L14: loc4: u64
L15: loc5: u64
L16: loc6: u64
L17: loc7: u64
L18: loc8: u64
L19: loc9: u64
L20: loc10: u64
L21: loc11: bool
L22: loc12: address
L23: loc13: u64
L24: loc14: u64
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(13)
B1:
6CopyLoc[2](Arg2: &mut TokenFarm)
7ImmBorrowField[51](TokenFarm.version: u64)
8ReadRef
9LdConst[0](u64: 0)
10Eq
11StLoc[10](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[10](loc0: bool)
B3:
15MoveLoc[10](loc0: bool)
16BrFalse(18)
B4:
17Branch(28)
B5:
18MoveLoc[2](Arg2: &mut TokenFarm)
19Pop
20MoveLoc[9](Arg9: &mut TxContext)
21Pop
22MoveLoc[8](Arg8: &Clock)
23Pop
24MoveLoc[1](Arg1: &mut TokenBank)
25Pop
26LdConst[20](u64: 200000)
27Abort
B6:
28ImmBorrowLoc[3](Arg3: vector<u64>)
29VecLen(6)
30StLoc[16](loc6: u64)
31ImmBorrowLoc[4](Arg4: vector<u64>)
32VecLen(6)
33StLoc[17](loc7: u64)
34ImmBorrowLoc[5](Arg5: vector<u64>)
35VecLen(6)
36StLoc[18](loc8: u64)
37ImmBorrowLoc[6](Arg6: vector<bool>)
38VecLen(14)
39StLoc[19](loc9: u64)
40ImmBorrowLoc[7](Arg7: vector<address>)
41VecLen(10)
42StLoc[20](loc10: u64)
43CopyLoc[16](loc6: u64)
44CopyLoc[17](loc7: u64)
45Eq
46BrFalse(52)
B7:
47MoveLoc[17](loc7: u64)
48CopyLoc[18](loc8: u64)
49Eq
50StLoc[11](loc1: bool)
51Branch(54)
B8:
52LdFalse
53StLoc[11](loc1: bool)
B9:
54MoveLoc[11](loc1: bool)
55BrFalse(61)
B10:
56MoveLoc[18](loc8: u64)
57CopyLoc[19](loc9: u64)
58Eq
59StLoc[12](loc2: bool)
60Branch(63)
B11:
61LdFalse
62StLoc[12](loc2: bool)
B12:
63MoveLoc[12](loc2: bool)
64BrFalse(70)
B13:
65MoveLoc[19](loc9: u64)
66MoveLoc[20](loc10: u64)
67Eq
68StLoc[13](loc3: bool)
69Branch(72)
B14:
70LdFalse
71StLoc[13](loc3: bool)
B15:
72MoveLoc[13](loc3: bool)
73BrFalse(75)
B16:
74Branch(85)
B17:
75MoveLoc[2](Arg2: &mut TokenFarm)
76Pop
77MoveLoc[9](Arg9: &mut TxContext)
78Pop
79MoveLoc[8](Arg8: &Clock)
80Pop
81MoveLoc[1](Arg1: &mut TokenBank)
82Pop
83LdConst[3](u64: 14400)
84Abort
B18:
85LdU64(0)
86StLoc[15](loc5: u64)
B19:
87CopyLoc[15](loc5: u64)
88CopyLoc[16](loc6: u64)
89Lt
90BrFalse(134)
B20:
91Branch(92)
B21:
92ImmBorrowLoc[3](Arg3: vector<u64>)
93CopyLoc[15](loc5: u64)
94VecImmBorrow(6)
95ReadRef
96StLoc[14](loc4: u64)
97ImmBorrowLoc[4](Arg4: vector<u64>)
98CopyLoc[15](loc5: u64)
99VecImmBorrow(6)
100ReadRef
101StLoc[23](loc13: u64)
102ImmBorrowLoc[5](Arg5: vector<u64>)
103CopyLoc[15](loc5: u64)
104VecImmBorrow(6)
105ReadRef
106StLoc[24](loc14: u64)
107ImmBorrowLoc[6](Arg6: vector<bool>)
108CopyLoc[15](loc5: u64)
109VecImmBorrow(14)
110ReadRef
111StLoc[21](loc11: bool)
112ImmBorrowLoc[7](Arg7: vector<address>)
113CopyLoc[15](loc5: u64)
114VecImmBorrow(10)
115ReadRef
116StLoc[22](loc12: address)
117CopyLoc[1](Arg1: &mut TokenBank)
118CopyLoc[2](Arg2: &mut TokenFarm)
119MoveLoc[14](loc4: u64)
120CopyLoc[8](Arg8: &Clock)
121MoveLoc[23](loc13: u64)
122Call utils::get_target_epoch_diff(&Clock, u64): u64
123MoveLoc[24](loc14: u64)
124MoveLoc[21](loc11: bool)
125MoveLoc[22](loc12: address)
126CopyLoc[8](Arg8: &Clock)
127CopyLoc[9](Arg9: &mut TxContext)
128Call send_staked_token_impl(&mut TokenBank, &mut TokenFarm, u64, u64, u64, bool, address, &Clock, &mut TxContext)
129MoveLoc[15](loc5: u64)
130LdU64(1)
131Add
132StLoc[15](loc5: u64)
133Branch(87)
B22:
134MoveLoc[2](Arg2: &mut TokenFarm)
135Pop
136MoveLoc[9](Arg9: &mut TxContext)
137Pop
138MoveLoc[8](Arg8: &Clock)
139Pop
140MoveLoc[1](Arg1: &mut TokenBank)
141Pop
142Ret
}
public do_create_token_airdrop(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: vector<u8>, Arg3: vector<u8>, Arg4: u64, Arg5: u64, Arg6: bool, Arg7: &mut TxContext) {
L8: loc0: ID
L9: loc1: UID
L10: loc2: u64
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[7](Arg7: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[4](Arg4: u64)
14LdU64(0)
15Gt
16BrFalse(18)
B4:
17Branch(24)
B5:
18MoveLoc[7](Arg7: &mut TxContext)
19Pop
20MoveLoc[1](Arg1: &mut TokenBank)
21Pop
22LdConst[3](u64: 14400)
23Abort
B6:
24CopyLoc[5](Arg5: u64)
25CopyLoc[4](Arg4: u64)
26Le
27BrFalse(29)
B7:
28Branch(35)
B8:
29MoveLoc[7](Arg7: &mut TxContext)
30Pop
31MoveLoc[1](Arg1: &mut TokenBank)
32Pop
33LdConst[3](u64: 14400)
34Abort
B9:
35CopyLoc[1](Arg1: &mut TokenBank)
36ImmBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
37Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
38StLoc[10](loc2: u64)
39CopyLoc[4](Arg4: u64)
40MoveLoc[10](loc2: u64)
41Le
42BrFalse(44)
B10:
43Branch(50)
B11:
44MoveLoc[7](Arg7: &mut TxContext)
45Pop
46MoveLoc[1](Arg1: &mut TokenBank)
47Pop
48LdConst[4](u64: 144001)
49Abort
B12:
50CopyLoc[7](Arg7: &mut TxContext)
51Call object::new(&mut TxContext): UID
52StLoc[9](loc1: UID)
53ImmBorrowLoc[9](loc1: UID)
54Call object::uid_to_inner(&UID): ID
55StLoc[8](loc0: ID)
56CopyLoc[1](Arg1: &mut TokenBank)
57MutBorrowField[52](TokenBank.token_airdrop_ids: vector<ID>)
58CopyLoc[8](loc0: ID)
59VecPushBack(5)
60MoveLoc[9](loc1: UID)
61LdConst[0](u64: 0)
62MoveLoc[8](loc0: ID)
63MoveLoc[2](Arg2: vector<u8>)
64CopyLoc[1](Arg1: &mut TokenBank)
65ImmBorrowField[8](TokenBank.id: UID)
66Call object::uid_to_inner(&UID): ID
67CopyLoc[1](Arg1: &mut TokenBank)
68ImmBorrowField[9](TokenBank.owner: address)
69ReadRef
70MoveLoc[5](Arg5: u64)
71MoveLoc[3](Arg3: vector<u8>)
72MoveLoc[7](Arg7: &mut TxContext)
73Call table::new<address, u8>(&mut TxContext): Table<address, u8>
74MoveLoc[1](Arg1: &mut TokenBank)
75MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
76MoveLoc[4](Arg4: u64)
77Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
78Call sbalance::from_balance<TOKEN>(Balance<TOKEN>): SBalance<TOKEN>
79MoveLoc[6](Arg6: bool)
80Pack[12](TokenAirdrop)
81Call transfer::share_object<TokenAirdrop>(TokenAirdrop)
82Ret
}
public do_claim_token_airdrop_token_legacy(Arg0: &mut TokenAirdrop, Arg1: u64, Arg2: vector<u8>, Arg3: &mut TxContext) {
L4: loc0: address
L5: loc1: bool
L6: loc2: vector<u8>
L7: loc3: address
L8: loc4: address
B0:
0CopyLoc[0](Arg0: &mut TokenAirdrop)
1ImmBorrowField[53](TokenAirdrop.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[3](Arg3: &mut TxContext)
8Pop
9MoveLoc[0](Arg0: &mut TokenAirdrop)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[1](Arg1: u64)
14CopyLoc[0](Arg0: &mut TokenAirdrop)
15ImmBorrowField[16](TokenAirdrop.balance: SBalance<TOKEN>)
16Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
17Le
18BrFalse(20)
B4:
19Branch(26)
B5:
20MoveLoc[3](Arg3: &mut TxContext)
21Pop
22MoveLoc[0](Arg0: &mut TokenAirdrop)
23Pop
24LdConst[4](u64: 144001)
25Abort
B6:
26CopyLoc[3](Arg3: &mut TxContext)
27FreezeRef
28Call tx_context::sender(&TxContext): address
29StLoc[7](loc3: address)
30CopyLoc[0](Arg0: &mut TokenAirdrop)
31ImmBorrowField[54](TokenAirdrop.allow_duplicate: bool)
32ReadRef
33LdFalse
34Eq
35BrFalse(52)
B7:
36CopyLoc[0](Arg0: &mut TokenAirdrop)
37MoveLoc[7](loc3: address)
38StLoc[4](loc0: address)
39FreezeRef
40MoveLoc[4](loc0: address)
41Call token_airdrop_has_used_address(&TokenAirdrop, address): bool
42LdFalse
43Eq
44BrFalse(46)
B8:
45Branch(52)
B9:
46MoveLoc[3](Arg3: &mut TxContext)
47Pop
48MoveLoc[0](Arg0: &mut TokenAirdrop)
49Pop
50LdConst[5](u64: 144002)
51Abort
B10:
52CopyLoc[3](Arg3: &mut TxContext)
53FreezeRef
54Call tx_context::sender(&TxContext): address
55StLoc[8](loc4: address)
56CopyLoc[0](Arg0: &mut TokenAirdrop)
57FreezeRef
58Call token_airdrop_is_free(&TokenAirdrop): bool
59BrFalse(67)
B11:
60CopyLoc[1](Arg1: u64)
61CopyLoc[0](Arg0: &mut TokenAirdrop)
62ImmBorrowField[14](TokenAirdrop.free_amount: u64)
63ReadRef
64Eq
65StLoc[5](loc1: bool)
66Branch(90)
B12:
67CopyLoc[0](Arg0: &mut TokenAirdrop)
68ImmBorrowField[15](TokenAirdrop.name: vector<u8>)
69ReadRef
70StLoc[6](loc2: vector<u8>)
71MutBorrowLoc[6](loc2: vector<u8>)
72CopyLoc[0](Arg0: &mut TokenAirdrop)
73ImmBorrowField[55](TokenAirdrop.verify_id: ID)
74Call bcs::to_bytes<ID>(&ID): vector<u8>
75Call vector::append<u8>(&mut vector<u8>, vector<u8>)
76MutBorrowLoc[6](loc2: vector<u8>)
77ImmBorrowLoc[8](loc4: address)
78Call bcs::to_bytes<address>(&address): vector<u8>
79Call vector::append<u8>(&mut vector<u8>, vector<u8>)
80MutBorrowLoc[6](loc2: vector<u8>)
81ImmBorrowLoc[1](Arg1: u64)
82Call bcs::to_bytes<u64>(&u64): vector<u8>
83Call vector::append<u8>(&mut vector<u8>, vector<u8>)
84ImmBorrowLoc[2](Arg2: vector<u8>)
85CopyLoc[0](Arg0: &mut TokenAirdrop)
86ImmBorrowField[56](TokenAirdrop.public_key: vector<u8>)
87ImmBorrowLoc[6](loc2: vector<u8>)
88Call ed25519::ed25519_verify(&vector<u8>, &vector<u8>, &vector<u8>): bool
89StLoc[5](loc1: bool)
B13:
90MoveLoc[5](loc1: bool)
91BrFalse(93)
B14:
92Branch(99)
B15:
93MoveLoc[3](Arg3: &mut TxContext)
94Pop
95MoveLoc[0](Arg0: &mut TokenAirdrop)
96Pop
97LdConst[6](u64: 144003)
98Abort
B16:
99CopyLoc[0](Arg0: &mut TokenAirdrop)
100MutBorrowField[16](TokenAirdrop.balance: SBalance<TOKEN>)
101MoveLoc[1](Arg1: u64)
102Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
103MoveLoc[3](Arg3: &mut TxContext)
104Call coin::from_balance<TOKEN>(Balance<TOKEN>, &mut TxContext): Coin<TOKEN>
105CopyLoc[8](loc4: address)
106Call transfer::public_transfer<Coin<TOKEN>>(Coin<TOKEN>, address)
107CopyLoc[0](Arg0: &mut TokenAirdrop)
108ImmBorrowField[54](TokenAirdrop.allow_duplicate: bool)
109ReadRef
110LdFalse
111Eq
112BrFalse(119)
B17:
113MoveLoc[0](Arg0: &mut TokenAirdrop)
114MutBorrowField[17](TokenAirdrop.address_table: Table<address, u8>)
115MoveLoc[8](loc4: address)
116LdU8(1)
117Call table::add<address, u8>(&mut Table<address, u8>, address, u8)
118Branch(121)
B18:
119MoveLoc[0](Arg0: &mut TokenAirdrop)
120Pop
B19:
121Ret
}
public do_claim_token_airdrop_token(Arg0: &mut TokenAirdrop, Arg1: u64, Arg2: vector<u8>, Arg3: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut TokenAirdrop)
1CopyLoc[1](Arg1: u64)
2MoveLoc[2](Arg2: vector<u8>)
3MoveLoc[3](Arg3: &mut TxContext)
4Call do_claim_token_airdrop_token_legacy(&mut TokenAirdrop, u64, vector<u8>, &mut TxContext)
5MoveLoc[0](Arg0: &mut TokenAirdrop)
6ImmBorrowField[11](TokenAirdrop.id: UID)
7Call object::uid_to_inner(&UID): ID
8MoveLoc[1](Arg1: u64)
9Pack[20](ClaimTokenAirdropEvent)
10Call event::emit<ClaimTokenAirdropEvent>(ClaimTokenAirdropEvent)
11Ret
}
public do_create_token_ido(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: vector<u8>, Arg3: u64, Arg4: bool, Arg5: u64, Arg6: &mut TxContext) {
L7: loc0: ID
L8: loc1: UID
L9: loc2: u64
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[6](Arg6: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[3](Arg3: u64)
14LdU64(0)
15Gt
16BrFalse(18)
B4:
17Branch(24)
B5:
18MoveLoc[6](Arg6: &mut TxContext)
19Pop
20MoveLoc[1](Arg1: &mut TokenBank)
21Pop
22LdConst[3](u64: 14400)
23Abort
B6:
24CopyLoc[5](Arg5: u64)
25LdU64(0)
26Gt
27BrFalse(29)
B7:
28Branch(35)
B8:
29MoveLoc[6](Arg6: &mut TxContext)
30Pop
31MoveLoc[1](Arg1: &mut TokenBank)
32Pop
33LdConst[3](u64: 14400)
34Abort
B9:
35CopyLoc[1](Arg1: &mut TokenBank)
36ImmBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
37Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
38StLoc[9](loc2: u64)
39CopyLoc[5](Arg5: u64)
40MoveLoc[9](loc2: u64)
41Le
42BrFalse(44)
B10:
43Branch(50)
B11:
44MoveLoc[6](Arg6: &mut TxContext)
45Pop
46MoveLoc[1](Arg1: &mut TokenBank)
47Pop
48LdConst[4](u64: 144001)
49Abort
B12:
50CopyLoc[6](Arg6: &mut TxContext)
51Call object::new(&mut TxContext): UID
52StLoc[8](loc1: UID)
53ImmBorrowLoc[8](loc1: UID)
54Call object::uid_to_inner(&UID): ID
55StLoc[7](loc0: ID)
56CopyLoc[1](Arg1: &mut TokenBank)
57MutBorrowField[57](TokenBank.token_ido_ids: vector<ID>)
58MoveLoc[7](loc0: ID)
59VecPushBack(5)
60MoveLoc[8](loc1: UID)
61LdConst[0](u64: 0)
62CopyLoc[1](Arg1: &mut TokenBank)
63ImmBorrowField[8](TokenBank.id: UID)
64Call object::uid_to_inner(&UID): ID
65MoveLoc[2](Arg2: vector<u8>)
66MoveLoc[3](Arg3: u64)
67MoveLoc[4](Arg4: bool)
68MoveLoc[6](Arg6: &mut TxContext)
69Call table::new<address, u8>(&mut TxContext): Table<address, u8>
70LdTrue
71Call balance::zero<SUI>(): Balance<SUI>
72MoveLoc[1](Arg1: &mut TokenBank)
73MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
74MoveLoc[5](Arg5: u64)
75Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
76Call sbalance::from_balance<TOKEN>(Balance<TOKEN>): SBalance<TOKEN>
77Pack[15](TokenIdo)
78Call transfer::share_object<TokenIdo>(TokenIdo)
79Ret
}
public do_close_token_ido(Arg0: &Permission<TokenBank>, Arg1: &Permission<TokenIdo>, Arg2: &mut TokenBank, Arg3: &mut TokenIdo, Arg4: &mut TxContext) {
L5: loc0: bool
B0:
0CopyLoc[2](Arg2: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(13)
B1:
6CopyLoc[3](Arg3: &mut TokenIdo)
7ImmBorrowField[58](TokenIdo.version: u64)
8ReadRef
9LdConst[0](u64: 0)
10Eq
11StLoc[5](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[5](loc0: bool)
B3:
15MoveLoc[5](loc0: bool)
16BrFalse(18)
B4:
17Branch(24)
B5:
18MoveLoc[3](Arg3: &mut TokenIdo)
19Pop
20MoveLoc[2](Arg2: &mut TokenBank)
21Pop
22LdConst[20](u64: 200000)
23Abort
B6:
24CopyLoc[3](Arg3: &mut TokenIdo)
25ImmBorrowField[27](TokenIdo.bank_id: ID)
26ReadRef
27CopyLoc[2](Arg2: &mut TokenBank)
28ImmBorrowField[8](TokenBank.id: UID)
29Call object::uid_to_inner(&UID): ID
30Eq
31BrFalse(33)
B7:
32Branch(39)
B8:
33MoveLoc[3](Arg3: &mut TokenIdo)
34Pop
35MoveLoc[2](Arg2: &mut TokenBank)
36Pop
37LdConst[3](u64: 14400)
38Abort
B9:
39MoveLoc[2](Arg2: &mut TokenBank)
40MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
41CopyLoc[3](Arg3: &mut TokenIdo)
42MutBorrowField[33](TokenIdo.balance: SBalance<TOKEN>)
43Call sbalance::split_all<TOKEN>(&mut SBalance<TOKEN>): Balance<TOKEN>
44Call sbalance::deposit<TOKEN>(&mut SBalance<TOKEN>, Balance<TOKEN>)
45MoveLoc[3](Arg3: &mut TokenIdo)
46ImmBorrowField[33](TokenIdo.balance: SBalance<TOKEN>)
47Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
48LdU64(0)
49Eq
50BrFalse(52)
B10:
51Branch(54)
B11:
52LdConst[19](u64: 144042)
53Abort
B12:
54Ret
}
public do_withdraw_token_ido_collect(Arg0: &Permission<TokenIdo>, Arg1: &mut TokenIdo, Arg2: &mut TxContext) {
L3: loc0: u64
B0:
0CopyLoc[1](Arg1: &mut TokenIdo)
1ImmBorrowField[58](TokenIdo.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut TokenIdo)
8Pop
9MoveLoc[2](Arg2: &mut TxContext)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[1](Arg1: &mut TokenIdo)
14ImmBorrowField[32](TokenIdo.collect: Balance<SUI>)
15Call balance::value<SUI>(&Balance<SUI>): u64
16StLoc[3](loc0: u64)
17MoveLoc[1](Arg1: &mut TokenIdo)
18MutBorrowField[32](TokenIdo.collect: Balance<SUI>)
19MoveLoc[3](loc0: u64)
20Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
21CopyLoc[2](Arg2: &mut TxContext)
22Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
23MoveLoc[2](Arg2: &mut TxContext)
24FreezeRef
25Call tx_context::sender(&TxContext): address
26Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
27Ret
}
public do_add_token_ido_whitelist(Arg0: &mut TokenIdo, Arg1: &mut TxContext) {
L2: loc0: address
B0:
0CopyLoc[0](Arg0: &mut TokenIdo)
1ImmBorrowField[58](TokenIdo.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[0](Arg0: &mut TokenIdo)
8Pop
9MoveLoc[1](Arg1: &mut TxContext)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[0](Arg0: &mut TokenIdo)
14ImmBorrowField[31](TokenIdo.is_whitelists_editable: bool)
15ReadRef
16LdTrue
17Eq
18BrFalse(20)
B4:
19Branch(26)
B5:
20MoveLoc[0](Arg0: &mut TokenIdo)
21Pop
22MoveLoc[1](Arg1: &mut TxContext)
23Pop
24LdConst[7](u64: 144004)
25Abort
B6:
26MoveLoc[1](Arg1: &mut TxContext)
27FreezeRef
28Call tx_context::sender(&TxContext): address
29StLoc[2](loc0: address)
30CopyLoc[0](Arg0: &mut TokenIdo)
31ImmBorrowField[34](TokenIdo.whitelists: Table<address, u8>)
32CopyLoc[2](loc0: address)
33Call table::contains<address, u8>(&Table<address, u8>, address): bool
34LdFalse
35Eq
36BrFalse(42)
B7:
37CopyLoc[0](Arg0: &mut TokenIdo)
38MutBorrowField[34](TokenIdo.whitelists: Table<address, u8>)
39MoveLoc[2](loc0: address)
40LdU8(1)
41Call table::add<address, u8>(&mut Table<address, u8>, address, u8)
B8:
42MoveLoc[0](Arg0: &mut TokenIdo)
43ImmBorrowField[26](TokenIdo.id: UID)
44Call object::uid_to_inner(&UID): ID
45Pack[21](AddTokenIdoWhitelistEvent)
46Call event::emit<AddTokenIdoWhitelistEvent>(AddTokenIdoWhitelistEvent)
47Ret
}
public do_change_token_ido_publicity(Arg0: &Permission<TokenIdo>, Arg1: &mut TokenIdo, Arg2: bool, Arg3: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut TokenIdo)
1ImmBorrowField[58](TokenIdo.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[1](Arg1: &mut TokenIdo)
8Pop
9LdConst[20](u64: 200000)
10Abort
B3:
11MoveLoc[2](Arg2: bool)
12MoveLoc[1](Arg1: &mut TokenIdo)
13MutBorrowField[30](TokenIdo.is_public: bool)
14WriteRef
15Ret
}
public do_change_token_ido_whitelists_editable(Arg0: &Permission<TokenIdo>, Arg1: &mut TokenIdo, Arg2: bool, Arg3: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut TokenIdo)
1ImmBorrowField[58](TokenIdo.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[1](Arg1: &mut TokenIdo)
8Pop
9LdConst[20](u64: 200000)
10Abort
B3:
11MoveLoc[2](Arg2: bool)
12MoveLoc[1](Arg1: &mut TokenIdo)
13MutBorrowField[31](TokenIdo.is_whitelists_editable: bool)
14WriteRef
15Ret
}
public do_buy_token_ido_token(Arg0: &mut TokenIdo, Arg1: vector<Coin<SUI>>, Arg2: u64, Arg3: &mut TxContext) {
L4: loc0: address
L5: loc1: Balance<SUI>
L6: loc2: u128
L7: loc3: u64
L8: loc4: u64
L9: loc5: Coin<TOKEN>
L10: loc6: u128
L11: loc7: u64
L12: loc8: address
B0:
0CopyLoc[0](Arg0: &mut TokenIdo)
1ImmBorrowField[58](TokenIdo.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[0](Arg0: &mut TokenIdo)
8Pop
9MoveLoc[3](Arg3: &mut TxContext)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[3](Arg3: &mut TxContext)
14FreezeRef
15Call tx_context::sender(&TxContext): address
16StLoc[12](loc8: address)
17CopyLoc[0](Arg0: &mut TokenIdo)
18MoveLoc[12](loc8: address)
19StLoc[4](loc0: address)
20FreezeRef
21MoveLoc[4](loc0: address)
22Call token_ido_is_public_or_has_whitelist_address(&TokenIdo, address): bool
23LdTrue
24Eq
25BrFalse(27)
B4:
26Branch(33)
B5:
27MoveLoc[0](Arg0: &mut TokenIdo)
28Pop
29MoveLoc[3](Arg3: &mut TxContext)
30Pop
31LdConst[8](u64: 144005)
32Abort
B6:
33CopyLoc[0](Arg0: &mut TokenIdo)
34ImmBorrowField[29](TokenIdo.price_e9: u64)
35ReadRef
36StLoc[11](loc7: u64)
37CopyLoc[2](Arg2: u64)
38CastU128
39CopyLoc[11](loc7: u64)
40CastU128
41Mul
42LdConst[21](u128: 1000..)
43Div
44CastU64
45StLoc[8](loc4: u64)
46CopyLoc[0](Arg0: &mut TokenIdo)
47ImmBorrowField[33](TokenIdo.balance: SBalance<TOKEN>)
48Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
49StLoc[7](loc3: u64)
50CopyLoc[8](loc4: u64)
51CopyLoc[7](loc3: u64)
52Gt
53BrFalse(74)
B7:
54CopyLoc[7](loc3: u64)
55StLoc[8](loc4: u64)
56MoveLoc[7](loc3: u64)
57CastU128
58StLoc[6](loc2: u128)
59MoveLoc[11](loc7: u64)
60CastU128
61StLoc[10](loc6: u128)
62MoveLoc[6](loc2: u128)
63LdConst[21](u128: 1000..)
64CastU128
65Mul
66CopyLoc[10](loc6: u128)
67LdU128(1)
68Sub
69Add
70MoveLoc[10](loc6: u128)
71Div
72CastU64
73StLoc[2](Arg2: u64)
B8:
74MoveLoc[1](Arg1: vector<Coin<SUI>>)
75CopyLoc[2](Arg2: u64)
76CopyLoc[3](Arg3: &mut TxContext)
77Call utils::merge_coins_to_amount_and_transfer_back_rest<SUI>(vector<Coin<SUI>>, u64, &mut TxContext): Coin<SUI>
78Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
79StLoc[5](loc1: Balance<SUI>)
80CopyLoc[0](Arg0: &mut TokenIdo)
81MutBorrowField[33](TokenIdo.balance: SBalance<TOKEN>)
82CopyLoc[8](loc4: u64)
83Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
84CopyLoc[3](Arg3: &mut TxContext)
85Call coin::from_balance<TOKEN>(Balance<TOKEN>, &mut TxContext): Coin<TOKEN>
86StLoc[9](loc5: Coin<TOKEN>)
87CopyLoc[0](Arg0: &mut TokenIdo)
88MutBorrowField[32](TokenIdo.collect: Balance<SUI>)
89MoveLoc[5](loc1: Balance<SUI>)
90Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
91Pop
92MoveLoc[9](loc5: Coin<TOKEN>)
93MoveLoc[3](Arg3: &mut TxContext)
94FreezeRef
95Call tx_context::sender(&TxContext): address
96Call transfer::public_transfer<Coin<TOKEN>>(Coin<TOKEN>, address)
97MoveLoc[0](Arg0: &mut TokenIdo)
98ImmBorrowField[26](TokenIdo.id: UID)
99Call object::uid_to_inner(&UID): ID
100MoveLoc[2](Arg2: u64)
101MoveLoc[8](loc4: u64)
102Pack[22](BuyTokenIdoTokenEvent)
103Call event::emit<BuyTokenIdoTokenEvent>(BuyTokenIdoTokenEvent)
104Ret
}
public do_create_token_farm(Arg0: &Permission<TokenBank>, Arg1: &mut TokenBank, Arg2: u64, Arg3: u64, Arg4: vector<u64>, Arg5: &mut TxContext) {
L6: loc0: ID
L7: loc1: u64
L8: loc2: u64
L9: loc3: u64
L10: loc4: Table<u64, TokenFarmIndexValue>
L11: loc5: ID
L12: loc6: UID
B0:
0CopyLoc[1](Arg1: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[5](Arg5: &mut TxContext)
8Pop
9MoveLoc[1](Arg1: &mut TokenBank)
10Pop
11LdConst[20](u64: 200000)
12Abort
B3:
13CopyLoc[2](Arg2: u64)
14LdU64(0)
15Gt
16BrFalse(18)
B4:
17Branch(24)
B5:
18MoveLoc[5](Arg5: &mut TxContext)
19Pop
20MoveLoc[1](Arg1: &mut TokenBank)
21Pop
22LdConst[3](u64: 14400)
23Abort
B6:
24CopyLoc[5](Arg5: &mut TxContext)
25Call object::new(&mut TxContext): UID
26StLoc[12](loc6: UID)
27ImmBorrowLoc[12](loc6: UID)
28Call object::uid_to_inner(&UID): ID
29StLoc[11](loc5: ID)
30CopyLoc[1](Arg1: &mut TokenBank)
31MutBorrowField[59](TokenBank.token_farm_ids: vector<ID>)
32MoveLoc[11](loc5: ID)
33VecPushBack(5)
34MoveLoc[1](Arg1: &mut TokenBank)
35ImmBorrowField[8](TokenBank.id: UID)
36Call object::uid_to_inner(&UID): ID
37StLoc[6](loc0: ID)
38MoveLoc[5](Arg5: &mut TxContext)
39Call table::new<u64, TokenFarmIndexValue>(&mut TxContext): Table<u64, TokenFarmIndexValue>
40StLoc[10](loc4: Table<u64, TokenFarmIndexValue>)
B7:
41ImmBorrowLoc[4](Arg4: vector<u64>)
42VecLen(6)
43LdU64(0)
44Gt
45BrFalse(63)
B8:
46Branch(47)
B9:
47MutBorrowLoc[4](Arg4: vector<u64>)
48VecPopBack(6)
49StLoc[7](loc1: u64)
50MutBorrowLoc[4](Arg4: vector<u64>)
51VecPopBack(6)
52StLoc[9](loc3: u64)
53MutBorrowLoc[4](Arg4: vector<u64>)
54VecPopBack(6)
55StLoc[8](loc2: u64)
56MutBorrowLoc[10](loc4: Table<u64, TokenFarmIndexValue>)
57MoveLoc[8](loc2: u64)
58MoveLoc[9](loc3: u64)
59MoveLoc[7](loc1: u64)
60Pack[13](TokenFarmIndexValue)
61Call table::add<u64, TokenFarmIndexValue>(&mut Table<u64, TokenFarmIndexValue>, u64, TokenFarmIndexValue)
62Branch(41)
B10:
63MoveLoc[12](loc6: UID)
64LdConst[0](u64: 0)
65MoveLoc[6](loc0: ID)
66MoveLoc[2](Arg2: u64)
67MoveLoc[3](Arg3: u64)
68MoveLoc[10](loc4: Table<u64, TokenFarmIndexValue>)
69LdU64(0)
70LdU128(0)
71Pack[14](TokenFarm)
72Call transfer::share_object<TokenFarm>(TokenFarm)
73Ret
}
public do_stake_token(Arg0: &mut TokenBank, Arg1: &mut TokenFarm, Arg2: Coin<TOKEN>, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {
L6: loc0: bool
L7: loc1: Balance<TOKEN>
L8: loc2: Balance<TOKEN>
L9: loc3: u64
L10: loc4: u64
L11: loc5: &TokenFarmIndexValue
L12: loc6: Balance<TOKEN>
L13: loc7: u64
L14: loc8: address
L15: loc9: StakedToken
L16: loc10: u64
B0:
0CopyLoc[0](Arg0: &mut TokenBank)
1ImmBorrowField[47](TokenBank.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(13)
B1:
6CopyLoc[1](Arg1: &mut TokenFarm)
7ImmBorrowField[51](TokenFarm.version: u64)
8ReadRef
9LdConst[0](u64: 0)
10Eq
11StLoc[6](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[6](loc0: bool)
B3:
15MoveLoc[6](loc0: bool)
16BrFalse(18)
B4:
17Branch(28)
B5:
18MoveLoc[1](Arg1: &mut TokenFarm)
19Pop
20MoveLoc[5](Arg5: &mut TxContext)
21Pop
22MoveLoc[4](Arg4: &Clock)
23Pop
24MoveLoc[0](Arg0: &mut TokenBank)
25Pop
26LdConst[20](u64: 200000)
27Abort
B6:
28CopyLoc[3](Arg3: u64)
29CopyLoc[1](Arg1: &mut TokenFarm)
30ImmBorrowField[60](TokenFarm.min_stake_index: u64)
31ReadRef
32Ge
33BrFalse(35)
B7:
34Branch(45)
B8:
35MoveLoc[1](Arg1: &mut TokenFarm)
36Pop
37MoveLoc[5](Arg5: &mut TxContext)
38Pop
39MoveLoc[4](Arg4: &Clock)
40Pop
41MoveLoc[0](Arg0: &mut TokenBank)
42Pop
43LdConst[15](u64: 144012)
44Abort
B9:
45ImmBorrowLoc[2](Arg2: Coin<TOKEN>)
46Call coin::value<TOKEN>(&Coin<TOKEN>): u64
47LdU64(0)
48Gt
49BrFalse(51)
B10:
50Branch(61)
B11:
51MoveLoc[1](Arg1: &mut TokenFarm)
52Pop
53MoveLoc[5](Arg5: &mut TxContext)
54Pop
55MoveLoc[4](Arg4: &Clock)
56Pop
57MoveLoc[0](Arg0: &mut TokenBank)
58Pop
59LdConst[3](u64: 14400)
60Abort
B12:
61CopyLoc[1](Arg1: &mut TokenFarm)
62ImmBorrowField[23](TokenFarm.stake_index_table: Table<u64, TokenFarmIndexValue>)
63CopyLoc[3](Arg3: u64)
64Call table::contains<u64, TokenFarmIndexValue>(&Table<u64, TokenFarmIndexValue>, u64): bool
65BrFalse(67)
B13:
66Branch(77)
B14:
67MoveLoc[1](Arg1: &mut TokenFarm)
68Pop
69MoveLoc[5](Arg5: &mut TxContext)
70Pop
71MoveLoc[4](Arg4: &Clock)
72Pop
73MoveLoc[0](Arg0: &mut TokenBank)
74Pop
75LdConst[11](u64: 144008)
76Abort
B15:
77CopyLoc[5](Arg5: &mut TxContext)
78FreezeRef
79Call tx_context::sender(&TxContext): address
80StLoc[14](loc8: address)
81CopyLoc[1](Arg1: &mut TokenFarm)
82ImmBorrowField[23](TokenFarm.stake_index_table: Table<u64, TokenFarmIndexValue>)
83CopyLoc[3](Arg3: u64)
84Call table::borrow<u64, TokenFarmIndexValue>(&Table<u64, TokenFarmIndexValue>, u64): &TokenFarmIndexValue
85StLoc[11](loc5: &TokenFarmIndexValue)
86ImmBorrowLoc[2](Arg2: Coin<TOKEN>)
87Call coin::value<TOKEN>(&Coin<TOKEN>): u64
88StLoc[9](loc3: u64)
89MoveLoc[2](Arg2: Coin<TOKEN>)
90Call coin::into_balance<TOKEN>(Coin<TOKEN>): Balance<TOKEN>
91StLoc[8](loc2: Balance<TOKEN>)
92CopyLoc[11](loc5: &TokenFarmIndexValue)
93ImmBorrowField[18](TokenFarmIndexValue.profit: u64)
94ReadRef
95LdConst[2](u64: 10000)
96Call ratio::ratio(u64, u64): Ratio
97MoveLoc[9](loc3: u64)
98Call ratio::partial(Ratio, u64): u64
99StLoc[13](loc7: u64)
100CopyLoc[13](loc7: u64)
101CopyLoc[0](Arg0: &mut TokenBank)
102ImmBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
103Call sbalance::value<TOKEN>(&SBalance<TOKEN>): u64
104Le
105BrFalse(112)
B16:
106MoveLoc[0](Arg0: &mut TokenBank)
107MutBorrowField[10](TokenBank.balance: SBalance<TOKEN>)
108MoveLoc[13](loc7: u64)
109Call sbalance::split<TOKEN>(&mut SBalance<TOKEN>, u64): Balance<TOKEN>
110StLoc[7](loc1: Balance<TOKEN>)
111Branch(116)
B17:
112MoveLoc[0](Arg0: &mut TokenBank)
113Pop
114Call balance::zero<TOKEN>(): Balance<TOKEN>
115StLoc[7](loc1: Balance<TOKEN>)
B18:
116MoveLoc[7](loc1: Balance<TOKEN>)
117StLoc[12](loc6: Balance<TOKEN>)
118MoveLoc[11](loc5: &TokenFarmIndexValue)
119ImmBorrowField[19](TokenFarmIndexValue.boost_multiplier: u64)
120ReadRef
121StLoc[10](loc4: u64)
122MoveLoc[3](Arg3: u64)
123CopyLoc[1](Arg1: &mut TokenFarm)
124ImmBorrowField[22](TokenFarm.base_epochs: u64)
125ReadRef
126Mul
127StLoc[16](loc10: u64)
128MoveLoc[1](Arg1: &mut TokenFarm)
129MoveLoc[8](loc2: Balance<TOKEN>)
130MoveLoc[12](loc6: Balance<TOKEN>)
131LdU64(0)
132MoveLoc[16](loc10: u64)
133MoveLoc[10](loc4: u64)
134MoveLoc[4](Arg4: &Clock)
135MoveLoc[5](Arg5: &mut TxContext)
136Call create_stake_token(&mut TokenFarm, Balance<TOKEN>, Balance<TOKEN>, u64, u64, u64, &Clock, &mut TxContext): StakedToken
137StLoc[15](loc9: StakedToken)
138ImmBorrowLoc[15](loc9: StakedToken)
139ImmBorrowField[0](StakedToken.id: UID)
140Call object::uid_to_inner(&UID): ID
141Pack[23](StakeTokenEvent)
142Call event::emit<StakeTokenEvent>(StakeTokenEvent)
143MoveLoc[15](loc9: StakedToken)
144MoveLoc[14](loc8: address)
145Call transfer::transfer<StakedToken>(StakedToken, address)
146Ret
}
public do_unlock_staked_token(Arg0: &mut TokenFarm, Arg1: StakedToken, Arg2: &Clock, Arg3: &mut TxContext) {
L4: loc0: address
B0:
0CopyLoc[0](Arg0: &mut TokenFarm)
1ImmBorrowField[51](TokenFarm.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[0](Arg0: &mut TokenFarm)
8Pop
9MoveLoc[3](Arg3: &mut TxContext)
10Pop
11MoveLoc[2](Arg2: &Clock)
12Pop
13LdConst[20](u64: 200000)
14Abort
B3:
15CopyLoc[3](Arg3: &mut TxContext)
16FreezeRef
17Call tx_context::sender(&TxContext): address
18StLoc[4](loc0: address)
19ImmBorrowLoc[1](Arg1: StakedToken)
20ImmBorrowField[0](StakedToken.id: UID)
21Call object::uid_to_inner(&UID): ID
22Pack[24](UnlockStakeTokenEvent)
23Call event::emit<UnlockStakeTokenEvent>(UnlockStakeTokenEvent)
24MoveLoc[0](Arg0: &mut TokenFarm)
25MoveLoc[1](Arg1: StakedToken)
26MoveLoc[2](Arg2: &Clock)
27CopyLoc[3](Arg3: &mut TxContext)
28Call destroy_stake_token(&mut TokenFarm, StakedToken, &Clock, &mut TxContext): Balance<TOKEN>
29MoveLoc[3](Arg3: &mut TxContext)
30Call coin::from_balance<TOKEN>(Balance<TOKEN>, &mut TxContext): Coin<TOKEN>
31MoveLoc[4](loc0: address)
32Call utils::transfer_or_destroy_zero<TOKEN>(Coin<TOKEN>, address)
33Ret
}
public do_unlock_linear_unlock_staked_token(Arg0: LinearUnlockStakedToken, Arg1: &Clock, Arg2: &mut TxContext) {
L3: loc0: ID
L4: loc1: address
L5: loc2: StakedToken
B0:
0CopyLoc[2](Arg2: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[4](loc1: address)
4MutBorrowLoc[0](Arg0: LinearUnlockStakedToken)
5MoveLoc[1](Arg1: &Clock)
6CopyLoc[2](Arg2: &mut TxContext)
7Call decrease_linear_unlock_stake_token(&mut LinearUnlockStakedToken, &Clock, &mut TxContext): Balance<TOKEN>
8CopyLoc[2](Arg2: &mut TxContext)
9Call coin::from_balance<TOKEN>(Balance<TOKEN>, &mut TxContext): Coin<TOKEN>
10CopyLoc[4](loc1: address)
11Call utils::transfer_or_destroy_zero<TOKEN>(Coin<TOKEN>, address)
12MoveLoc[0](Arg0: LinearUnlockStakedToken)
13Unpack[2](LinearUnlockStakedToken)
14StLoc[5](loc2: StakedToken)
15StLoc[3](loc0: ID)
16Call object::delete(UID)
17ImmBorrowLoc[5](loc2: StakedToken)
18Call is_zero_stake_token(&StakedToken): bool
19BrFalse(25)
B1:
20MoveLoc[2](Arg2: &mut TxContext)
21Pop
22MoveLoc[5](loc2: StakedToken)
23Call destroy_zero_stake_token(StakedToken)
24Branch(32)
B2:
25MoveLoc[2](Arg2: &mut TxContext)
26Call object::new(&mut TxContext): UID
27MoveLoc[3](loc0: ID)
28MoveLoc[5](loc2: StakedToken)
29Pack[2](LinearUnlockStakedToken)
30MoveLoc[4](loc1: address)
31Call transfer::transfer<LinearUnlockStakedToken>(LinearUnlockStakedToken, address)
B3:
32Ret
}
public do_unwrap_linear_unlock_staked_token(Arg0: &mut TokenFarm, Arg1: LinearUnlockStakedToken, Arg2: &Clock, Arg3: &mut TxContext) {
L4: loc0: StakedToken
B0:
0CopyLoc[0](Arg0: &mut TokenFarm)
1ImmBorrowField[51](TokenFarm.version: u64)
2ReadRef
3LdConst[0](u64: 0)
4Eq
5BrFalse(7)
B1:
6Branch(15)
B2:
7MoveLoc[0](Arg0: &mut TokenFarm)
8Pop
9MoveLoc[3](Arg3: &mut TxContext)
10Pop
11MoveLoc[2](Arg2: &Clock)
12Pop
13LdConst[20](u64: 200000)
14Abort
B3:
15MoveLoc[0](Arg0: &mut TokenFarm)
16MoveLoc[1](Arg1: LinearUnlockStakedToken)
17MoveLoc[2](Arg2: &Clock)
18CopyLoc[3](Arg3: &mut TxContext)
19Call unwrap_linear_unlock_stake_token(&mut TokenFarm, LinearUnlockStakedToken, &Clock, &mut TxContext): StakedToken
20StLoc[4](loc0: StakedToken)
21ImmBorrowLoc[4](loc0: StakedToken)
22ImmBorrowField[0](StakedToken.id: UID)
23Call object::uid_to_inner(&UID): ID
24Pack[25](UnwrapLinearUnlockStakedTokenEvent)
25Call event::emit<UnwrapLinearUnlockStakedTokenEvent>(UnwrapLinearUnlockStakedTokenEvent)
26MoveLoc[4](loc0: StakedToken)
27MoveLoc[3](Arg3: &mut TxContext)
28FreezeRef
29Call tx_context::sender(&TxContext): address
30Call transfer_or_destroy_zero_stake_token(StakedToken, address)
31Ret
}
Constants [
0 => u64: 0
1 => u64: 1000
2 => u64: 10000
3 => u64: 14400
4 => u64: 144001
5 => u64: 144002
6 => u64: 144003
7 => u64: 144004
8 => u64: 144005
9 => u64: 144006
10 => u64: 144007
11 => u64: 144008
12 => u64: 144009
13 => u64: 144010
14 => u64: 144011
15 => u64: 144012
16 => u64: 144013
17 => u64: 144040
18 => u64: 144041
19 => u64: 144042
20 => u64: 200000
21 => u128: 1000000000
22 => u64: 1000000000
23 => u64: 10
24 => u8: 0
25 => u8: 1
26 => u8: 2
27 => u8: 200
28 => u8: 201
29 => u8: 202
30 => u8: 203
31 => u8: 204
32 => vector<u8>: "SSWP" // interpreted as UTF8 string
33 => vector<u8>: "Suiswap Token" // interpreted as UTF8 string
34 => vector<u8>: "Suiswap Platform Governance Token" // interpreted as UTF8 string
35 => vector<u8>: "https://suiswap.app/images/token/suiswap.svg" // interpreted as UTF8 string
]
}