TOKEN

Module0xd47b…3db2

Move path: 0x361d…7ffc::TOKEN
Functions: 134118 public, 41 entry
Structs: 26
Friend modules: pool

TOKEN

Declarations

Rebuilt from the module interface. No verified source is published, and function bodies are only available as bytecode.

module TOKEN;

struct AddTokenIdoWhitelistEvent has copy, drop {

ido_id: ID,

}

struct BuyTokenIdoTokenEvent has copy, drop {

ido_id: ID,

in_amount: u64,

out_amount: u64,

}

struct ClaimTokenAirdropEvent has copy, drop {

airdrop_id: ID,

amount: u64,

}

struct IncreaseTokenSupplyEvent has copy, drop {

bank_id: ID,

amount: u64,

}

struct LinearUnlockStakedToken has key {

id: UID,

origin_id: ID,

inner: StakedToken,

}

struct SendTokenEvent has copy, drop {

token_id: ID,

bank_id: ID,

amount: u64,

recipient: address,

token_type: u8,

}

struct StakeTokenEvent has copy, drop {

st_id: ID,

}

struct StakedToken has store, key {

id: UID,

balance: sbalance::SBalance<TOKEN>,

profit: sbalance::SBalance<TOKEN>,

start_epoch: u64,

end_epoch: u64,

boost: u128,

}

struct TOKEN 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 TestToken has drop {

dummy_field: bool,

}

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 TestUSDC has drop {

dummy_field: bool,

}

struct TestUSDT has drop {

dummy_field: bool,

}

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::SBalance<TOKEN>,

allow_duplicate: bool,

}

struct TokenBank has key {

id: UID,

version: u64,

owner: address,

balance: sbalance::SBalance<TOKEN>,

admin_balance: Balance<TOKEN>,

early_unlock_fee: ratio::Ratio,

stats_liquidity_mine_amount: u64,

token_farm_ids: vector<ID>,

token_ido_ids: vector<ID>,

token_airdrop_ids: vector<ID>,

}

struct TokenCap has key {

id: UID,

treasury_cap: TreasuryCap<TOKEN>,

token_bank_permission: permission::Permission<TokenBank>,

token_airdrop_permission: permission::Permission<TokenAirdrop>,

token_farm_permission: permission::Permission<TokenFarm>,

token_ido_permission: permission::Permission<TokenIdo>,

bank_id: ID,

coin_metadata_id: ID,

test_token_supply_id: ID,

}

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 TokenFarmIndexValue has copy, drop, store {

profit: u64,

boost_multiplier: u64,

}

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::SBalance<TOKEN>,

}

struct UnlockStakeTokenEvent has copy, drop {

st_id: ID,

}

struct UnwrapLinearUnlockStakedTokenEvent has copy, drop {

st_id: ID,

}

public entry fun add_token_ido_whitelist(&mut TokenIdo)

