tide
SUI$0.86892.17%USDC$1.000.02%DEEP$0.01481.52%WAL$0.02904.73%CETUS$0.02002.52%NAVX$0.009522.83%IKA$0.001458.59%HAEDAL$0.02661.03%MMT$0.12445.95%BLUE$0.007691.41%NS$0.009991.32%USDT$0.99890.01%haSUI$0.94021.50%

Search by name, SuiNS, address, digest, object ID, coin type or checkpoint.

API

guild

Module0x351d…0dc6
Move path
0xe19a…dfe6::guild
Functions
5233 public, 0 entry
Structs
29
Friend modules
boosting_v2guild_v2quest_v2
guild

Bytecode1457 lines

The on-chain disassembly. Offsets are bytecode positions within each function.

// Move bytecode v6
module e19a74728854cd996c7d26b8ced51ecbc2bb655ce33bb3976992b638fcb9dfe6.guild {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::ed25519;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
 
struct GUILD has drop {
dummy_field: bool
}
 
struct Config has store, key {
id: UID,
version: u64,
paused: bool,
validator: Option<vector<u8>>,
change_name_gap: u64,
fund_receiver: address
}
 
struct GlobalVault has key {
id: UID,
balances: Bag,
vault_manager: VaultManager
}
 
struct VaultCreatedEvent has copy, drop {
vault_id: ID
}
 
struct VaultDepositEvent has copy, drop {
vault_id: ID,
token_type: TypeName,
amount: u64,
total_balance: u64
}
 
struct VaultWithdrawEvent has copy, drop {
vault_id: ID,
token_type: TypeName,
amount: u64,
total_balance: u64
}
 
struct VaultManager has store {
tokens: vector<TokenInfo>,
last_update_time: u64
}
 
struct TokenInfo has copy, drop, store {
token_type: TypeName,
amount_in: u64,
amount_out: u64
}
 
struct Paused has copy, drop, store {
module_name: String,
paused: bool
}
 
struct AdminCap has store, key {
id: UID
}
 
struct TreasureCap has store, key {
id: UID
}
 
struct Logs has store, key {
id: UID,
users: Table<address, bool>
}
 
struct NewUserEvent has copy, drop {
archive_id: ID,
owner: address
}
 
struct UserArchive has store, key {
id: UID,
owner: address,
nonce_type: Table<u8, u128>,
total_mission_reward: Table<TypeName, u64>,
last_updated_name: u64
}
 
struct RewardClaimedEventV2 has copy, drop {
token_type: TypeName,
owner: address,
guild_id: u128,
rw_id: u128,
amount: u64,
nonce: u128
}
 
struct CreateGuildEvent has copy, drop {
guild_id: u128,
creator: address,
nonce: u128
}
 
struct RenameGuildEvent has copy, drop {
guild_id: u128,
guild_name: String,
changer: address,
nonce: u128
}
 
struct UpdateGuildEvent has copy, drop {
guild_id: u128,
updater: address,
guild_level: u64,
nonce: u128
}
 
struct CommissionTimeRange has copy, drop, store {
min_time: u64,
max_time: u64
}
 
struct SubscriptionEvent has copy, drop {
subscriber: address,
duration: u16,
fee: u64,
class: u8,
nonce: u128
}
 
struct Checkin has copy, drop, store {
checkin_days: u64,
last_checkin_time: u64
}
 
struct FeePool<phantom Ty0> has store, key {
id: UID,
balance: Balance<Ty0>
}
 
struct CreateFeePoolEvent has copy, drop {
pool_id: ID,
token_type: TypeName
}
 
struct FeePoolWithdrawEvent has copy, drop {
owner: address,
pool_id: ID,
amount: u64
}
 
struct RewardPool<phantom Ty0> has store, key {
id: UID,
balance: Balance<Ty0>
}
 
struct CreateRewardPoolEvent has copy, drop {
pool_id: ID,
token_type: TypeName
}
 
struct RewardPoolDepositEvent has copy, drop {
owner: address,
pool_id: ID,
amount: u64,
token_type: TypeName
}
 
struct RewardPoolWithdrawEvent has copy, drop {
owner: address,
pool_id: ID,
amount: u64
}
 
struct RewardClaimedEvent has copy, drop {
type: u8,
token_type: TypeName,
owner: address,
guild_id: u128,
rw_id: u128,
pool_id: address,
amount: u64,
nonce: u128
}
 
init(Arg0: GUILD, Arg1: &mut TxContext) {
L2: loc0: address
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[2](loc0: address)
4CopyLoc[1](Arg1: &mut TxContext)
5Call object::new(&mut TxContext): UID
6Pack[9](AdminCap)
7CopyLoc[2](loc0: address)
8Call transfer::public_transfer<AdminCap>(AdminCap, address)
9CopyLoc[1](Arg1: &mut TxContext)
10Call object::new(&mut TxContext): UID
11Pack[10](TreasureCap)
12MoveLoc[2](loc0: address)
13Call transfer::public_transfer<TreasureCap>(TreasureCap, address)
14CopyLoc[1](Arg1: &mut TxContext)
15Call object::new(&mut TxContext): UID
16LdConst[35](u64: 6)
17LdFalse
18Call option::none<vector<u8>>(): Option<vector<u8>>
19LdConst[36](u64: 6048..)
20LdConst[37](address: 0x08..)
21Pack[1](Config)
22Call transfer::share_object<Config>(Config)
23CopyLoc[1](Arg1: &mut TxContext)
24Call object::new(&mut TxContext): UID
25MoveLoc[1](Arg1: &mut TxContext)
26Call table::new<address, bool>(&mut TxContext): Table<address, bool>
27Pack[11](Logs)
28Call transfer::share_object<Logs>(Logs)
29Ret
}
 
public init_vault(Arg0: &AdminCap, Arg1: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public(friend) deposit_to_vault<Ty0>(Arg0: &mut GlobalVault, Arg1: Balance<Ty0>, Arg2: &Clock) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public(friend) withdraw_from_vault<Ty0>(Arg0: &mut GlobalVault, Arg1: u64, Arg2: &Clock, Arg3: &mut TxContext): Coin<Ty0> {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
update_vault_manager(Arg0: &mut GlobalVault, Arg1: TypeName, Arg2: u64, Arg3: u64, Arg4: &Clock) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public get_vault_balance<Ty0>(Arg0: &GlobalVault): u64 {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public new_user(Arg0: &mut Logs, Arg1: &mut Config, Arg2: &mut TxContext) {
L3: loc0: String
L4: loc1: address
L5: loc2: UserArchive
B0:
0MoveLoc[1](Arg1: &mut Config)
1LdConst[0](vector<u8>: "GUI..)
2Call string::utf8(vector<u8>): String
3StLoc[3](loc0: String)
4FreezeRef
5MoveLoc[3](loc0: String)
6Call verify_config(&Config, String)
7CopyLoc[2](Arg2: &mut TxContext)
8FreezeRef
9Call tx_context::sender(&TxContext): address
10StLoc[4](loc1: address)
11CopyLoc[0](Arg0: &mut Logs)
12ImmBorrowField[0](Logs.users: Table<address, bool>)
13CopyLoc[4](loc1: address)
14Call table::contains<address, bool>(&Table<address, bool>, address): bool
15Not
16BrFalse(18)
B1:
17Branch(24)
B2:
18MoveLoc[0](Arg0: &mut Logs)
19Pop
20MoveLoc[2](Arg2: &mut TxContext)
21Pop
22LdConst[14](u64: 6006)
23Abort
B3:
24CopyLoc[2](Arg2: &mut TxContext)
25Call object::new(&mut TxContext): UID
26CopyLoc[2](Arg2: &mut TxContext)
27FreezeRef
28Call tx_context::sender(&TxContext): address
29CopyLoc[2](Arg2: &mut TxContext)
30Call table::new<u8, u128>(&mut TxContext): Table<u8, u128>
31MoveLoc[2](Arg2: &mut TxContext)
32Call table::new<TypeName, u64>(&mut TxContext): Table<TypeName, u64>
33LdU64(0)
34Pack[13](UserArchive)
35StLoc[5](loc2: UserArchive)
36MoveLoc[0](Arg0: &mut Logs)
37MutBorrowField[0](Logs.users: Table<address, bool>)
38CopyLoc[4](loc1: address)
39LdTrue
40Call table::add<address, bool>(&mut Table<address, bool>, address, bool)
41ImmBorrowLoc[5](loc2: UserArchive)
42Call object::id<UserArchive>(&UserArchive): ID
43CopyLoc[4](loc1: address)
44Pack[12](NewUserEvent)
45Call event::emit<NewUserEvent>(NewUserEvent)
46MoveLoc[5](loc2: UserArchive)
47MoveLoc[4](loc1: address)
48Call transfer::public_transfer<UserArchive>(UserArchive, address)
49Ret
}
 
public register(Arg0: &mut Logs, Arg1: &mut Config, Arg2: &mut TxContext): UserArchive {
L3: loc0: String
L4: loc1: address
L5: loc2: UserArchive
B0:
0MoveLoc[1](Arg1: &mut Config)
1LdConst[0](vector<u8>: "GUI..)
2Call string::utf8(vector<u8>): String
3StLoc[3](loc0: String)
4FreezeRef
5MoveLoc[3](loc0: String)
6Call verify_config(&Config, String)
7CopyLoc[2](Arg2: &mut TxContext)
8FreezeRef
9Call tx_context::sender(&TxContext): address
10StLoc[4](loc1: address)
11CopyLoc[0](Arg0: &mut Logs)
12ImmBorrowField[0](Logs.users: Table<address, bool>)
13CopyLoc[4](loc1: address)
14Call table::contains<address, bool>(&Table<address, bool>, address): bool
15Not
16BrFalse(18)
B1:
17Branch(24)
B2:
18MoveLoc[0](Arg0: &mut Logs)
19Pop
20MoveLoc[2](Arg2: &mut TxContext)
21Pop
22LdConst[14](u64: 6006)
23Abort
B3:
24CopyLoc[2](Arg2: &mut TxContext)
25Call object::new(&mut TxContext): UID
26CopyLoc[2](Arg2: &mut TxContext)
27FreezeRef
28Call tx_context::sender(&TxContext): address
29CopyLoc[2](Arg2: &mut TxContext)
30Call table::new<u8, u128>(&mut TxContext): Table<u8, u128>
31MoveLoc[2](Arg2: &mut TxContext)
32Call table::new<TypeName, u64>(&mut TxContext): Table<TypeName, u64>
33LdU64(0)
34Pack[13](UserArchive)
35StLoc[5](loc2: UserArchive)
36MoveLoc[0](Arg0: &mut Logs)
37MutBorrowField[0](Logs.users: Table<address, bool>)
38CopyLoc[4](loc1: address)
39LdTrue
40Call table::add<address, bool>(&mut Table<address, bool>, address, bool)
41ImmBorrowLoc[5](loc2: UserArchive)
42Call object::id<UserArchive>(&UserArchive): ID
43MoveLoc[4](loc1: address)
44Pack[12](NewUserEvent)
45Call event::emit<NewUserEvent>(NewUserEvent)
46MoveLoc[5](loc2: UserArchive)
47Ret
}
 
public validate_archive_owner(Arg0: &UserArchive, Arg1: &mut TxContext) {
L2: loc0: address
B0:
0MoveLoc[1](Arg1: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[2](loc0: address)
4MoveLoc[0](Arg0: &UserArchive)
5ImmBorrowField[1](UserArchive.owner: address)
6ReadRef
7MoveLoc[2](loc0: address)
8Eq
9BrFalse(11)
B1:
10Branch(13)
B2:
11LdConst[25](u64: 6017)
12Abort
B3:
13Ret
}
 
public create_guild<Ty0>(Arg0: &Config, Arg1: &mut FeePool<Ty0>, Arg2: &mut UserArchive, Arg3: u128, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: Coin<Ty0>, Arg7: &Clock, Arg8: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public create_guild_v2<Ty0>(Arg0: &Config, Arg1: &mut GlobalVault, Arg2: &mut UserArchive, Arg3: u128, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: Coin<Ty0>, Arg7: &Clock, Arg8: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public rename_guild<Ty0>(Arg0: &Config, Arg1: &mut FeePool<Ty0>, Arg2: &mut UserArchive, Arg3: u128, Arg4: String, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: Coin<Ty0>, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public rename_guild_v2<Ty0>(Arg0: &Config, Arg1: &mut GlobalVault, Arg2: &mut UserArchive, Arg3: u128, Arg4: String, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: Coin<Ty0>, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public update_guild<Ty0>(Arg0: &Config, Arg1: &mut FeePool<Ty0>, Arg2: &mut UserArchive, Arg3: u128, Arg4: u64, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: Coin<Ty0>, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public update_guild_v2<Ty0>(Arg0: &Config, Arg1: &mut GlobalVault, Arg2: &mut UserArchive, Arg3: u128, Arg4: u64, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: Coin<Ty0>, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public claim_reward<Ty0>(Arg0: &Config, Arg1: &mut UserArchive, Arg2: &mut RewardPool<Ty0>, Arg3: u128, Arg4: u128, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: &Clock, Arg8: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public claim_reward_v2<Ty0>(Arg0: &Config, Arg1: &mut UserArchive, Arg2: &mut GlobalVault, Arg3: u128, Arg4: u128, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: &Clock, Arg8: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public(friend) set_checkin_fee(Arg0: &AdminCap, Arg1: &mut Config, Arg2: u64) {
L3: loc0: &mut u64
B0:
0CopyLoc[1](Arg1: &mut Config)
1ImmBorrowField[2](Config.id: UID)
2LdConst[6](vector<u8>: "CHE..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(12)
B1:
6MoveLoc[1](Arg1: &mut Config)
7MutBorrowField[2](Config.id: UID)
8LdConst[6](vector<u8>: "CHE..)
9MoveLoc[2](Arg2: u64)
10Call dynamic_field::add<vector<u8>, u64>(&mut UID, vector<u8>, u64)
11Branch(20)
B2:
12MoveLoc[1](Arg1: &mut Config)
13MutBorrowField[2](Config.id: UID)
14LdConst[6](vector<u8>: "CHE..)
15Call dynamic_field::borrow_mut<vector<u8>, u64>(&mut UID, vector<u8>): &mut u64
16StLoc[3](loc0: &mut u64)
17MoveLoc[2](Arg2: u64)
18MoveLoc[3](loc0: &mut u64)
19WriteRef
B3:
20Ret
}
 
public(friend) init_checkin(Arg0: &mut UserArchive) {
B0:
0CopyLoc[0](Arg0: &mut UserArchive)
1ImmBorrowField[3](UserArchive.id: UID)
2LdConst[4](vector<u8>: "CHE..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(14)
B1:
6MoveLoc[0](Arg0: &mut UserArchive)
7MutBorrowField[3](UserArchive.id: UID)
8LdConst[4](vector<u8>: "CHE..)
9LdU64(0)
10LdU64(0)
11Pack[20](Checkin)
12Call dynamic_field::add<vector<u8>, Checkin>(&mut UID, vector<u8>, Checkin)
13Branch(16)
B2:
14MoveLoc[0](Arg0: &mut UserArchive)
15Pop
B3:
16Ret
}
 
public(friend) set_checkin(Arg0: &Config, Arg1: &mut UserArchive, Arg2: &Clock): u64 * u64 {
L3: loc0: bool
L4: loc1: u64
L5: loc2: &mut Checkin
L6: loc3: u64
L7: loc4: u64
L8: loc5: u64
B0:
0MoveLoc[2](Arg2: &Clock)
1Call clock::timestamp_ms(&Clock): u64
2StLoc[8](loc5: u64)
3CopyLoc[8](loc5: u64)
4Call start_of_day(u64): u64
5StLoc[7](loc4: u64)
6MoveLoc[0](Arg0: &Config)
7Call get_max_check_in_days(&Config): u64
8StLoc[6](loc3: u64)
9MoveLoc[1](Arg1: &mut UserArchive)
10MutBorrowField[3](UserArchive.id: UID)
11LdConst[4](vector<u8>: "CHE..)
12Call dynamic_field::borrow_mut<vector<u8>, Checkin>(&mut UID, vector<u8>): &mut Checkin
13StLoc[5](loc2: &mut Checkin)
14CopyLoc[6](loc3: u64)
15LdU64(0)
16Gt
17BrFalse(19)
B1:
18Branch(23)
B2:
19MoveLoc[5](loc2: &mut Checkin)
20Pop
21LdConst[33](u64: 6025)
22Abort
B3:
23CopyLoc[5](loc2: &mut Checkin)
24ImmBorrowField[4](Checkin.last_checkin_time: u64)
25ReadRef
26CopyLoc[7](loc4: u64)
27Lt
28BrFalse(30)
B4:
29Branch(34)
B5:
30MoveLoc[5](loc2: &mut Checkin)
31Pop
32LdConst[32](u64: 6024)
33Abort
B6:
34MoveLoc[7](loc4: u64)
35CopyLoc[5](loc2: &mut Checkin)
36ImmBorrowField[4](Checkin.last_checkin_time: u64)
37ReadRef
38Sub
39LdConst[7](u64: 8640..)
40Gt
41BrFalse(45)
B7:
42LdTrue
43StLoc[3](loc0: bool)
44Branch(53)
B8:
45CopyLoc[5](loc2: &mut Checkin)
46ImmBorrowField[5](Checkin.checkin_days: u64)
47ReadRef
48LdU64(1)
49Add
50MoveLoc[6](loc3: u64)
51Gt
52StLoc[3](loc0: bool)
B9:
53MoveLoc[3](loc0: bool)
54BrFalse(58)
B10:
55LdU64(1)
56StLoc[4](loc1: u64)
57Branch(64)
B11:
58CopyLoc[5](loc2: &mut Checkin)
59ImmBorrowField[5](Checkin.checkin_days: u64)
60ReadRef
61LdU64(1)
62Add
63StLoc[4](loc1: u64)
B12:
64MoveLoc[4](loc1: u64)
65CopyLoc[5](loc2: &mut Checkin)
66MutBorrowField[5](Checkin.checkin_days: u64)
67WriteRef
68MoveLoc[8](loc5: u64)
69CopyLoc[5](loc2: &mut Checkin)
70MutBorrowField[4](Checkin.last_checkin_time: u64)
71WriteRef
72CopyLoc[5](loc2: &mut Checkin)
73ImmBorrowField[5](Checkin.checkin_days: u64)
74ReadRef
75MoveLoc[5](loc2: &mut Checkin)
76ImmBorrowField[4](Checkin.last_checkin_time: u64)
77ReadRef
78Ret
}
 
start_of_day(Arg0: u64): u64 {
B0:
0MoveLoc[0](Arg0: u64)
1LdConst[7](u64: 8640..)
2Div
3LdConst[7](u64: 8640..)
4Mul
5Ret
}
 
public(friend) set_max_check_in_days(Arg0: &AdminCap, Arg1: &mut Config, Arg2: u64) {
L3: loc0: &mut u64
B0:
0CopyLoc[1](Arg1: &mut Config)
1ImmBorrowField[2](Config.id: UID)
2LdConst[5](vector<u8>: "MAX..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(12)
B1:
6MoveLoc[1](Arg1: &mut Config)
7MutBorrowField[2](Config.id: UID)
8LdConst[5](vector<u8>: "MAX..)
9MoveLoc[2](Arg2: u64)
10Call dynamic_field::add<vector<u8>, u64>(&mut UID, vector<u8>, u64)
11Branch(20)
B2:
12MoveLoc[1](Arg1: &mut Config)
13MutBorrowField[2](Config.id: UID)
14LdConst[5](vector<u8>: "MAX..)
15Call dynamic_field::borrow_mut<vector<u8>, u64>(&mut UID, vector<u8>): &mut u64
16StLoc[3](loc0: &mut u64)
17MoveLoc[2](Arg2: u64)
18MoveLoc[3](loc0: &mut u64)
19WriteRef
B3:
20Ret
}
 
public get_max_check_in_days(Arg0: &Config): u64 {
B0:
0CopyLoc[0](Arg0: &Config)
1ImmBorrowField[2](Config.id: UID)
2LdConst[5](vector<u8>: "MAX..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(10)
B1:
6MoveLoc[0](Arg0: &Config)
7Pop
8LdU64(0)
9Ret
B2:
10MoveLoc[0](Arg0: &Config)
11ImmBorrowField[2](Config.id: UID)
12LdConst[5](vector<u8>: "MAX..)
13Call dynamic_field::borrow<vector<u8>, u64>(&UID, vector<u8>): &u64
14ReadRef
15Ret
}
 
public get_checkin_fee(Arg0: &Config): u64 {
B0:
0CopyLoc[0](Arg0: &Config)
1ImmBorrowField[2](Config.id: UID)
2LdConst[6](vector<u8>: "CHE..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(10)
B1:
6MoveLoc[0](Arg0: &Config)
7Pop
8LdU64(0)
9Ret
B2:
10MoveLoc[0](Arg0: &Config)
11ImmBorrowField[2](Config.id: UID)
12LdConst[6](vector<u8>: "CHE..)
13Call dynamic_field::borrow<vector<u8>, u64>(&UID, vector<u8>): &u64
14ReadRef
15Ret
}
 
public create_reward_pool<Ty0>(Arg0: &AdminCap, Arg1: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public deposit_reward<Ty0>(Arg0: &TreasureCap, Arg1: Coin<Ty0>, Arg2: &mut RewardPool<Ty0>, Arg3: &TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public create_fee_pool<Ty0>(Arg0: &AdminCap, Arg1: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public set_fund_receiver(Arg0: &TreasureCap, Arg1: address, Arg2: &mut Config) {
B0:
0MoveLoc[1](Arg1: address)
1MoveLoc[2](Arg2: &mut Config)
2MutBorrowField[6](Config.fund_receiver: address)
3WriteRef
4Ret
}
 
public withdraw_fee<Ty0>(Arg0: &TreasureCap, Arg1: &Config, Arg2: &mut FeePool<Ty0>, Arg3: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public withdraw_reward<Ty0>(Arg0: &TreasureCap, Arg1: &Config, Arg2: &mut RewardPool<Ty0>, Arg3: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public(friend) update_time_range(Arg0: &mut UserArchive, Arg1: u64, Arg2: u64) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public(friend) update_time_range_with_key(Arg0: &mut UserArchive, Arg1: vector<u8>, Arg2: u64, Arg3: u64) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public(friend) update_claim_commission_time_range(Arg0: &mut UserArchive, Arg1: vector<u8>, Arg2: u8, Arg3: u64, Arg4: u64) {
L5: loc0: &u8
L6: loc1: VecMap<u8, CommissionTimeRange>
L7: loc2: &mut VecMap<u8, CommissionTimeRange>
L8: loc3: &mut CommissionTimeRange
B0:
0CopyLoc[4](Arg4: u64)
1CopyLoc[3](Arg3: u64)
2Ge
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut UserArchive)
6Pop
7LdConst[28](u64: 6020)
8Abort
B3:
9CopyLoc[0](Arg0: &mut UserArchive)
10ImmBorrowField[3](UserArchive.id: UID)
11CopyLoc[1](Arg1: vector<u8>)
12Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
13Not
14BrFalse(29)
B4:
15Call vec_map::empty<u8, CommissionTimeRange>(): VecMap<u8, CommissionTimeRange>
16StLoc[6](loc1: VecMap<u8, CommissionTimeRange>)
17MutBorrowLoc[6](loc1: VecMap<u8, CommissionTimeRange>)
18MoveLoc[2](Arg2: u8)
19MoveLoc[3](Arg3: u64)
20MoveLoc[4](Arg4: u64)
21Pack[18](CommissionTimeRange)
22Call vec_map::insert<u8, CommissionTimeRange>(&mut VecMap<u8, CommissionTimeRange>, u8, CommissionTimeRange)
23MoveLoc[0](Arg0: &mut UserArchive)
24MutBorrowField[3](UserArchive.id: UID)
25MoveLoc[1](Arg1: vector<u8>)
26MoveLoc[6](loc1: VecMap<u8, CommissionTimeRange>)
27Call dynamic_field::add<vector<u8>, VecMap<u8, CommissionTimeRange>>(&mut UID, vector<u8>, VecMap<u8, CommissionTimeRange>)
28Branch(71)
B5:
29MoveLoc[0](Arg0: &mut UserArchive)
30MutBorrowField[3](UserArchive.id: UID)
31MoveLoc[1](Arg1: vector<u8>)
32Call dynamic_field::borrow_mut<vector<u8>, VecMap<u8, CommissionTimeRange>>(&mut UID, vector<u8>): &mut VecMap<u8, CommissionTimeRange>
33StLoc[7](loc2: &mut VecMap<u8, CommissionTimeRange>)
34CopyLoc[7](loc2: &mut VecMap<u8, CommissionTimeRange>)
35ImmBorrowLoc[2](Arg2: u8)
36StLoc[5](loc0: &u8)
37FreezeRef
38MoveLoc[5](loc0: &u8)
39Call vec_map::contains<u8, CommissionTimeRange>(&VecMap<u8, CommissionTimeRange>, &u8): bool
40BrFalse(65)
B6:
41MoveLoc[7](loc2: &mut VecMap<u8, CommissionTimeRange>)
42ImmBorrowLoc[2](Arg2: u8)
43Call vec_map::get_mut<u8, CommissionTimeRange>(&mut VecMap<u8, CommissionTimeRange>, &u8): &mut CommissionTimeRange
44StLoc[8](loc3: &mut CommissionTimeRange)
45CopyLoc[3](Arg3: u64)
46CopyLoc[8](loc3: &mut CommissionTimeRange)
47ImmBorrowField[7](CommissionTimeRange.max_time: u64)
48ReadRef
49Gt
50BrFalse(52)
B7:
51Branch(56)
B8:
52MoveLoc[8](loc3: &mut CommissionTimeRange)
53Pop
54LdConst[29](u64: 6021)
55Abort
B9:
56MoveLoc[3](Arg3: u64)
57CopyLoc[8](loc3: &mut CommissionTimeRange)
58MutBorrowField[8](CommissionTimeRange.min_time: u64)
59WriteRef
60MoveLoc[4](Arg4: u64)
61MoveLoc[8](loc3: &mut CommissionTimeRange)
62MutBorrowField[7](CommissionTimeRange.max_time: u64)
63WriteRef
64Branch(71)
B10:
65MoveLoc[7](loc2: &mut VecMap<u8, CommissionTimeRange>)
66MoveLoc[2](Arg2: u8)
67MoveLoc[3](Arg3: u64)
68MoveLoc[4](Arg4: u64)
69Pack[18](CommissionTimeRange)
70Call vec_map::insert<u8, CommissionTimeRange>(&mut VecMap<u8, CommissionTimeRange>, u8, CommissionTimeRange)
B11:
71Ret
}
 
public(friend) update_task_time_range(Arg0: &mut UserArchive, Arg1: vector<u8>, Arg2: vector<u8>, Arg3: u64, Arg4: u64) {
L5: loc0: &vector<u8>
L6: loc1: VecMap<vector<u8>, CommissionTimeRange>
L7: loc2: &mut VecMap<vector<u8>, CommissionTimeRange>
L8: loc3: &mut CommissionTimeRange
B0:
0CopyLoc[4](Arg4: u64)
1CopyLoc[3](Arg3: u64)
2Ge
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut UserArchive)
6Pop
7LdConst[28](u64: 6020)
8Abort
B3:
9CopyLoc[0](Arg0: &mut UserArchive)
10ImmBorrowField[3](UserArchive.id: UID)
11CopyLoc[1](Arg1: vector<u8>)
12Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
13Not
14BrFalse(29)
B4:
15Call vec_map::empty<vector<u8>, CommissionTimeRange>(): VecMap<vector<u8>, CommissionTimeRange>
16StLoc[6](loc1: VecMap<vector<u8>, CommissionTimeRange>)
17MutBorrowLoc[6](loc1: VecMap<vector<u8>, CommissionTimeRange>)
18MoveLoc[2](Arg2: vector<u8>)
19MoveLoc[3](Arg3: u64)
20MoveLoc[4](Arg4: u64)
21Pack[18](CommissionTimeRange)
22Call vec_map::insert<vector<u8>, CommissionTimeRange>(&mut VecMap<vector<u8>, CommissionTimeRange>, vector<u8>, CommissionTimeRange)
23MoveLoc[0](Arg0: &mut UserArchive)
24MutBorrowField[3](UserArchive.id: UID)
25MoveLoc[1](Arg1: vector<u8>)
26MoveLoc[6](loc1: VecMap<vector<u8>, CommissionTimeRange>)
27Call dynamic_field::add<vector<u8>, VecMap<vector<u8>, CommissionTimeRange>>(&mut UID, vector<u8>, VecMap<vector<u8>, CommissionTimeRange>)
28Branch(71)
B5:
29MoveLoc[0](Arg0: &mut UserArchive)
30MutBorrowField[3](UserArchive.id: UID)
31MoveLoc[1](Arg1: vector<u8>)
32Call dynamic_field::borrow_mut<vector<u8>, VecMap<vector<u8>, CommissionTimeRange>>(&mut UID, vector<u8>): &mut VecMap<vector<u8>, CommissionTimeRange>
33StLoc[7](loc2: &mut VecMap<vector<u8>, CommissionTimeRange>)
34CopyLoc[7](loc2: &mut VecMap<vector<u8>, CommissionTimeRange>)
35ImmBorrowLoc[2](Arg2: vector<u8>)
36StLoc[5](loc0: &vector<u8>)
37FreezeRef
38MoveLoc[5](loc0: &vector<u8>)
39Call vec_map::contains<vector<u8>, CommissionTimeRange>(&VecMap<vector<u8>, CommissionTimeRange>, &vector<u8>): bool
40BrFalse(65)
B6:
41MoveLoc[7](loc2: &mut VecMap<vector<u8>, CommissionTimeRange>)
42ImmBorrowLoc[2](Arg2: vector<u8>)
43Call vec_map::get_mut<vector<u8>, CommissionTimeRange>(&mut VecMap<vector<u8>, CommissionTimeRange>, &vector<u8>): &mut CommissionTimeRange
44StLoc[8](loc3: &mut CommissionTimeRange)
45CopyLoc[3](Arg3: u64)
46CopyLoc[8](loc3: &mut CommissionTimeRange)
47ImmBorrowField[7](CommissionTimeRange.max_time: u64)
48ReadRef
49Gt
50BrFalse(52)
B7:
51Branch(56)
B8:
52MoveLoc[8](loc3: &mut CommissionTimeRange)
53Pop
54LdConst[29](u64: 6021)
55Abort
B9:
56MoveLoc[3](Arg3: u64)
57CopyLoc[8](loc3: &mut CommissionTimeRange)
58MutBorrowField[8](CommissionTimeRange.min_time: u64)
59WriteRef
60MoveLoc[4](Arg4: u64)
61MoveLoc[8](loc3: &mut CommissionTimeRange)
62MutBorrowField[7](CommissionTimeRange.max_time: u64)
63WriteRef
64Branch(71)
B10:
65MoveLoc[7](loc2: &mut VecMap<vector<u8>, CommissionTimeRange>)
66MoveLoc[2](Arg2: vector<u8>)
67MoveLoc[3](Arg3: u64)
68MoveLoc[4](Arg4: u64)
69Pack[18](CommissionTimeRange)
70Call vec_map::insert<vector<u8>, CommissionTimeRange>(&mut VecMap<vector<u8>, CommissionTimeRange>, vector<u8>, CommissionTimeRange)
B11:
71Ret
}
 
public(friend) update_user_reward<Ty0>(Arg0: &mut UserArchive, Arg1: u64) {
L2: loc0: u64
L3: loc1: u64
L4: loc2: TypeName
B0:
0Call type_name::get<Ty0>(): TypeName
1StLoc[4](loc2: TypeName)
2CopyLoc[0](Arg0: &mut UserArchive)
3ImmBorrowField[9](UserArchive.total_mission_reward: Table<TypeName, u64>)
4CopyLoc[4](loc2: TypeName)
5Call table::contains<TypeName, u64>(&Table<TypeName, u64>, TypeName): bool
6Not
7BrFalse(11)
B1:
8LdU64(0)
9StLoc[2](loc0: u64)
10Branch(16)
B2:
11CopyLoc[0](Arg0: &mut UserArchive)
12MutBorrowField[9](UserArchive.total_mission_reward: Table<TypeName, u64>)
13CopyLoc[4](loc2: TypeName)
14Call table::remove<TypeName, u64>(&mut Table<TypeName, u64>, TypeName): u64
15StLoc[2](loc0: u64)
B3:
16MoveLoc[2](loc0: u64)
17StLoc[3](loc1: u64)
18MoveLoc[0](Arg0: &mut UserArchive)
19MutBorrowField[9](UserArchive.total_mission_reward: Table<TypeName, u64>)
20MoveLoc[4](loc2: TypeName)
21MoveLoc[3](loc1: u64)
22MoveLoc[1](Arg1: u64)
23Add
24Call table::add<TypeName, u64>(&mut Table<TypeName, u64>, TypeName, u64)
25Ret
}
 
public(friend) set_archive_last_name_time(Arg0: &mut UserArchive, Arg1: u64) {
B0:
0MoveLoc[1](Arg1: u64)
1MoveLoc[0](Arg0: &mut UserArchive)
2MutBorrowField[10](UserArchive.last_updated_name: u64)
3WriteRef
4Ret
}
 
public(friend) set_archive_change_name_time(Arg0: &mut UserArchive, Arg1: &Config, Arg2: &Clock) {
L3: loc0: u64
B0:
0MoveLoc[2](Arg2: &Clock)
1Call clock::timestamp_ms(&Clock): u64
2StLoc[3](loc0: u64)
3CopyLoc[3](loc0: u64)
4CopyLoc[0](Arg0: &mut UserArchive)
5ImmBorrowField[10](UserArchive.last_updated_name: u64)
6ReadRef
7MoveLoc[1](Arg1: &Config)
8ImmBorrowField[11](Config.change_name_gap: u64)
9ReadRef
10Add
11Ge
12BrFalse(14)
B1:
13Branch(18)
B2:
14MoveLoc[0](Arg0: &mut UserArchive)
15Pop
16LdConst[26](u64: 6018)
17Abort
B3:
18MoveLoc[3](loc0: u64)
19MoveLoc[0](Arg0: &mut UserArchive)
20MutBorrowField[10](UserArchive.last_updated_name: u64)
21WriteRef
22Ret
}
 
public(friend) update_user_nonce(Arg0: &mut UserArchive, Arg1: u8, Arg2: u128): u128 {
L3: loc0: u128
B0:
0CopyLoc[0](Arg0: &mut UserArchive)
1ImmBorrowField[12](UserArchive.nonce_type: Table<u8, u128>)
2CopyLoc[1](Arg1: u8)
3Call table::contains<u8, u128>(&Table<u8, u128>, u8): bool
4Not
5BrFalse(9)
B1:
6LdU128(0)
7StLoc[3](loc0: u128)
8Branch(14)
B2:
9CopyLoc[0](Arg0: &mut UserArchive)
10MutBorrowField[12](UserArchive.nonce_type: Table<u8, u128>)
11CopyLoc[1](Arg1: u8)
12Call table::remove<u8, u128>(&mut Table<u8, u128>, u8): u128
13StLoc[3](loc0: u128)
B3:
14MoveLoc[3](loc0: u128)
15CopyLoc[2](Arg2: u128)
16Lt
17BrFalse(19)
B4:
18Branch(23)
B5:
19MoveLoc[0](Arg0: &mut UserArchive)
20Pop
21LdConst[15](u64: 6007)
22Abort
B6:
23MoveLoc[0](Arg0: &mut UserArchive)
24MutBorrowField[12](UserArchive.nonce_type: Table<u8, u128>)
25MoveLoc[1](Arg1: u8)
26CopyLoc[2](Arg2: u128)
27Call table::add<u8, u128>(&mut Table<u8, u128>, u8, u128)
28MoveLoc[2](Arg2: u128)
29Ret
}
 
public update_time_change_gap(Arg0: &AdminCap, Arg1: u64, Arg2: &mut Config) {
B0:
0CopyLoc[1](Arg1: u64)
1LdU64(0)
2Ge
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[2](Arg2: &mut Config)
6Pop
7LdConst[9](u64: 6001)
8Abort
B3:
9MoveLoc[1](Arg1: u64)
10MoveLoc[2](Arg2: &mut Config)
11MutBorrowField[11](Config.change_name_gap: u64)
12WriteRef
13Ret
}
 
public update_validator(Arg0: &AdminCap, Arg1: vector<u8>, Arg2: &mut Config) {
B0:
0ImmBorrowLoc[1](Arg1: vector<u8>)
1VecLen(96)
2LdU64(32)
3Eq
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[2](Arg2: &mut Config)
7Pop
8LdConst[18](u64: 6010)
9Abort
B3:
10MoveLoc[2](Arg2: &mut Config)
11MutBorrowField[13](Config.validator: Option<vector<u8>>)
12MoveLoc[1](Arg1: vector<u8>)
13Call option::swap_or_fill<vector<u8>>(&mut Option<vector<u8>>, vector<u8>): Option<vector<u8>>
14Pop
15Ret
}
 
verify_signature(Arg0: vector<u8>, Arg1: vector<u8>, Arg2: &Option<vector<u8>>) {
B0:
0CopyLoc[2](Arg2: &Option<vector<u8>>)
1Call option::is_some<vector<u8>>(&Option<vector<u8>>): bool
2BrFalse(4)
B1:
3Branch(8)
B2:
4MoveLoc[2](Arg2: &Option<vector<u8>>)
5Pop
6LdConst[17](u64: 6009)
7Abort
B3:
8ImmBorrowLoc[0](Arg0: vector<u8>)
9MoveLoc[2](Arg2: &Option<vector<u8>>)
10Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
11ImmBorrowLoc[1](Arg1: vector<u8>)
12Call ed25519::ed25519_verify(&vector<u8>, &vector<u8>, &vector<u8>): bool
13BrFalse(15)
B4:
14Branch(17)
B5:
15LdConst[16](u64: 6008)
16Abort
B6:
17Ret
}
 
public(friend) verify_signature_v2(Arg0: &Config, Arg1: vector<u8>, Arg2: vector<u8>) {
L3: loc0: &vector<u8>
B0:
0CopyLoc[0](Arg0: &Config)
1ImmBorrowField[13](Config.validator: Option<vector<u8>>)
2Call option::is_none<vector<u8>>(&Option<vector<u8>>): bool
3BrFalse(8)
B1:
4MoveLoc[0](Arg0: &Config)
5Pop
6LdConst[17](u64: 6009)
7Abort
B2:
8MoveLoc[0](Arg0: &Config)
9ImmBorrowField[13](Config.validator: Option<vector<u8>>)
10Call option::borrow<vector<u8>>(&Option<vector<u8>>): &vector<u8>
11StLoc[3](loc0: &vector<u8>)
12ImmBorrowLoc[1](Arg1: vector<u8>)
13MoveLoc[3](loc0: &vector<u8>)
14ImmBorrowLoc[2](Arg2: vector<u8>)
15Call ed25519::ed25519_verify(&vector<u8>, &vector<u8>, &vector<u8>): bool
16BrFalse(18)
B3:
17Branch(20)
B4:
18LdConst[16](u64: 6008)
19Abort
B5:
20Ret
}
 
public verify_config(Arg0: &Config, Arg1: String) {
L2: loc0: &VecMap<String, Paused>
B0:
0CopyLoc[0](Arg0: &Config)
1ImmBorrowField[14](Config.version: u64)
2ReadRef
3LdConst[35](u64: 6)
4Le
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &Config)
8Pop
9LdConst[13](u64: 6005)
10Abort
B3:
11CopyLoc[0](Arg0: &Config)
12ImmBorrowField[2](Config.id: UID)
13LdConst[1](vector<u8>: "PAU..)
14Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
15BrFalse(39)
B4:
16MoveLoc[0](Arg0: &Config)
17ImmBorrowField[2](Config.id: UID)
18LdConst[1](vector<u8>: "PAU..)
19Call dynamic_field::borrow<vector<u8>, VecMap<String, Paused>>(&UID, vector<u8>): &VecMap<String, Paused>
20StLoc[2](loc0: &VecMap<String, Paused>)
21CopyLoc[2](loc0: &VecMap<String, Paused>)
22ImmBorrowLoc[1](Arg1: String)
23Call vec_map::contains<String, Paused>(&VecMap<String, Paused>, &String): bool
24BrFalse(35)
B5:
25MoveLoc[2](loc0: &VecMap<String, Paused>)
26ImmBorrowLoc[1](Arg1: String)
27Call vec_map::get<String, Paused>(&VecMap<String, Paused>, &String): &Paused
28ImmBorrowField[15](Paused.paused: bool)
29ReadRef
30Not
31BrFalse(33)
B6:
32Branch(43)
B7:
33LdConst[12](u64: 6004)
34Abort
B8:
35MoveLoc[2](loc0: &VecMap<String, Paused>)
36Pop
37LdConst[12](u64: 6004)
38Abort
B9:
39MoveLoc[0](Arg0: &Config)
40Pop
41LdConst[12](u64: 6004)
42Abort
B10:
43Ret
}
 
public paused(Arg0: &AdminCap, Arg1: &mut Config, Arg2: bool) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1MoveLoc[1](Arg1: &mut Config)
2LdConst[0](vector<u8>: "GUI..)
3Call string::utf8(vector<u8>): String
4MoveLoc[2](Arg2: bool)
5Call paused_v2(&AdminCap, &mut Config, String, bool)
6Ret
}
 
public paused_with_key(Arg0: &AdminCap, Arg1: &mut Config, Arg2: String, Arg3: bool) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1MoveLoc[1](Arg1: &mut Config)
2MoveLoc[2](Arg2: String)
3MoveLoc[3](Arg3: bool)
4Call paused_v2(&AdminCap, &mut Config, String, bool)
5Ret
}
 
public paused_v2(Arg0: &AdminCap, Arg1: &mut Config, Arg2: String, Arg3: bool) {
L4: loc0: &String
L5: loc1: VecMap<String, Paused>
L6: loc2: &mut VecMap<String, Paused>
L7: loc3: &mut Paused
B0:
0CopyLoc[1](Arg1: &mut Config)
1ImmBorrowField[2](Config.id: UID)
2LdConst[1](vector<u8>: "PAU..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(20)
B1:
6Call vec_map::empty<String, Paused>(): VecMap<String, Paused>
7StLoc[5](loc1: VecMap<String, Paused>)
8MutBorrowLoc[5](loc1: VecMap<String, Paused>)
9CopyLoc[2](Arg2: String)
10MoveLoc[2](Arg2: String)
11MoveLoc[3](Arg3: bool)
12Pack[8](Paused)
13Call vec_map::insert<String, Paused>(&mut VecMap<String, Paused>, String, Paused)
14MoveLoc[1](Arg1: &mut Config)
15MutBorrowField[2](Config.id: UID)
16LdConst[1](vector<u8>: "PAU..)
17MoveLoc[5](loc1: VecMap<String, Paused>)
18Call dynamic_field::add<vector<u8>, VecMap<String, Paused>>(&mut UID, vector<u8>, VecMap<String, Paused>)
19Branch(47)
B2:
20MoveLoc[1](Arg1: &mut Config)
21MutBorrowField[2](Config.id: UID)
22LdConst[1](vector<u8>: "PAU..)
23Call dynamic_field::borrow_mut<vector<u8>, VecMap<String, Paused>>(&mut UID, vector<u8>): &mut VecMap<String, Paused>
24StLoc[6](loc2: &mut VecMap<String, Paused>)
25CopyLoc[6](loc2: &mut VecMap<String, Paused>)
26ImmBorrowLoc[2](Arg2: String)
27StLoc[4](loc0: &String)
28FreezeRef
29MoveLoc[4](loc0: &String)
30Call vec_map::contains<String, Paused>(&VecMap<String, Paused>, &String): bool
31BrFalse(41)
B3:
32MoveLoc[6](loc2: &mut VecMap<String, Paused>)
33ImmBorrowLoc[2](Arg2: String)
34Call vec_map::get_mut<String, Paused>(&mut VecMap<String, Paused>, &String): &mut Paused
35StLoc[7](loc3: &mut Paused)
36MoveLoc[3](Arg3: bool)
37MoveLoc[7](loc3: &mut Paused)
38MutBorrowField[15](Paused.paused: bool)
39WriteRef
40Branch(47)
B4:
41MoveLoc[6](loc2: &mut VecMap<String, Paused>)
42CopyLoc[2](Arg2: String)
43MoveLoc[2](Arg2: String)
44MoveLoc[3](Arg3: bool)
45Pack[8](Paused)
46Call vec_map::insert<String, Paused>(&mut VecMap<String, Paused>, String, Paused)
B5:
47Ret
}
 
public migrate(Arg0: &AdminCap, Arg1: &mut Config, Arg2: u64) {
B0:
0CopyLoc[1](Arg1: &mut Config)
1ImmBorrowField[14](Config.version: u64)
2ReadRef
3CopyLoc[2](Arg2: u64)
4Lt
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[1](Arg1: &mut Config)
8Pop
9LdConst[19](u64: 6011)
10Abort
B3:
11MoveLoc[2](Arg2: u64)
12MoveLoc[1](Arg1: &mut Config)
13MutBorrowField[14](Config.version: u64)
14WriteRef
15Ret
}
 
public withdraw_amount_from_vault<Ty0>(Arg0: &TreasureCap, Arg1: &Config, Arg2: &mut GlobalVault, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public withdraw_all_from_vault<Ty0>(Arg0: &TreasureCap, Arg1: &Config, Arg2: &mut GlobalVault, Arg3: &Clock, Arg4: &mut TxContext) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public deposit_fund_to_vault<Ty0>(Arg0: &TreasureCap, Arg1: &mut GlobalVault, Arg2: Balance<Ty0>, Arg3: &Clock) {
B0:
0LdConst[31](u64: 6023)
1Abort
}
 
public set_fee_type<Ty0>(Arg0: &AdminCap, Arg1: &mut Config, Arg2: String) {
L3: loc0: &String
L4: loc1: &mut TypeName
L5: loc2: VecMap<String, TypeName>
L6: loc3: &mut VecMap<String, TypeName>
B0:
0CopyLoc[1](Arg1: &mut Config)
1ImmBorrowField[2](Config.id: UID)
2LdConst[3](vector<u8>: "FEE..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(18)
B1:
6Call vec_map::empty<String, TypeName>(): VecMap<String, TypeName>
7StLoc[5](loc2: VecMap<String, TypeName>)
8MutBorrowLoc[5](loc2: VecMap<String, TypeName>)
9MoveLoc[2](Arg2: String)
10Call type_name::get<Ty0>(): TypeName
11Call vec_map::insert<String, TypeName>(&mut VecMap<String, TypeName>, String, TypeName)
12MoveLoc[1](Arg1: &mut Config)
13MutBorrowField[2](Config.id: UID)
14LdConst[3](vector<u8>: "FEE..)
15MoveLoc[5](loc2: VecMap<String, TypeName>)
16Call dynamic_field::add<vector<u8>, VecMap<String, TypeName>>(&mut UID, vector<u8>, VecMap<String, TypeName>)
17Branch(42)
B2:
18MoveLoc[1](Arg1: &mut Config)
19MutBorrowField[2](Config.id: UID)
20LdConst[3](vector<u8>: "FEE..)
21Call dynamic_field::borrow_mut<vector<u8>, VecMap<String, TypeName>>(&mut UID, vector<u8>): &mut VecMap<String, TypeName>
22StLoc[6](loc3: &mut VecMap<String, TypeName>)
23CopyLoc[6](loc3: &mut VecMap<String, TypeName>)
24ImmBorrowLoc[2](Arg2: String)
25StLoc[3](loc0: &String)
26FreezeRef
27MoveLoc[3](loc0: &String)
28Call vec_map::contains<String, TypeName>(&VecMap<String, TypeName>, &String): bool
29BrFalse(38)
B3:
30MoveLoc[6](loc3: &mut VecMap<String, TypeName>)
31ImmBorrowLoc[2](Arg2: String)
32Call vec_map::get_mut<String, TypeName>(&mut VecMap<String, TypeName>, &String): &mut TypeName
33StLoc[4](loc1: &mut TypeName)
34Call type_name::get<Ty0>(): TypeName
35MoveLoc[4](loc1: &mut TypeName)
36WriteRef
37Branch(42)
B4:
38MoveLoc[6](loc3: &mut VecMap<String, TypeName>)
39MoveLoc[2](Arg2: String)
40Call type_name::get<Ty0>(): TypeName
41Call vec_map::insert<String, TypeName>(&mut VecMap<String, TypeName>, String, TypeName)
B5:
42Ret
}
 
public get_fee_type(Arg0: &Config, Arg1: String): TypeName {
L2: loc0: &VecMap<String, TypeName>
B0:
0CopyLoc[0](Arg0: &Config)
1ImmBorrowField[2](Config.id: UID)
2LdConst[3](vector<u8>: "FEE..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &Config)
7Pop
8LdConst[34](u64: 6026)
9Abort
B3:
10MoveLoc[0](Arg0: &Config)
11ImmBorrowField[2](Config.id: UID)
12LdConst[3](vector<u8>: "FEE..)
13Call dynamic_field::borrow<vector<u8>, VecMap<String, TypeName>>(&UID, vector<u8>): &VecMap<String, TypeName>
14StLoc[2](loc0: &VecMap<String, TypeName>)
15CopyLoc[2](loc0: &VecMap<String, TypeName>)
16ImmBorrowLoc[1](Arg1: String)
17Call vec_map::contains<String, TypeName>(&VecMap<String, TypeName>, &String): bool
18BrFalse(20)
B4:
19Branch(24)
B5:
20MoveLoc[2](loc0: &VecMap<String, TypeName>)
21Pop
22LdConst[34](u64: 6026)
23Abort
B6:
24MoveLoc[2](loc0: &VecMap<String, TypeName>)
25ImmBorrowLoc[1](Arg1: String)
26Call vec_map::get<String, TypeName>(&VecMap<String, TypeName>, &String): &TypeName
27ReadRef
28Ret
}
 
Constants [
0 => vector<u8>: "GUILD_MODULE" // interpreted as UTF8 string
1 => vector<u8>: "PAUSED" // interpreted as UTF8 string
2 => vector<u8>: "COMMISSION_TIME_RANGE" // interpreted as UTF8 string
3 => vector<u8>: "FEE_TYPE_KEY" // interpreted as UTF8 string
4 => vector<u8>: "CHECKIN_KEY" // interpreted as UTF8 string
5 => vector<u8>: "MAX_CHECKIN_DAYS_KEY" // interpreted as UTF8 string
6 => vector<u8>: "CHECKIN_FEE" // interpreted as UTF8 string
7 => u64: 86400000
8 => u64: 6000
9 => u64: 6001
10 => u64: 6002
11 => u64: 6003
12 => u64: 6004
13 => u64: 6005
14 => u64: 6006
15 => u64: 6007
16 => u64: 6008
17 => u64: 6009
18 => u64: 6010
19 => u64: 6011
20 => u64: 6012
21 => u64: 6013
22 => u64: 6014
23 => u64: 6015
24 => u64: 6016
25 => u64: 6017
26 => u64: 6018
27 => u64: 6019
28 => u64: 6020
29 => u64: 6021
30 => u64: 6022
31 => u64: 6023
32 => u64: 6024
33 => u64: 6025
34 => u64: 6026
35 => u64: 6
36 => u64: 604800000
37 => address: 0x08b994f6ec4a22c6f5fabe10f25822a0b33f7c1a4881dbf2f6d19dae55809baa
]
}