public entry fun admin_mint_test_token(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun admin_mint_test_token_bnb(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun admin_mint_test_token_btc(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun admin_mint_test_token_dai(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun admin_mint_test_token_eth(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun admin_mint_test_token_sol(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun admin_mint_test_token_usdc(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun admin_mint_test_token_usdt(&TokenCap,&mut TestTokenSupply,u64,address)

public entry fun buy_token_ido_token(&mut TokenIdo,vector<Coin<SUI>>,u64)

public entry fun change_token_ido_publicity(&TokenCap,&mut TokenIdo,bool)

public entry fun change_token_ido_whitelists_editable(&TokenCap,&mut TokenIdo,bool)

public entry fun claim_token_airdrop_token(&mut TokenAirdrop,u64,vector<u8>)

public entry fun close_token_ido(&TokenCap,&mut TokenBank,&mut TokenIdo)

fun create_linear_unlock_stake_token(Balance<TOKEN>,Balance<TOKEN>,u64,u64,u64,&Clock): LinearUnlockStakedToken

fun create_stake_token(&mut TokenFarm,Balance<TOKEN>,Balance<TOKEN>,u64,u64,u64,&Clock): StakedToken

public entry fun create_token_airdrop(&TokenCap,&mut TokenBank,vector<u8>,vector<u8>,u64,u64,bool)

public entry fun create_token_farm(&TokenCap,&mut TokenBank,u64,u64,vector<u64>)

public entry fun create_token_ido(&TokenCap,&mut TokenBank,vector<u8>,u64,bool,u64)

fun decrease_linear_unlock_stake_token(&mut LinearUnlockStakedToken,&Clock): Balance<TOKEN>

public fun deposit_token_supply(&mut TokenCap,&mut TokenBank,vector<Coin<TOKEN>>)

fun destroy_stake_token(&mut TokenFarm,StakedToken,&Clock): Balance<TOKEN>

fun destroy_stake_token_force(&mut TokenFarm,StakedToken): Balance<TOKEN>

fun destroy_zero_stake_token(StakedToken)

public fun do_add_token_ido_whitelist(&mut TokenIdo)

public fun do_buy_token_ido_token(&mut TokenIdo,vector<Coin<SUI>>,u64)

public fun do_change_token_ido_publicity(&permission::Permission<TokenIdo>,&mut TokenIdo,bool)

public fun do_change_token_ido_whitelists_editable(&permission::Permission<TokenIdo>,&mut TokenIdo,bool)

public fun do_claim_token_airdrop_token(&mut TokenAirdrop,u64,vector<u8>)

public fun do_claim_token_airdrop_token_legacy(&mut TokenAirdrop,u64,vector<u8>)

public fun do_close_token_ido(&permission::Permission<TokenBank>,&permission::Permission<TokenIdo>,&mut TokenBank,&mut TokenIdo)

public fun do_create_token_airdrop(&permission::Permission<TokenBank>,&mut TokenBank,vector<u8>,vector<u8>,u64,u64,bool)

public fun do_create_token_farm(&permission::Permission<TokenBank>,&mut TokenBank,u64,u64,vector<u64>)

public fun do_create_token_ido(&permission::Permission<TokenBank>,&mut TokenBank,vector<u8>,u64,bool,u64)

public fun do_deposit_token_supply(&mut TokenCap,&mut TokenBank,vector<Coin<TOKEN>>)

public fun do_increase_token_supply(&mut TokenCap,&mut TokenBank,u64)

public(package) fun do_send_liquidity_mine_token(&permission::Permission<TokenBank>,&mut TokenBank,u64,address)

public fun do_send_staked_token(&permission::Permission<TokenBank>,&mut TokenBank,&mut TokenFarm,u64,u64,u64,bool,address,&Clock)

public fun do_send_staked_token_batch(&permission::Permission<TokenBank>,&mut TokenBank,&mut TokenFarm,vector<u64>,vector<u64>,vector<u64>,vector<bool>,vector<address>,&Clock)

public fun do_send_staked_token_with_target_epoch(&permission::Permission<TokenBank>,&mut TokenBank,&mut TokenFarm,u64,u64,u64,bool,address,&Clock)

public fun do_send_staked_token_with_target_epoch_batch(&permission::Permission<TokenBank>,&mut TokenBank,&mut TokenFarm,vector<u64>,vector<u64>,vector<u64>,vector<bool>,vector<address>,&Clock)

public fun do_send_token(&permission::Permission<TokenBank>,&mut TokenBank,u64,address)

public fun do_send_token_batch(&permission::Permission<TokenBank>,&mut TokenBank,vector<u64>,vector<address>)

public fun do_stake_token(&mut TokenBank,&mut TokenFarm,Coin<TOKEN>,u64,&Clock)

public fun do_unlock_linear_unlock_staked_token(LinearUnlockStakedToken,&Clock)

public fun do_unlock_staked_token(&mut TokenFarm,StakedToken,&Clock)

public fun do_unwrap_linear_unlock_staked_token(&mut TokenFarm,LinearUnlockStakedToken,&Clock)

public fun do_withdraw_token_bank_admin_balance(&permission::Permission<TokenBank>,&mut TokenBank)

public fun do_withdraw_token_ido_collect(&permission::Permission<TokenIdo>,&mut TokenIdo)

public entry fun increase_token_supply(&mut TokenCap,&mut TokenBank,u64)

fun init(TOKEN)

fun init_impl(TOKEN)

fun is_zero_stake_token(&StakedToken): bool

public fun linear_staked_token_get_end_epoch(&LinearUnlockStakedToken): u64

public fun linear_staked_token_get_id(&LinearUnlockStakedToken): ID

public fun linear_staked_token_get_left_balance_value(&LinearUnlockStakedToken): u64

public fun linear_staked_token_get_left_profit_value(&LinearUnlockStakedToken): u64

public fun linear_staked_token_get_origin_balance_value(&LinearUnlockStakedToken): u64

public fun linear_staked_token_get_origin_profit_value(&LinearUnlockStakedToken): u64

public fun linear_staked_token_get_start_epoch(&LinearUnlockStakedToken): u64

public entry fun mint_test_token(&mut TestTokenSupply,address)

public entry fun mint_test_token_bnb(&mut TestTokenSupply,address)

public entry fun mint_test_token_btc(&mut TestTokenSupply,address)

public entry fun mint_test_token_dai(&mut TestTokenSupply,address)

public entry fun mint_test_token_eth(&mut TestTokenSupply,address)

public entry fun mint_test_token_sol(&mut TestTokenSupply,address)

public entry fun mint_test_token_usdc(&mut TestTokenSupply,address)

public entry fun mint_test_token_usdt(&mut TestTokenSupply,address)

public entry fun send_staked_token(&TokenCap,&mut TokenBank,&mut TokenFarm,u64,u64,u64,bool,address,&Clock)

public entry fun send_staked_token_batch(&TokenCap,&mut TokenBank,&mut TokenFarm,vector<u64>,vector<u64>,vector<u64>,vector<bool>,vector<address>,&Clock)

fun send_staked_token_impl(&mut TokenBank,&mut TokenFarm,u64,u64,u64,bool,address,&Clock)

public entry fun send_staked_token_with_target_epoch(&TokenCap,&mut TokenBank,&mut TokenFarm,u64,u64,u64,bool,address,&Clock)

public entry fun send_staked_token_with_target_epoch_batch(&TokenCap,&mut TokenBank,&mut TokenFarm,vector<u64>,vector<u64>,vector<u64>,vector<bool>,vector<address>,&Clock)

public entry fun send_token(&TokenCap,&mut TokenBank,u64,address)

public entry fun send_token_batch(&TokenCap,&mut TokenBank,vector<u64>,vector<address>)

fun send_token_impl(&mut TokenBank,u64,address)

public entry fun set_token_bank_public_key(&TokenCap,&mut TokenBank,vector<u8>)

public entry fun stake_token(&mut TokenBank,&mut TokenFarm,Coin<TOKEN>,u64,&Clock)

public(package) fun staked_token_add_data<T0: copy + drop + store, T1: store>(&mut StakedToken,T0,T1)

public fun staked_token_get_boost(&StakedToken): u128

public fun staked_token_get_end_epoch(&StakedToken): u64

public fun staked_token_get_id(&StakedToken): ID

public fun staked_token_get_left_balance_value(&StakedToken): u64

public fun staked_token_get_left_profit_value(&StakedToken): u64

public fun staked_token_get_origin_balance_value(&StakedToken): u64

public fun staked_token_get_origin_profit_value(&StakedToken): u64

public fun staked_token_get_start_epoch(&StakedToken): u64

public(package) fun staked_token_pop_data<T0: copy + drop + store, T1: store>(&mut StakedToken,T0): Option<T1>

public fun token_airdrop_get_balance_value(&TokenAirdrop): u64

public fun token_airdrop_get_bank_id(&TokenAirdrop): ID

public fun token_airdrop_get_free_amount(&TokenAirdrop): u64

public fun token_airdrop_get_id(&TokenAirdrop): ID

public fun token_airdrop_get_name(&TokenAirdrop): vector<u8>

public fun token_airdrop_get_owner(&TokenAirdrop): address

public fun token_airdrop_get_supply(&TokenAirdrop): u64

public fun token_airdrop_has_used_address(&TokenAirdrop,address): bool

public fun token_airdrop_is_free(&TokenAirdrop): bool

public fun token_bank_get_balance_value(&TokenBank): u64

public fun token_bank_get_id(&TokenBank): ID

public fun token_bank_get_owner(&TokenBank): address

public fun token_bank_get_public_key(&TokenBank): Option<vector<u8>>

public fun token_bank_get_supply(&TokenBank): u64

public fun token_cap_cp_token_airdrop_permission(&TokenCap): permission::Permission<TokenAirdrop>

public fun token_cap_cp_token_bank_permission(&TokenCap): permission::Permission<TokenBank>

public fun token_cap_cp_token_farm_permission(&TokenCap): permission::Permission<TokenFarm>

public fun token_cap_cp_token_ido_permission(&TokenCap): permission::Permission<TokenIdo>

public fun token_farm_get_bank_id(&TokenFarm): ID

public fun token_farm_get_base_epochs(&TokenFarm): u64

public fun token_farm_get_id(&TokenFarm): ID

public fun token_farm_get_total_stake_amount(&TokenFarm): u64

public fun token_farm_get_total_stake_boost(&TokenFarm): u128

public fun token_farm_get_value_for_index(&TokenFarm, u64): TokenFarmIndexValue

public fun token_farm_has_index_in_stake_index_table(&TokenFarm, u64): bool

public fun token_farm_index_value_get_boost(&TokenFarmIndexValue): u64

public fun token_farm_index_value_get_profit(&TokenFarmIndexValue): u64

public fun token_ido_get_balance_value(&TokenIdo): u64

public fun token_ido_get_bank_id(&TokenIdo): ID

public fun token_ido_get_collect_value(&TokenIdo): u64

public fun token_ido_get_id(&TokenIdo): ID

public fun token_ido_get_is_public(&TokenIdo): bool

public fun token_ido_get_is_whitelists_editable(&TokenIdo): bool

public fun token_ido_get_name(&TokenIdo): vector<u8>

public fun token_ido_get_price_e9(&TokenIdo): u64

public fun token_ido_get_supply(&TokenIdo): u64

public fun token_ido_is_public_or_has_whitelist_address(&TokenIdo,address): bool

fun transfer_or_destroy_zero_stake_token(StakedToken,address)

public entry fun ttcp(TokenCap,TokenBank,address)

public entry fun ttcp2(TokenCap, address)

public entry fun unlock_linear_unlock_staked_token(LinearUnlockStakedToken,&Clock)

public entry fun unlock_staked_token(&mut TokenFarm,StakedToken,&Clock)

fun unwrap_linear_unlock_stake_token(&mut TokenFarm,LinearUnlockStakedToken,&Clock): StakedToken

public entry fun unwrap_linear_unlock_staked_token(&mut TokenFarm,LinearUnlockStakedToken,&Clock)

public entry fun withdraw_token_bank_admin_balance(&TokenCap,&mut TokenBank)

public entry fun withdraw_token_ido_collect(&TokenCap,&mut TokenIdo)