boosting_v2
Module0x351d…0dc6
- Move path
- 0xe19a…dfe6::boosting_v2
- Functions
- 3329 public, 0 entry
- Structs
- 28
- Friend modules
- None
Bytecode3285 lines
The on-chain disassembly. Offsets are instruction numbers within each function.
// Move bytecode v6
module e19a74728854cd996c7d26b8ced51ecbc2bb655ce33bb3976992b638fcb9dfe6.boosting_v2 {
use e19a74728854cd996c7d26b8ced51ecbc2bb655ce33bb3976992b638fcb9dfe6::guild;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::bcs;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct BoostingVault has key {
id: UID,
balances: Bag,
fund_receiver: address,
tokens_stat: vector<TokenStat>
}
struct TokenStat has copy, drop, store {
token_type: TypeName,
amount_in: u64,
amount_out: u64,
last_updated: u64
}
struct PreSubscribe has key {
id: UID,
paused: bool,
start_time: u64,
duration: u64,
price_per_class: Table<u8, u64>,
fee_type: TypeName,
subscribers: VecSet<address>,
subscribers_type: Table<u8, VecSet<address>>,
no_slots: Table<u8, u16>,
wl_manager: VecSet<address>,
whitelisted: Table<u8, VecSet<address>>,
refund_amounts: Table<address, u64>,
refund_available: bool,
total_deposit: u64,
total_refund: u64
}
struct VaultCreatedEvent has copy, drop {
vault_id: ID
}
struct SetFundReceiverEvent has copy, drop {
new_receiver: address
}
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 InitPreSubscribeEvent has copy, drop {
pre_subscribe: ID
}
struct PausePreSubscribeEvent has copy, drop {
pre_subscribe: ID,
paused: bool
}
struct SetartTimePreSubscribeEvent has copy, drop {
pre_subscribe: ID,
start_time: u64
}
struct SetDurationPreSubscribeEvent has copy, drop {
pre_subscribe: ID,
duration: u64
}
struct SetPricePerClassPreSubscribeEvent has copy, drop {
pre_subscribe: ID,
class: u8,
price: u64
}
struct SetFeeTypePreSubscribeEvent has copy, drop {
pre_subscribe: ID,
fee_type: TypeName
}
struct SetSlotsPreSubscribeEvent has copy, drop {
pre_subscribe: ID,
type: u8,
slots: u16
}
struct AddWLManagerEvent has copy, drop {
pre_subscribe: ID,
manager: vector<address>
}
struct RemoveWLManagerEvent has copy, drop {
pre_subscribe: ID,
manager: vector<address>
}
struct AddWhitelistEvent has copy, drop {
pre_subscribe: ID,
type: u8,
users: vector<address>
}
struct RemoveWhitelistEvent has copy, drop {
pre_subscribe: ID,
type: u8,
users: vector<address>
}
struct SetRefundAvailableEvent has copy, drop {
pre_subscribe: ID,
available: bool
}
struct DepositPreSubscribeEvent has copy, drop {
pre_subscribe: ID,
subscriber: address,
type: u8,
amount: u64
}
struct RefundPreSubscribeEvent has copy, drop {
pre_subscribe: ID,
subscriber: address,
premium_refundable: bool,
premium_plus_refundable: bool,
amount: u64
}
struct PreSubscribeEvent has copy, drop {
subscriber: address,
type: u8,
amount: u64
}
struct BuyingStarEvent has copy, drop {
buyer: address,
number_of_stars: u64,
fee: u64,
nonce: u128
}
struct SwappingStarEvent has copy, drop {
swapper: address,
number_of_stars: u64,
received_fee: u64,
nonce: u128
}
struct SubscriptionEvent has copy, drop {
subscriber: address,
duration: u16,
fee: u64,
class: u8,
nonce: u128
}
struct CommissionClaimEvent has copy, drop {
claimer: address,
amount: u64,
min_time: u64,
max_time: u64,
nonce: u128
}
struct CommissionClaimEventV2 has copy, drop {
claimer: address,
type: u8,
amount: u64,
min_time: u64,
max_time: u64,
nonce: u128
}
struct ClaimBonusEvent has copy, drop {
claimer: address,
amount: u64,
min_time: u64,
max_time: u64,
nonce: u128
}
public register(Arg0: &mut Logs, Arg1: &mut Config, Arg2: &mut TxContext): UserArchive {
B0:
0MoveLoc[0](Arg0: &mut Logs)
1MoveLoc[1](Arg1: &mut Config)
2MoveLoc[2](Arg2: &mut TxContext)
3Call guild::register(&mut Logs, &mut Config, &mut TxContext): UserArchive
4Ret
}
public init_vault(Arg0: &AdminCap, Arg1: &mut TxContext) {
L2: loc0: BoostingVault
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1Call object::new(&mut TxContext): UID
2CopyLoc[1](Arg1: &mut TxContext)
3Call bag::new(&mut TxContext): Bag
4MoveLoc[1](Arg1: &mut TxContext)
5FreezeRef
6Call tx_context::sender(&TxContext): address
7VecPack(37, 0)
8Pack[0](BoostingVault)
9StLoc[2](loc0: BoostingVault)
10ImmBorrowLoc[2](loc0: BoostingVault)
11Call object::id<BoostingVault>(&BoostingVault): ID
12Pack[3](VaultCreatedEvent)
13Call event::emit<VaultCreatedEvent>(VaultCreatedEvent)
14MoveLoc[2](loc0: BoostingVault)
15Call transfer::share_object<BoostingVault>(BoostingVault)
16Ret
}
public buying_stars<Ty0>(Arg0: &Config, Arg1: &mut BoostingVault, Arg2: &mut UserArchive, Arg3: u64, Arg4: vector<u8>, Arg5: vector<u8>, Arg6: Balance<Ty0>, Arg7: &Clock, Arg8: &mut TxContext) {
L9: loc0: &mut TxContext
L10: loc1: bool
L11: loc2: bool
L12: loc3: u64
L13: loc4: BCS
L14: loc5: address
L15: loc6: String
L16: loc7: u64
L17: loc8: u128
L18: loc9: u128
L19: loc10: u64
L20: loc11: address
L21: loc12: u64
L22: loc13: vector<u8>
L23: loc14: String
L24: loc15: u8
B0:
0CopyLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4MoveLoc[0](Arg0: &Config)
5MoveLoc[4](Arg4: vector<u8>)
6CopyLoc[5](Arg5: vector<u8>)
7Call guild::verify_signature_v2(&Config, vector<u8>, vector<u8>)
8CopyLoc[8](Arg8: &mut TxContext)
9FreezeRef
10Call tx_context::sender(&TxContext): address
11StLoc[20](loc11: address)
12CopyLoc[2](Arg2: &mut UserArchive)
13MoveLoc[8](Arg8: &mut TxContext)
14StLoc[9](loc0: &mut TxContext)
15FreezeRef
16MoveLoc[9](loc0: &mut TxContext)
17Call guild::validate_archive_owner(&UserArchive, &mut TxContext)
18CopyLoc[7](Arg7: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20StLoc[19](loc10: u64)
21MoveLoc[5](Arg5: vector<u8>)
22Call bcs::new(vector<u8>): BCS
23StLoc[13](loc4: BCS)
24MutBorrowLoc[13](loc4: BCS)
25Call bcs::peel_u8(&mut BCS): u8
26MutBorrowLoc[13](loc4: BCS)
27Call bcs::peel_address(&mut BCS): address
28MutBorrowLoc[13](loc4: BCS)
29Call bcs::peel_u64(&mut BCS): u64
30MutBorrowLoc[13](loc4: BCS)
31Call bcs::peel_u64(&mut BCS): u64
32MutBorrowLoc[13](loc4: BCS)
33Call bcs::peel_vec_u8(&mut BCS): vector<u8>
34MutBorrowLoc[13](loc4: BCS)
35Call bcs::peel_u64(&mut BCS): u64
36MutBorrowLoc[13](loc4: BCS)
37Call bcs::peel_u128(&mut BCS): u128
38StLoc[18](loc9: u128)
39StLoc[16](loc7: u64)
40StLoc[22](loc13: vector<u8>)
41StLoc[12](loc3: u64)
42StLoc[21](loc12: u64)
43StLoc[14](loc5: address)
44StLoc[24](loc15: u8)
45CopyLoc[20](loc11: address)
46MoveLoc[14](loc5: address)
47Eq
48BrFalse(50)
B1:
49Branch(58)
B2:
50MoveLoc[1](Arg1: &mut BoostingVault)
51Pop
52MoveLoc[7](Arg7: &Clock)
53Pop
54MoveLoc[2](Arg2: &mut UserArchive)
55Pop
56LdConst[6](u64: 7000)
57Abort
B3:
58CopyLoc[3](Arg3: u64)
59LdU64(0)
60Gt
61BrFalse(67)
B4:
62CopyLoc[3](Arg3: u64)
63MoveLoc[21](loc12: u64)
64Eq
65StLoc[10](loc1: bool)
66Branch(69)
B5:
67LdFalse
68StLoc[10](loc1: bool)
B6:
69MoveLoc[10](loc1: bool)
70BrFalse(72)
B7:
71Branch(80)
B8:
72MoveLoc[1](Arg1: &mut BoostingVault)
73Pop
74MoveLoc[7](Arg7: &Clock)
75Pop
76MoveLoc[2](Arg2: &mut UserArchive)
77Pop
78LdConst[7](u64: 7001)
79Abort
B9:
80CopyLoc[12](loc3: u64)
81LdU64(0)
82Gt
83BrFalse(90)
B10:
84ImmBorrowLoc[6](Arg6: Balance<Ty0>)
85Call balance::value<Ty0>(&Balance<Ty0>): u64
86CopyLoc[12](loc3: u64)
87Eq
88StLoc[11](loc2: bool)
89Branch(92)
B11:
90LdFalse
91StLoc[11](loc2: bool)
B12:
92MoveLoc[11](loc2: bool)
93BrFalse(95)
B13:
94Branch(103)
B14:
95MoveLoc[1](Arg1: &mut BoostingVault)
96Pop
97MoveLoc[7](Arg7: &Clock)
98Pop
99MoveLoc[2](Arg2: &mut UserArchive)
100Pop
101LdConst[8](u64: 7002)
102Abort
B15:
103Call type_name::get<Ty0>(): TypeName
104Call type_name::into_string(TypeName): String
105Call string::from_ascii(String): String
106StLoc[15](loc6: String)
107MoveLoc[22](loc13: vector<u8>)
108Call string::utf8(vector<u8>): String
109StLoc[23](loc14: String)
110MoveLoc[15](loc6: String)
111MoveLoc[23](loc14: String)
112Eq
113BrFalse(115)
B16:
114Branch(123)
B17:
115MoveLoc[1](Arg1: &mut BoostingVault)
116Pop
117MoveLoc[7](Arg7: &Clock)
118Pop
119MoveLoc[2](Arg2: &mut UserArchive)
120Pop
121LdConst[11](u64: 7005)
122Abort
B18:
123CopyLoc[19](loc10: u64)
124MoveLoc[16](loc7: u64)
125Lt
126BrFalse(128)
B19:
127Branch(136)
B20:
128MoveLoc[1](Arg1: &mut BoostingVault)
129Pop
130MoveLoc[7](Arg7: &Clock)
131Pop
132MoveLoc[2](Arg2: &mut UserArchive)
133Pop
134LdConst[10](u64: 7004)
135Abort
B21:
136CopyLoc[2](Arg2: &mut UserArchive)
137MoveLoc[24](loc15: u8)
138MoveLoc[18](loc9: u128)
139Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128
140StLoc[17](loc8: u128)
141MoveLoc[2](Arg2: &mut UserArchive)
142MoveLoc[19](loc10: u64)
143Call guild::set_archive_last_name_time(&mut UserArchive, u64)
144MoveLoc[1](Arg1: &mut BoostingVault)
145MoveLoc[6](Arg6: Balance<Ty0>)
146MoveLoc[7](Arg7: &Clock)
147Call deposit_to_vault<Ty0>(&mut BoostingVault, Balance<Ty0>, &Clock)
148MoveLoc[20](loc11: address)
149MoveLoc[3](Arg3: u64)
150MoveLoc[12](loc3: u64)
151MoveLoc[17](loc8: u128)
152Pack[22](BuyingStarEvent)
153Call event::emit<BuyingStarEvent>(BuyingStarEvent)
154Ret
}
public swap_stars<Ty0>(Arg0: &Config, Arg1: &mut BoostingVault, Arg2: &mut UserArchive, Arg3: u64, Arg4: u64, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: &Clock, Arg8: &mut TxContext) {
L9: loc0: &mut TxContext
L10: loc1: bool
L11: loc2: bool
L12: loc3: BCS
L13: loc4: Coin<Ty0>
L14: loc5: String
L15: loc6: u64
L16: loc7: u128
L17: loc8: u128
L18: loc9: u64
L19: loc10: u64
L20: loc11: address
L21: loc12: u64
L22: loc13: address
L23: loc14: vector<u8>
L24: loc15: String
L25: loc16: u8
B0:
0CopyLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4MoveLoc[0](Arg0: &Config)
5MoveLoc[5](Arg5: vector<u8>)
6CopyLoc[6](Arg6: vector<u8>)
7Call guild::verify_signature_v2(&Config, vector<u8>, vector<u8>)
8CopyLoc[8](Arg8: &mut TxContext)
9FreezeRef
10Call tx_context::sender(&TxContext): address
11StLoc[20](loc11: address)
12CopyLoc[2](Arg2: &mut UserArchive)
13CopyLoc[8](Arg8: &mut TxContext)
14StLoc[9](loc0: &mut TxContext)
15FreezeRef
16MoveLoc[9](loc0: &mut TxContext)
17Call guild::validate_archive_owner(&UserArchive, &mut TxContext)
18CopyLoc[7](Arg7: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20StLoc[18](loc9: u64)
21MoveLoc[6](Arg6: vector<u8>)
22Call bcs::new(vector<u8>): BCS
23StLoc[12](loc3: BCS)
24MutBorrowLoc[12](loc3: BCS)
25Call bcs::peel_u8(&mut BCS): u8
26MutBorrowLoc[12](loc3: BCS)
27Call bcs::peel_address(&mut BCS): address
28MutBorrowLoc[12](loc3: BCS)
29Call bcs::peel_u64(&mut BCS): u64
30MutBorrowLoc[12](loc3: BCS)
31Call bcs::peel_u64(&mut BCS): u64
32MutBorrowLoc[12](loc3: BCS)
33Call bcs::peel_vec_u8(&mut BCS): vector<u8>
34MutBorrowLoc[12](loc3: BCS)
35Call bcs::peel_u64(&mut BCS): u64
36MutBorrowLoc[12](loc3: BCS)
37Call bcs::peel_u128(&mut BCS): u128
38StLoc[17](loc8: u128)
39StLoc[15](loc6: u64)
40StLoc[23](loc14: vector<u8>)
41StLoc[19](loc10: u64)
42StLoc[21](loc12: u64)
43StLoc[22](loc13: address)
44StLoc[25](loc16: u8)
45CopyLoc[20](loc11: address)
46CopyLoc[22](loc13: address)
47Eq
48BrFalse(50)
B1:
49Branch(60)
B2:
50MoveLoc[1](Arg1: &mut BoostingVault)
51Pop
52MoveLoc[8](Arg8: &mut TxContext)
53Pop
54MoveLoc[7](Arg7: &Clock)
55Pop
56MoveLoc[2](Arg2: &mut UserArchive)
57Pop
58LdConst[6](u64: 7000)
59Abort
B3:
60CopyLoc[3](Arg3: u64)
61LdU64(0)
62Gt
63BrFalse(69)
B4:
64MoveLoc[21](loc12: u64)
65CopyLoc[3](Arg3: u64)
66Eq
67StLoc[10](loc1: bool)
68Branch(71)
B5:
69LdFalse
70StLoc[10](loc1: bool)
B6:
71MoveLoc[10](loc1: bool)
72BrFalse(74)
B7:
73Branch(84)
B8:
74MoveLoc[1](Arg1: &mut BoostingVault)
75Pop
76MoveLoc[8](Arg8: &mut TxContext)
77Pop
78MoveLoc[7](Arg7: &Clock)
79Pop
80MoveLoc[2](Arg2: &mut UserArchive)
81Pop
82LdConst[7](u64: 7001)
83Abort
B9:
84CopyLoc[19](loc10: u64)
85LdU64(0)
86Gt
87BrFalse(93)
B10:
88MoveLoc[4](Arg4: u64)
89CopyLoc[19](loc10: u64)
90Eq
91StLoc[11](loc2: bool)
92Branch(95)
B11:
93LdFalse
94StLoc[11](loc2: bool)
B12:
95MoveLoc[11](loc2: bool)
96BrFalse(98)
B13:
97Branch(108)
B14:
98MoveLoc[1](Arg1: &mut BoostingVault)
99Pop
100MoveLoc[8](Arg8: &mut TxContext)
101Pop
102MoveLoc[7](Arg7: &Clock)
103Pop
104MoveLoc[2](Arg2: &mut UserArchive)
105Pop
106LdConst[8](u64: 7002)
107Abort
B15:
108Call type_name::get<Ty0>(): TypeName
109Call type_name::into_string(TypeName): String
110Call string::from_ascii(String): String
111StLoc[14](loc5: String)
112MoveLoc[23](loc14: vector<u8>)
113Call string::utf8(vector<u8>): String
114StLoc[24](loc15: String)
115MoveLoc[14](loc5: String)
116MoveLoc[24](loc15: String)
117Eq
118BrFalse(120)
B16:
119Branch(130)
B17:
120MoveLoc[1](Arg1: &mut BoostingVault)
121Pop
122MoveLoc[8](Arg8: &mut TxContext)
123Pop
124MoveLoc[7](Arg7: &Clock)
125Pop
126MoveLoc[2](Arg2: &mut UserArchive)
127Pop
128LdConst[11](u64: 7005)
129Abort
B18:
130CopyLoc[18](loc9: u64)
131MoveLoc[15](loc6: u64)
132Lt
133BrFalse(135)
B19:
134Branch(145)
B20:
135MoveLoc[1](Arg1: &mut BoostingVault)
136Pop
137MoveLoc[8](Arg8: &mut TxContext)
138Pop
139MoveLoc[7](Arg7: &Clock)
140Pop
141MoveLoc[2](Arg2: &mut UserArchive)
142Pop
143LdConst[10](u64: 7004)
144Abort
B21:
145CopyLoc[2](Arg2: &mut UserArchive)
146MoveLoc[25](loc16: u8)
147MoveLoc[17](loc8: u128)
148Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128
149StLoc[16](loc7: u128)
150MoveLoc[2](Arg2: &mut UserArchive)
151MoveLoc[18](loc9: u64)
152Call guild::set_archive_last_name_time(&mut UserArchive, u64)
153MoveLoc[1](Arg1: &mut BoostingVault)
154CopyLoc[19](loc10: u64)
155MoveLoc[7](Arg7: &Clock)
156MoveLoc[8](Arg8: &mut TxContext)
157Call withdraw_from_vault<Ty0>(&mut BoostingVault, u64, &Clock, &mut TxContext): Coin<Ty0>
158StLoc[13](loc4: Coin<Ty0>)
159MoveLoc[20](loc11: address)
160MoveLoc[3](Arg3: u64)
161MoveLoc[19](loc10: u64)
162MoveLoc[16](loc7: u128)
163Pack[23](SwappingStarEvent)
164Call event::emit<SwappingStarEvent>(SwappingStarEvent)
165MoveLoc[13](loc4: Coin<Ty0>)
166MoveLoc[22](loc13: address)
167Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
168Ret
}
public subscribe<Ty0>(Arg0: &Config, Arg1: &mut BoostingVault, Arg2: &mut UserArchive, Arg3: u16, Arg4: u8, Arg5: vector<u8>, Arg6: vector<u8>, Arg7: Balance<Ty0>, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: &mut TxContext
L11: loc1: bool
L12: loc2: u64
L13: loc3: BCS
L14: loc4: u8
L15: loc5: String
L16: loc6: u64
L17: loc7: u128
L18: loc8: u128
L19: loc9: u64
L20: loc10: u16
L21: loc11: address
L22: loc12: address
L23: loc13: vector<u8>
L24: loc14: String
L25: loc15: u8
B0:
0CopyLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4MoveLoc[0](Arg0: &Config)
5MoveLoc[5](Arg5: vector<u8>)
6CopyLoc[6](Arg6: vector<u8>)
7Call guild::verify_signature_v2(&Config, vector<u8>, vector<u8>)
8CopyLoc[9](Arg9: &mut TxContext)
9FreezeRef
10Call tx_context::sender(&TxContext): address
11StLoc[21](loc11: address)
12CopyLoc[2](Arg2: &mut UserArchive)
13MoveLoc[9](Arg9: &mut TxContext)
14StLoc[10](loc0: &mut TxContext)
15FreezeRef
16MoveLoc[10](loc0: &mut TxContext)
17Call guild::validate_archive_owner(&UserArchive, &mut TxContext)
18CopyLoc[8](Arg8: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20StLoc[19](loc9: u64)
21MoveLoc[6](Arg6: vector<u8>)
22Call bcs::new(vector<u8>): BCS
23StLoc[13](loc3: BCS)
24MutBorrowLoc[13](loc3: BCS)
25Call bcs::peel_u8(&mut BCS): u8
26MutBorrowLoc[13](loc3: BCS)
27Call bcs::peel_address(&mut BCS): address
28MutBorrowLoc[13](loc3: BCS)
29Call bcs::peel_u16(&mut BCS): u16
30MutBorrowLoc[13](loc3: BCS)
31Call bcs::peel_u8(&mut BCS): u8
32MutBorrowLoc[13](loc3: BCS)
33Call bcs::peel_u64(&mut BCS): u64
34MutBorrowLoc[13](loc3: BCS)
35Call bcs::peel_vec_u8(&mut BCS): vector<u8>
36MutBorrowLoc[13](loc3: BCS)
37Call bcs::peel_u64(&mut BCS): u64
38MutBorrowLoc[13](loc3: BCS)
39Call bcs::peel_u128(&mut BCS): u128
40StLoc[18](loc8: u128)
41StLoc[16](loc6: u64)
42StLoc[23](loc13: vector<u8>)
43StLoc[12](loc2: u64)
44StLoc[14](loc4: u8)
45StLoc[20](loc10: u16)
46StLoc[22](loc12: address)
47StLoc[25](loc15: u8)
48CopyLoc[21](loc11: address)
49MoveLoc[22](loc12: address)
50Eq
51BrFalse(53)
B1:
52Branch(61)
B2:
53MoveLoc[1](Arg1: &mut BoostingVault)
54Pop
55MoveLoc[8](Arg8: &Clock)
56Pop
57MoveLoc[2](Arg2: &mut UserArchive)
58Pop
59LdConst[6](u64: 7000)
60Abort
B3:
61MoveLoc[20](loc10: u16)
62CopyLoc[3](Arg3: u16)
63Eq
64BrFalse(66)
B4:
65Branch(74)
B5:
66MoveLoc[1](Arg1: &mut BoostingVault)
67Pop
68MoveLoc[8](Arg8: &Clock)
69Pop
70MoveLoc[2](Arg2: &mut UserArchive)
71Pop
72LdConst[7](u64: 7001)
73Abort
B6:
74CopyLoc[14](loc4: u8)
75MoveLoc[4](Arg4: u8)
76Eq
77BrFalse(79)
B7:
78Branch(87)
B8:
79MoveLoc[1](Arg1: &mut BoostingVault)
80Pop
81MoveLoc[8](Arg8: &Clock)
82Pop
83MoveLoc[2](Arg2: &mut UserArchive)
84Pop
85LdConst[7](u64: 7001)
86Abort
B9:
87CopyLoc[12](loc2: u64)
88LdU64(0)
89Gt
90BrFalse(97)
B10:
91ImmBorrowLoc[7](Arg7: Balance<Ty0>)
92Call balance::value<Ty0>(&Balance<Ty0>): u64
93CopyLoc[12](loc2: u64)
94Eq
95StLoc[11](loc1: bool)
96Branch(99)
B11:
97LdFalse
98StLoc[11](loc1: bool)
B12:
99MoveLoc[11](loc1: bool)
100BrFalse(102)
B13:
101Branch(110)
B14:
102MoveLoc[1](Arg1: &mut BoostingVault)
103Pop
104MoveLoc[8](Arg8: &Clock)
105Pop
106MoveLoc[2](Arg2: &mut UserArchive)
107Pop
108LdConst[8](u64: 7002)
109Abort
B15:
110Call type_name::get<Ty0>(): TypeName
111Call type_name::into_string(TypeName): String
112Call string::from_ascii(String): String
113StLoc[15](loc5: String)
114MoveLoc[23](loc13: vector<u8>)
115Call string::utf8(vector<u8>): String
116StLoc[24](loc14: String)
117MoveLoc[15](loc5: String)
118MoveLoc[24](loc14: String)
119Eq
120BrFalse(122)
B16:
121Branch(130)
B17:
122MoveLoc[1](Arg1: &mut BoostingVault)
123Pop
124MoveLoc[8](Arg8: &Clock)
125Pop
126MoveLoc[2](Arg2: &mut UserArchive)
127Pop
128LdConst[11](u64: 7005)
129Abort
B18:
130CopyLoc[19](loc9: u64)
131MoveLoc[16](loc6: u64)
132Lt
133BrFalse(135)
B19:
134Branch(143)
B20:
135MoveLoc[1](Arg1: &mut BoostingVault)
136Pop
137MoveLoc[8](Arg8: &Clock)
138Pop
139MoveLoc[2](Arg2: &mut UserArchive)
140Pop
141LdConst[10](u64: 7004)
142Abort
B21:
143CopyLoc[2](Arg2: &mut UserArchive)
144MoveLoc[25](loc15: u8)
145MoveLoc[18](loc8: u128)
146Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128
147StLoc[17](loc7: u128)
148MoveLoc[2](Arg2: &mut UserArchive)
149MoveLoc[19](loc9: u64)
150Call guild::set_archive_last_name_time(&mut UserArchive, u64)
151MoveLoc[1](Arg1: &mut BoostingVault)
152MoveLoc[7](Arg7: Balance<Ty0>)
153MoveLoc[8](Arg8: &Clock)
154Call deposit_to_vault<Ty0>(&mut BoostingVault, Balance<Ty0>, &Clock)
155MoveLoc[21](loc11: address)
156MoveLoc[3](Arg3: u16)
157MoveLoc[12](loc2: u64)
158MoveLoc[14](loc4: u8)
159MoveLoc[17](loc7: u128)
160Pack[24](SubscriptionEvent)
161Call event::emit<SubscriptionEvent>(SubscriptionEvent)
162Ret
}
public claim_commission<Ty0>(Arg0: &Config, Arg1: &mut BoostingVault, Arg2: &mut UserArchive, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: &mut TxContext
L11: loc1: bool
L12: loc2: bool
L13: loc3: bool
L14: loc4: BCS
L15: loc5: u64
L16: loc6: address
L17: loc7: Coin<Ty0>
L18: loc8: String
L19: loc9: u64
L20: loc10: u128
L21: loc11: u128
L22: loc12: u64
L23: loc13: address
L24: loc14: u64
L25: loc15: u64
L26: loc16: vector<u8>
L27: loc17: String
L28: loc18: u8
B0:
0CopyLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4MoveLoc[0](Arg0: &Config)
5MoveLoc[6](Arg6: vector<u8>)
6CopyLoc[7](Arg7: vector<u8>)
7Call guild::verify_signature_v2(&Config, vector<u8>, vector<u8>)
8CopyLoc[2](Arg2: &mut UserArchive)
9CopyLoc[9](Arg9: &mut TxContext)
10StLoc[10](loc0: &mut TxContext)
11FreezeRef
12MoveLoc[10](loc0: &mut TxContext)
13Call guild::validate_archive_owner(&UserArchive, &mut TxContext)
14CopyLoc[9](Arg9: &mut TxContext)
15FreezeRef
16Call tx_context::sender(&TxContext): address
17StLoc[23](loc13: address)
18CopyLoc[8](Arg8: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20StLoc[22](loc12: u64)
21CopyLoc[22](loc12: u64)
22CopyLoc[5](Arg5: u64)
23Ge
24BrFalse(30)
B1:
25CopyLoc[5](Arg5: u64)
26CopyLoc[4](Arg4: u64)
27Ge
28StLoc[11](loc1: bool)
29Branch(32)
B2:
30LdFalse
31StLoc[11](loc1: bool)
B3:
32MoveLoc[11](loc1: bool)
33BrFalse(35)
B4:
34Branch(45)
B5:
35MoveLoc[1](Arg1: &mut BoostingVault)
36Pop
37MoveLoc[9](Arg9: &mut TxContext)
38Pop
39MoveLoc[8](Arg8: &Clock)
40Pop
41MoveLoc[2](Arg2: &mut UserArchive)
42Pop
43LdConst[7](u64: 7001)
44Abort
B6:
45MoveLoc[7](Arg7: vector<u8>)
46Call bcs::new(vector<u8>): BCS
47StLoc[14](loc4: BCS)
48MutBorrowLoc[14](loc4: BCS)
49Call bcs::peel_u8(&mut BCS): u8
50MutBorrowLoc[14](loc4: BCS)
51Call bcs::peel_address(&mut BCS): address
52MutBorrowLoc[14](loc4: BCS)
53Call bcs::peel_u64(&mut BCS): u64
54MutBorrowLoc[14](loc4: BCS)
55Call bcs::peel_u64(&mut BCS): u64
56MutBorrowLoc[14](loc4: BCS)
57Call bcs::peel_u64(&mut BCS): u64
58MutBorrowLoc[14](loc4: BCS)
59Call bcs::peel_vec_u8(&mut BCS): vector<u8>
60MutBorrowLoc[14](loc4: BCS)
61Call bcs::peel_u64(&mut BCS): u64
62MutBorrowLoc[14](loc4: BCS)
63Call bcs::peel_u128(&mut BCS): u128
64StLoc[21](loc11: u128)
65StLoc[19](loc9: u64)
66StLoc[26](loc16: vector<u8>)
67StLoc[24](loc14: u64)
68StLoc[25](loc15: u64)
69StLoc[15](loc5: u64)
70StLoc[16](loc6: address)
71StLoc[28](loc18: u8)
72CopyLoc[23](loc13: address)
73CopyLoc[16](loc6: address)
74Eq
75BrFalse(77)
B7:
76Branch(87)
B8:
77MoveLoc[1](Arg1: &mut BoostingVault)
78Pop
79MoveLoc[9](Arg9: &mut TxContext)
80Pop
81MoveLoc[8](Arg8: &Clock)
82Pop
83MoveLoc[2](Arg2: &mut UserArchive)
84Pop
85LdConst[6](u64: 7000)
86Abort
B9:
87CopyLoc[3](Arg3: u64)
88LdU64(0)
89Gt
90BrFalse(96)
B10:
91MoveLoc[15](loc5: u64)
92CopyLoc[3](Arg3: u64)
93Eq
94StLoc[12](loc2: bool)
95Branch(98)
B11:
96LdFalse
97StLoc[12](loc2: bool)
B12:
98MoveLoc[12](loc2: bool)
99BrFalse(101)
B13:
100Branch(111)
B14:
101MoveLoc[1](Arg1: &mut BoostingVault)
102Pop
103MoveLoc[9](Arg9: &mut TxContext)
104Pop
105MoveLoc[8](Arg8: &Clock)
106Pop
107MoveLoc[2](Arg2: &mut UserArchive)
108Pop
109LdConst[8](u64: 7002)
110Abort
B15:
111MoveLoc[25](loc15: u64)
112CopyLoc[4](Arg4: u64)
113Eq
114BrFalse(120)
B16:
115MoveLoc[24](loc14: u64)
116CopyLoc[5](Arg5: u64)
117Eq
118StLoc[13](loc3: bool)
119Branch(122)
B17:
120LdFalse
121StLoc[13](loc3: bool)
B18:
122MoveLoc[13](loc3: bool)
123BrFalse(125)
B19:
124Branch(135)
B20:
125MoveLoc[1](Arg1: &mut BoostingVault)
126Pop
127MoveLoc[9](Arg9: &mut TxContext)
128Pop
129MoveLoc[8](Arg8: &Clock)
130Pop
131MoveLoc[2](Arg2: &mut UserArchive)
132Pop
133LdConst[7](u64: 7001)
134Abort
B21:
135Call type_name::get<Ty0>(): TypeName
136Call type_name::into_string(TypeName): String
137Call string::from_ascii(String): String
138StLoc[18](loc8: String)
139MoveLoc[26](loc16: vector<u8>)
140Call string::utf8(vector<u8>): String
141StLoc[27](loc17: String)
142MoveLoc[18](loc8: String)
143MoveLoc[27](loc17: String)
144Eq
145BrFalse(147)
B22:
146Branch(157)
B23:
147MoveLoc[1](Arg1: &mut BoostingVault)
148Pop
149MoveLoc[9](Arg9: &mut TxContext)
150Pop
151MoveLoc[8](Arg8: &Clock)
152Pop
153MoveLoc[2](Arg2: &mut UserArchive)
154Pop
155LdConst[11](u64: 7005)
156Abort
B24:
157CopyLoc[22](loc12: u64)
158MoveLoc[19](loc9: u64)
159Lt
160BrFalse(162)
B25:
161Branch(172)
B26:
162MoveLoc[1](Arg1: &mut BoostingVault)
163Pop
164MoveLoc[9](Arg9: &mut TxContext)
165Pop
166MoveLoc[8](Arg8: &Clock)
167Pop
168MoveLoc[2](Arg2: &mut UserArchive)
169Pop
170LdConst[10](u64: 7004)
171Abort
B27:
172CopyLoc[2](Arg2: &mut UserArchive)
173LdConst[1](vector<u8>: "BOO..)
174CopyLoc[28](loc18: u8)
175CopyLoc[4](Arg4: u64)
176CopyLoc[5](Arg5: u64)
177Call guild::update_claim_commission_time_range(&mut UserArchive, vector<u8>, u8, u64, u64)
178CopyLoc[2](Arg2: &mut UserArchive)
179CopyLoc[28](loc18: u8)
180MoveLoc[21](loc11: u128)
181Call guild::update_user_nonce(&mut UserArchive, u8, u128): u128
182StLoc[20](loc10: u128)
183MoveLoc[2](Arg2: &mut UserArchive)
184MoveLoc[22](loc12: u64)
185Call guild::set_archive_last_name_time(&mut UserArchive, u64)
186MoveLoc[1](Arg1: &mut BoostingVault)
187CopyLoc[3](Arg3: u64)
188MoveLoc[8](Arg8: &Clock)
189MoveLoc[9](Arg9: &mut TxContext)
190Call withdraw_from_vault<Ty0>(&mut BoostingVault, u64, &Clock, &mut TxContext): Coin<Ty0>
191StLoc[17](loc7: Coin<Ty0>)
192MoveLoc[23](loc13: address)
193MoveLoc[28](loc18: u8)
194MoveLoc[3](Arg3: u64)
195MoveLoc[4](Arg4: u64)
196MoveLoc[5](Arg5: u64)
197MoveLoc[20](loc10: u128)
198Pack[26](CommissionClaimEventV2)
199Call event::emit<CommissionClaimEventV2>(CommissionClaimEventV2)
200MoveLoc[17](loc7: Coin<Ty0>)
201MoveLoc[16](loc6: address)
202Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
203Ret
}
public claim_bonus<Ty0>(Arg0: &Config, Arg1: &mut BoostingVault, Arg2: &mut UserArchive, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: vector<u8>, Arg7: vector<u8>, Arg8: &Clock, Arg9: &mut TxContext) {
B0:
0LdConst[19](u64: 7013)
1Abort
}
deposit_to_vault<Ty0>(Arg0: &mut BoostingVault, Arg1: Balance<Ty0>, Arg2: &Clock) {
L3: loc0: TypeName
L4: loc1: u64
L5: loc2: u64
L6: loc3: &mut Balance<Ty0>
L7: loc4: ID
B0:
0CopyLoc[0](Arg0: &mut BoostingVault)
1FreezeRef
2Call object::id<BoostingVault>(&BoostingVault): ID
3StLoc[7](loc4: ID)
4Call type_name::get<Ty0>(): TypeName
5StLoc[3](loc0: TypeName)
6ImmBorrowLoc[1](Arg1: Balance<Ty0>)
7Call balance::value<Ty0>(&Balance<Ty0>): u64
8StLoc[4](loc1: u64)
9CopyLoc[0](Arg0: &mut BoostingVault)
10ImmBorrowField[0](BoostingVault.balances: Bag)
11CopyLoc[3](loc0: TypeName)
12Call bag::contains<TypeName>(&Bag, TypeName): bool
13Not
14BrFalse(20)
B1:
15CopyLoc[0](Arg0: &mut BoostingVault)
16MutBorrowField[0](BoostingVault.balances: Bag)
17CopyLoc[3](loc0: TypeName)
18Call balance::zero<Ty0>(): Balance<Ty0>
19Call bag::add<TypeName, Balance<Ty0>>(&mut Bag, TypeName, Balance<Ty0>)
B2:
20CopyLoc[0](Arg0: &mut BoostingVault)
21MutBorrowField[0](BoostingVault.balances: Bag)
22CopyLoc[3](loc0: TypeName)
23Call bag::borrow_mut<TypeName, Balance<Ty0>>(&mut Bag, TypeName): &mut Balance<Ty0>
24StLoc[6](loc3: &mut Balance<Ty0>)
25CopyLoc[6](loc3: &mut Balance<Ty0>)
26MoveLoc[1](Arg1: Balance<Ty0>)
27Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
28Pop
29MoveLoc[6](loc3: &mut Balance<Ty0>)
30FreezeRef
31Call balance::value<Ty0>(&Balance<Ty0>): u64
32StLoc[5](loc2: u64)
33MoveLoc[0](Arg0: &mut BoostingVault)
34CopyLoc[3](loc0: TypeName)
35CopyLoc[4](loc1: u64)
36LdU64(0)
37MoveLoc[2](Arg2: &Clock)
38Call update_vault_token_stat(&mut BoostingVault, TypeName, u64, u64, &Clock)
39MoveLoc[7](loc4: ID)
40MoveLoc[3](loc0: TypeName)
41MoveLoc[4](loc1: u64)
42MoveLoc[5](loc2: u64)
43Pack[5](VaultDepositEvent)
44Call event::emit<VaultDepositEvent>(VaultDepositEvent)
45Ret
}
withdraw_from_vault<Ty0>(Arg0: &mut BoostingVault, Arg1: u64, Arg2: &Clock, Arg3: &mut TxContext): Coin<Ty0> {
L4: loc0: TypeName
L5: loc1: u64
L6: loc2: Balance<Ty0>
L7: loc3: &mut Balance<Ty0>
L8: loc4: ID
B0:
0CopyLoc[0](Arg0: &mut BoostingVault)
1FreezeRef
2Call object::id<BoostingVault>(&BoostingVault): ID
3StLoc[8](loc4: ID)
4Call type_name::get<Ty0>(): TypeName
5StLoc[4](loc0: TypeName)
6CopyLoc[0](Arg0: &mut BoostingVault)
7ImmBorrowField[0](BoostingVault.balances: Bag)
8CopyLoc[4](loc0: TypeName)
9Call bag::contains<TypeName>(&Bag, TypeName): bool
10BrFalse(12)
B1:
11Branch(20)
B2:
12MoveLoc[0](Arg0: &mut BoostingVault)
13Pop
14MoveLoc[3](Arg3: &mut TxContext)
15Pop
16MoveLoc[2](Arg2: &Clock)
17Pop
18LdConst[16](u64: 7010)
19Abort
B3:
20CopyLoc[0](Arg0: &mut BoostingVault)
21MutBorrowField[0](BoostingVault.balances: Bag)
22CopyLoc[4](loc0: TypeName)
23Call bag::borrow_mut<TypeName, Balance<Ty0>>(&mut Bag, TypeName): &mut Balance<Ty0>
24StLoc[7](loc3: &mut Balance<Ty0>)
25CopyLoc[7](loc3: &mut Balance<Ty0>)
26FreezeRef
27Call balance::value<Ty0>(&Balance<Ty0>): u64
28CopyLoc[1](Arg1: u64)
29Ge
30BrFalse(32)
B4:
31Branch(42)
B5:
32MoveLoc[7](loc3: &mut Balance<Ty0>)
33Pop
34MoveLoc[0](Arg0: &mut BoostingVault)
35Pop
36MoveLoc[3](Arg3: &mut TxContext)
37Pop
38MoveLoc[2](Arg2: &Clock)
39Pop
40LdConst[17](u64: 7011)
41Abort
B6:
42CopyLoc[7](loc3: &mut Balance<Ty0>)
43CopyLoc[1](Arg1: u64)
44Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
45StLoc[6](loc2: Balance<Ty0>)
46MoveLoc[7](loc3: &mut Balance<Ty0>)
47FreezeRef
48Call balance::value<Ty0>(&Balance<Ty0>): u64
49StLoc[5](loc1: u64)
50MoveLoc[0](Arg0: &mut BoostingVault)
51CopyLoc[4](loc0: TypeName)
52LdU64(0)
53CopyLoc[1](Arg1: u64)
54MoveLoc[2](Arg2: &Clock)
55Call update_vault_token_stat(&mut BoostingVault, TypeName, u64, u64, &Clock)
56MoveLoc[8](loc4: ID)
57MoveLoc[4](loc0: TypeName)
58MoveLoc[1](Arg1: u64)
59MoveLoc[5](loc1: u64)
60Pack[6](VaultWithdrawEvent)
61Call event::emit<VaultWithdrawEvent>(VaultWithdrawEvent)
62MoveLoc[6](loc2: Balance<Ty0>)
63MoveLoc[3](Arg3: &mut TxContext)
64Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
65Ret
}
update_vault_token_stat(Arg0: &mut BoostingVault, Arg1: TypeName, Arg2: u64, Arg3: u64, Arg4: &Clock) {
L5: loc0: u64
L6: loc1: u64
L7: loc2: u64
L8: loc3: &mut TokenStat
L9: loc4: &mut vector<TokenStat>
B0:
0MoveLoc[0](Arg0: &mut BoostingVault)
1MutBorrowField[1](BoostingVault.tokens_stat: vector<TokenStat>)
2StLoc[9](loc4: &mut vector<TokenStat>)
3CopyLoc[9](loc4: &mut vector<TokenStat>)
4FreezeRef
5VecLen(37)
6StLoc[6](loc1: u64)
7LdU64(0)
8StLoc[5](loc0: u64)
9MoveLoc[4](Arg4: &Clock)
10Call clock::timestamp_ms(&Clock): u64
11StLoc[7](loc2: u64)
B1:
12CopyLoc[5](loc0: u64)
13CopyLoc[6](loc1: u64)
14Lt
15BrFalse(57)
B2:
16Branch(17)
B3:
17CopyLoc[9](loc4: &mut vector<TokenStat>)
18CopyLoc[5](loc0: u64)
19VecMutBorrow(37)
20StLoc[8](loc3: &mut TokenStat)
21CopyLoc[8](loc3: &mut TokenStat)
22ImmBorrowField[2](TokenStat.token_type: TypeName)
23ReadRef
24CopyLoc[1](Arg1: TypeName)
25Eq
26BrFalse(50)
B4:
27MoveLoc[9](loc4: &mut vector<TokenStat>)
28Pop
29CopyLoc[8](loc3: &mut TokenStat)
30ImmBorrowField[3](TokenStat.amount_in: u64)
31ReadRef
32MoveLoc[2](Arg2: u64)
33Add
34CopyLoc[8](loc3: &mut TokenStat)
35MutBorrowField[3](TokenStat.amount_in: u64)
36WriteRef
37CopyLoc[8](loc3: &mut TokenStat)
38ImmBorrowField[4](TokenStat.amount_out: u64)
39ReadRef
40MoveLoc[3](Arg3: u64)
41Add
42CopyLoc[8](loc3: &mut TokenStat)
43MutBorrowField[4](TokenStat.amount_out: u64)
44WriteRef
45MoveLoc[7](loc2: u64)
46MoveLoc[8](loc3: &mut TokenStat)
47MutBorrowField[5](TokenStat.last_updated: u64)
48WriteRef
49Ret
B5:
50MoveLoc[8](loc3: &mut TokenStat)
51Pop
52MoveLoc[5](loc0: u64)
53LdU64(1)
54Add
55StLoc[5](loc0: u64)
56Branch(12)
B6:
57MoveLoc[9](loc4: &mut vector<TokenStat>)
58MoveLoc[1](Arg1: TypeName)
59MoveLoc[2](Arg2: u64)
60MoveLoc[3](Arg3: u64)
61MoveLoc[7](loc2: u64)
62Pack[1](TokenStat)
63VecPushBack(37)
64Ret
}
public init_pre_subscribe<Ty0>(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut TxContext) {
L3: loc0: PreSubscribe
L4: loc1: VecSet<address>
L5: loc2: Table<u8, VecSet<address>>
L6: loc3: Table<u8, VecSet<address>>
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4Call vec_set::empty<address>(): VecSet<address>
5StLoc[4](loc1: VecSet<address>)
6CopyLoc[2](Arg2: &mut TxContext)
7Call table::new<u8, VecSet<address>>(&mut TxContext): Table<u8, VecSet<address>>
8StLoc[5](loc2: Table<u8, VecSet<address>>)
9MutBorrowLoc[5](loc2: Table<u8, VecSet<address>>)
10LdConst[4](u8: 0)
11Call vec_set::empty<address>(): VecSet<address>
12Call table::add<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8, VecSet<address>)
13MutBorrowLoc[5](loc2: Table<u8, VecSet<address>>)
14LdConst[5](u8: 1)
15Call vec_set::empty<address>(): VecSet<address>
16Call table::add<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8, VecSet<address>)
17CopyLoc[2](Arg2: &mut TxContext)
18Call table::new<u8, VecSet<address>>(&mut TxContext): Table<u8, VecSet<address>>
19StLoc[6](loc3: Table<u8, VecSet<address>>)
20MutBorrowLoc[6](loc3: Table<u8, VecSet<address>>)
21LdConst[4](u8: 0)
22Call vec_set::empty<address>(): VecSet<address>
23Call table::add<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8, VecSet<address>)
24MutBorrowLoc[6](loc3: Table<u8, VecSet<address>>)
25LdConst[5](u8: 1)
26Call vec_set::empty<address>(): VecSet<address>
27Call table::add<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8, VecSet<address>)
28CopyLoc[2](Arg2: &mut TxContext)
29Call object::new(&mut TxContext): UID
30LdTrue
31LdU64(0)
32LdConst[3](u64: 2592..)
33CopyLoc[2](Arg2: &mut TxContext)
34Call table::new<u8, u64>(&mut TxContext): Table<u8, u64>
35Call type_name::get<Ty0>(): TypeName
36MoveLoc[4](loc1: VecSet<address>)
37MoveLoc[5](loc2: Table<u8, VecSet<address>>)
38CopyLoc[2](Arg2: &mut TxContext)
39Call table::new<u8, u16>(&mut TxContext): Table<u8, u16>
40Call vec_set::empty<address>(): VecSet<address>
41MoveLoc[6](loc3: Table<u8, VecSet<address>>)
42MoveLoc[2](Arg2: &mut TxContext)
43Call table::new<address, u64>(&mut TxContext): Table<address, u64>
44LdFalse
45LdU64(0)
46LdU64(0)
47Pack[2](PreSubscribe)
48StLoc[3](loc0: PreSubscribe)
49ImmBorrowLoc[3](loc0: PreSubscribe)
50Call object::id<PreSubscribe>(&PreSubscribe): ID
51Pack[7](InitPreSubscribeEvent)
52Call event::emit<InitPreSubscribeEvent>(InitPreSubscribeEvent)
53MoveLoc[3](loc0: PreSubscribe)
54Call transfer::share_object<PreSubscribe>(PreSubscribe)
55Ret
}
public pause_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: bool) {
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[2](Arg2: &mut PreSubscribe)
5ImmBorrowField[6](PreSubscribe.paused: bool)
6ReadRef
7CopyLoc[3](Arg3: bool)
8Neq
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[2](Arg2: &mut PreSubscribe)
12Pop
13LdConst[7](u64: 7001)
14Abort
B3:
15CopyLoc[3](Arg3: bool)
16CopyLoc[2](Arg2: &mut PreSubscribe)
17MutBorrowField[6](PreSubscribe.paused: bool)
18WriteRef
19MoveLoc[2](Arg2: &mut PreSubscribe)
20FreezeRef
21Call object::id<PreSubscribe>(&PreSubscribe): ID
22MoveLoc[3](Arg3: bool)
23Pack[8](PausePreSubscribeEvent)
24Call event::emit<PausePreSubscribeEvent>(PausePreSubscribeEvent)
25Ret
}
public set_start_time_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: u64, Arg4: &Clock) {
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: &Clock)
6Call clock::timestamp_ms(&Clock): u64
7Ge
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[2](Arg2: &mut PreSubscribe)
11Pop
12LdConst[7](u64: 7001)
13Abort
B3:
14CopyLoc[3](Arg3: u64)
15CopyLoc[2](Arg2: &mut PreSubscribe)
16MutBorrowField[7](PreSubscribe.start_time: u64)
17WriteRef
18MoveLoc[2](Arg2: &mut PreSubscribe)
19FreezeRef
20Call object::id<PreSubscribe>(&PreSubscribe): ID
21MoveLoc[3](Arg3: u64)
22Pack[9](SetartTimePreSubscribeEvent)
23Call event::emit<SetartTimePreSubscribeEvent>(SetartTimePreSubscribeEvent)
24Ret
}
public set_duration_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: u64) {
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[3](Arg3: u64)
5LdU64(0)
6Ge
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[2](Arg2: &mut PreSubscribe)
10Pop
11LdConst[7](u64: 7001)
12Abort
B3:
13CopyLoc[3](Arg3: u64)
14CopyLoc[2](Arg2: &mut PreSubscribe)
15MutBorrowField[8](PreSubscribe.duration: u64)
16WriteRef
17MoveLoc[2](Arg2: &mut PreSubscribe)
18FreezeRef
19Call object::id<PreSubscribe>(&PreSubscribe): ID
20MoveLoc[3](Arg3: u64)
21Pack[10](SetDurationPreSubscribeEvent)
22Call event::emit<SetDurationPreSubscribeEvent>(SetDurationPreSubscribeEvent)
23Ret
}
public set_price_per_class_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: u8, Arg4: u64) {
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[4](Arg4: u64)
5LdU64(0)
6Gt
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[2](Arg2: &mut PreSubscribe)
10Pop
11LdConst[7](u64: 7001)
12Abort
B3:
13CopyLoc[2](Arg2: &mut PreSubscribe)
14ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
15CopyLoc[3](Arg3: u8)
16Call table::contains<u8, u64>(&Table<u8, u64>, u8): bool
17BrFalse(29)
B4:
18CopyLoc[2](Arg2: &mut PreSubscribe)
19MutBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
20CopyLoc[3](Arg3: u8)
21Call table::remove<u8, u64>(&mut Table<u8, u64>, u8): u64
22Pop
23CopyLoc[2](Arg2: &mut PreSubscribe)
24MutBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
25CopyLoc[3](Arg3: u8)
26CopyLoc[4](Arg4: u64)
27Call table::add<u8, u64>(&mut Table<u8, u64>, u8, u64)
28Branch(34)
B5:
29CopyLoc[2](Arg2: &mut PreSubscribe)
30MutBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
31CopyLoc[3](Arg3: u8)
32CopyLoc[4](Arg4: u64)
33Call table::add<u8, u64>(&mut Table<u8, u64>, u8, u64)
B6:
34MoveLoc[2](Arg2: &mut PreSubscribe)
35FreezeRef
36Call object::id<PreSubscribe>(&PreSubscribe): ID
37MoveLoc[3](Arg3: u8)
38MoveLoc[4](Arg4: u64)
39Pack[11](SetPricePerClassPreSubscribeEvent)
40Call event::emit<SetPricePerClassPreSubscribeEvent>(SetPricePerClassPreSubscribeEvent)
41Ret
}
public change_fee_type_pre_subscribe<Ty0>(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe) {
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4Call type_name::get<Ty0>(): TypeName
5CopyLoc[2](Arg2: &mut PreSubscribe)
6MutBorrowField[10](PreSubscribe.fee_type: TypeName)
7WriteRef
8CopyLoc[2](Arg2: &mut PreSubscribe)
9FreezeRef
10Call object::id<PreSubscribe>(&PreSubscribe): ID
11MoveLoc[2](Arg2: &mut PreSubscribe)
12ImmBorrowField[10](PreSubscribe.fee_type: TypeName)
13ReadRef
14Pack[12](SetFeeTypePreSubscribeEvent)
15Call event::emit<SetFeeTypePreSubscribeEvent>(SetFeeTypePreSubscribeEvent)
16Ret
}
public set_no_slots_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: u8, Arg4: u16) {
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[4](Arg4: u16)
5LdU16(0)
6Gt
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[2](Arg2: &mut PreSubscribe)
10Pop
11LdConst[7](u64: 7001)
12Abort
B3:
13CopyLoc[2](Arg2: &mut PreSubscribe)
14ImmBorrowField[11](PreSubscribe.no_slots: Table<u8, u16>)
15CopyLoc[3](Arg3: u8)
16Call table::contains<u8, u16>(&Table<u8, u16>, u8): bool
17BrFalse(29)
B4:
18CopyLoc[2](Arg2: &mut PreSubscribe)
19MutBorrowField[11](PreSubscribe.no_slots: Table<u8, u16>)
20CopyLoc[3](Arg3: u8)
21Call table::remove<u8, u16>(&mut Table<u8, u16>, u8): u16
22Pop
23CopyLoc[2](Arg2: &mut PreSubscribe)
24MutBorrowField[11](PreSubscribe.no_slots: Table<u8, u16>)
25CopyLoc[3](Arg3: u8)
26CopyLoc[4](Arg4: u16)
27Call table::add<u8, u16>(&mut Table<u8, u16>, u8, u16)
28Branch(34)
B5:
29CopyLoc[2](Arg2: &mut PreSubscribe)
30MutBorrowField[11](PreSubscribe.no_slots: Table<u8, u16>)
31CopyLoc[3](Arg3: u8)
32CopyLoc[4](Arg4: u16)
33Call table::add<u8, u16>(&mut Table<u8, u16>, u8, u16)
B6:
34MoveLoc[2](Arg2: &mut PreSubscribe)
35FreezeRef
36Call object::id<PreSubscribe>(&PreSubscribe): ID
37MoveLoc[3](Arg3: u8)
38MoveLoc[4](Arg4: u16)
39Pack[13](SetSlotsPreSubscribeEvent)
40Call event::emit<SetSlotsPreSubscribeEvent>(SetSlotsPreSubscribeEvent)
41Ret
}
public pre_subscribe<Ty0>(Arg0: &Config, Arg1: &mut PreSubscribe, Arg2: &mut BoostingVault, Arg3: u8, Arg4: Balance<Ty0>, Arg5: &Clock, Arg6: &mut TxContext) {
L7: loc0: bool
L8: loc1: &address
L9: loc2: &address
L10: loc3: bool
L11: loc4: bool
L12: loc5: &address
L13: loc6: u64
L14: loc7: u64
L15: loc8: &mut VecSet<address>
L16: loc9: &mut VecSet<address>
L17: loc10: &mut VecSet<address>
L18: loc11: u64
L19: loc12: u64
L20: loc13: &mut u64
L21: loc14: &mut u16
L22: loc15: address
B0:
0MoveLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[1](Arg1: &mut PreSubscribe)
5ImmBorrowField[6](PreSubscribe.paused: bool)
6ReadRef
7Not
8BrFalse(10)
B1:
9Branch(20)
B2:
10MoveLoc[2](Arg2: &mut BoostingVault)
11Pop
12MoveLoc[1](Arg1: &mut PreSubscribe)
13Pop
14MoveLoc[6](Arg6: &mut TxContext)
15Pop
16MoveLoc[5](Arg5: &Clock)
17Pop
18LdConst[12](u64: 7006)
19Abort
B3:
20CopyLoc[5](Arg5: &Clock)
21Call clock::timestamp_ms(&Clock): u64
22StLoc[14](loc7: u64)
23CopyLoc[14](loc7: u64)
24CopyLoc[1](Arg1: &mut PreSubscribe)
25ImmBorrowField[7](PreSubscribe.start_time: u64)
26ReadRef
27Ge
28BrFalse(40)
B4:
29MoveLoc[14](loc7: u64)
30CopyLoc[1](Arg1: &mut PreSubscribe)
31ImmBorrowField[7](PreSubscribe.start_time: u64)
32ReadRef
33CopyLoc[1](Arg1: &mut PreSubscribe)
34ImmBorrowField[8](PreSubscribe.duration: u64)
35ReadRef
36Add
37Le
38StLoc[7](loc0: bool)
39Branch(42)
B5:
40LdFalse
41StLoc[7](loc0: bool)
B6:
42MoveLoc[7](loc0: bool)
43BrFalse(45)
B7:
44Branch(55)
B8:
45MoveLoc[2](Arg2: &mut BoostingVault)
46Pop
47MoveLoc[1](Arg1: &mut PreSubscribe)
48Pop
49MoveLoc[6](Arg6: &mut TxContext)
50Pop
51MoveLoc[5](Arg5: &Clock)
52Pop
53LdConst[14](u64: 7008)
54Abort
B9:
55CopyLoc[3](Arg3: u8)
56LdConst[4](u8: 0)
57Eq
58BrFalse(62)
B10:
59LdTrue
60StLoc[10](loc3: bool)
61Branch(66)
B11:
62CopyLoc[3](Arg3: u8)
63LdConst[5](u8: 1)
64Eq
65StLoc[10](loc3: bool)
B12:
66MoveLoc[10](loc3: bool)
67BrFalse(69)
B13:
68Branch(79)
B14:
69MoveLoc[2](Arg2: &mut BoostingVault)
70Pop
71MoveLoc[1](Arg1: &mut PreSubscribe)
72Pop
73MoveLoc[6](Arg6: &mut TxContext)
74Pop
75MoveLoc[5](Arg5: &Clock)
76Pop
77LdConst[7](u64: 7001)
78Abort
B15:
79CopyLoc[6](Arg6: &mut TxContext)
80FreezeRef
81Call tx_context::sender(&TxContext): address
82StLoc[22](loc15: address)
83CopyLoc[1](Arg1: &mut PreSubscribe)
84ImmBorrowField[11](PreSubscribe.no_slots: Table<u8, u16>)
85CopyLoc[3](Arg3: u8)
86Call table::contains<u8, u16>(&Table<u8, u16>, u8): bool
87BrFalse(94)
B16:
88CopyLoc[1](Arg1: &mut PreSubscribe)
89ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
90CopyLoc[3](Arg3: u8)
91Call table::contains<u8, u64>(&Table<u8, u64>, u8): bool
92StLoc[11](loc4: bool)
93Branch(96)
B17:
94LdFalse
95StLoc[11](loc4: bool)
B18:
96MoveLoc[11](loc4: bool)
97BrFalse(99)
B19:
98Branch(109)
B20:
99MoveLoc[2](Arg2: &mut BoostingVault)
100Pop
101MoveLoc[1](Arg1: &mut PreSubscribe)
102Pop
103MoveLoc[6](Arg6: &mut TxContext)
104Pop
105MoveLoc[5](Arg5: &Clock)
106Pop
107LdConst[7](u64: 7001)
108Abort
B21:
109CopyLoc[1](Arg1: &mut PreSubscribe)
110MutBorrowField[11](PreSubscribe.no_slots: Table<u8, u16>)
111CopyLoc[3](Arg3: u8)
112Call table::borrow_mut<u8, u16>(&mut Table<u8, u16>, u8): &mut u16
113CopyLoc[1](Arg1: &mut PreSubscribe)
114ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
115CopyLoc[3](Arg3: u8)
116Call table::borrow<u8, u64>(&Table<u8, u64>, u8): &u64
117ReadRef
118StLoc[18](loc11: u64)
119StLoc[21](loc14: &mut u16)
120ImmBorrowLoc[4](Arg4: Balance<Ty0>)
121Call balance::value<Ty0>(&Balance<Ty0>): u64
122StLoc[13](loc6: u64)
123CopyLoc[1](Arg1: &mut PreSubscribe)
124ImmBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
125ImmBorrowLoc[22](loc15: address)
126Call vec_set::contains<address>(&VecSet<address>, &address): bool
127BrFalse(290)
B22:
128CopyLoc[3](Arg3: u8)
129LdConst[5](u8: 1)
130Eq
131BrFalse(277)
B23:
132CopyLoc[1](Arg1: &mut PreSubscribe)
133MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
134LdConst[4](u8: 0)
135Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
136StLoc[16](loc9: &mut VecSet<address>)
137CopyLoc[16](loc9: &mut VecSet<address>)
138ImmBorrowLoc[22](loc15: address)
139StLoc[12](loc5: &address)
140FreezeRef
141MoveLoc[12](loc5: &address)
142Call vec_set::contains<address>(&VecSet<address>, &address): bool
143Not
144BrFalse(159)
B24:
145MoveLoc[2](Arg2: &mut BoostingVault)
146Pop
147MoveLoc[21](loc14: &mut u16)
148Pop
149MoveLoc[16](loc9: &mut VecSet<address>)
150Pop
151MoveLoc[1](Arg1: &mut PreSubscribe)
152Pop
153MoveLoc[6](Arg6: &mut TxContext)
154Pop
155MoveLoc[5](Arg5: &Clock)
156Pop
157LdConst[15](u64: 7009)
158Abort
B25:
159MoveLoc[16](loc9: &mut VecSet<address>)
160ImmBorrowLoc[22](loc15: address)
161Call vec_set::remove<address>(&mut VecSet<address>, &address)
162CopyLoc[1](Arg1: &mut PreSubscribe)
163ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
164LdConst[4](u8: 0)
165Call table::contains<u8, u64>(&Table<u8, u64>, u8): bool
166BrFalse(168)
B26:
167Branch(180)
B27:
168MoveLoc[2](Arg2: &mut BoostingVault)
169Pop
170MoveLoc[21](loc14: &mut u16)
171Pop
172MoveLoc[1](Arg1: &mut PreSubscribe)
173Pop
174MoveLoc[6](Arg6: &mut TxContext)
175Pop
176MoveLoc[5](Arg5: &Clock)
177Pop
178LdConst[7](u64: 7001)
179Abort
B28:
180CopyLoc[1](Arg1: &mut PreSubscribe)
181ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
182LdConst[4](u8: 0)
183Call table::borrow<u8, u64>(&Table<u8, u64>, u8): &u64
184ReadRef
185StLoc[19](loc12: u64)
186CopyLoc[13](loc6: u64)
187CopyLoc[18](loc11: u64)
188CopyLoc[19](loc12: u64)
189Sub
190Eq
191BrFalse(193)
B29:
192Branch(205)
B30:
193MoveLoc[2](Arg2: &mut BoostingVault)
194Pop
195MoveLoc[21](loc14: &mut u16)
196Pop
197MoveLoc[1](Arg1: &mut PreSubscribe)
198Pop
199MoveLoc[6](Arg6: &mut TxContext)
200Pop
201MoveLoc[5](Arg5: &Clock)
202Pop
203LdConst[8](u64: 7002)
204Abort
B31:
205CopyLoc[1](Arg1: &mut PreSubscribe)
206MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
207LdConst[5](u8: 1)
208Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
209StLoc[15](loc8: &mut VecSet<address>)
210CopyLoc[15](loc8: &mut VecSet<address>)
211ImmBorrowLoc[22](loc15: address)
212StLoc[8](loc1: &address)
213FreezeRef
214MoveLoc[8](loc1: &address)
215Call vec_set::contains<address>(&VecSet<address>, &address): bool
216Not
217BrFalse(219)
B32:
218Branch(233)
B33:
219MoveLoc[2](Arg2: &mut BoostingVault)
220Pop
221MoveLoc[21](loc14: &mut u16)
222Pop
223MoveLoc[15](loc8: &mut VecSet<address>)
224Pop
225MoveLoc[1](Arg1: &mut PreSubscribe)
226Pop
227MoveLoc[6](Arg6: &mut TxContext)
228Pop
229MoveLoc[5](Arg5: &Clock)
230Pop
231LdConst[15](u64: 7009)
232Abort
B34:
233MoveLoc[15](loc8: &mut VecSet<address>)
234CopyLoc[22](loc15: address)
235Call vec_set::insert<address>(&mut VecSet<address>, address)
236CopyLoc[1](Arg1: &mut PreSubscribe)
237MutBorrowField[14](PreSubscribe.whitelisted: Table<u8, VecSet<address>>)
238LdConst[4](u8: 0)
239Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
240StLoc[17](loc10: &mut VecSet<address>)
241CopyLoc[17](loc10: &mut VecSet<address>)
242ImmBorrowLoc[22](loc15: address)
243StLoc[9](loc2: &address)
244FreezeRef
245MoveLoc[9](loc2: &address)
246Call vec_set::contains<address>(&VecSet<address>, &address): bool
247BrFalse(252)
B35:
248MoveLoc[17](loc10: &mut VecSet<address>)
249ImmBorrowLoc[22](loc15: address)
250Call vec_set::remove<address>(&mut VecSet<address>, &address)
251Branch(254)
B36:
252MoveLoc[17](loc10: &mut VecSet<address>)
253Pop
B37:
254CopyLoc[1](Arg1: &mut PreSubscribe)
255ImmBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
256CopyLoc[22](loc15: address)
257Call table::contains<address, u64>(&Table<address, u64>, address): bool
258Not
259BrFalse(268)
B38:
260CopyLoc[1](Arg1: &mut PreSubscribe)
261MutBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
262MoveLoc[22](loc15: address)
263MoveLoc[18](loc11: u64)
264MoveLoc[19](loc12: u64)
265Sub
266Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
267Branch(289)
B39:
268CopyLoc[1](Arg1: &mut PreSubscribe)
269MutBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
270MoveLoc[22](loc15: address)
271Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64
272StLoc[20](loc13: &mut u64)
273MoveLoc[19](loc12: u64)
274MoveLoc[20](loc13: &mut u64)
275WriteRef
276Branch(289)
B40:
277MoveLoc[2](Arg2: &mut BoostingVault)
278Pop
279MoveLoc[21](loc14: &mut u16)
280Pop
281MoveLoc[1](Arg1: &mut PreSubscribe)
282Pop
283MoveLoc[6](Arg6: &mut TxContext)
284Pop
285MoveLoc[5](Arg5: &Clock)
286Pop
287LdConst[15](u64: 7009)
288Abort
B41:
289Branch(328)
B42:
290CopyLoc[13](loc6: u64)
291CopyLoc[18](loc11: u64)
292Eq
293BrFalse(295)
B43:
294Branch(307)
B44:
295MoveLoc[2](Arg2: &mut BoostingVault)
296Pop
297MoveLoc[21](loc14: &mut u16)
298Pop
299MoveLoc[1](Arg1: &mut PreSubscribe)
300Pop
301MoveLoc[6](Arg6: &mut TxContext)
302Pop
303MoveLoc[5](Arg5: &Clock)
304Pop
305LdConst[8](u64: 7002)
306Abort
B45:
307CopyLoc[1](Arg1: &mut PreSubscribe)
308MutBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
309CopyLoc[22](loc15: address)
310Call vec_set::insert<address>(&mut VecSet<address>, address)
311CopyLoc[1](Arg1: &mut PreSubscribe)
312MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
313CopyLoc[3](Arg3: u8)
314Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
315CopyLoc[22](loc15: address)
316Call vec_set::insert<address>(&mut VecSet<address>, address)
317CopyLoc[1](Arg1: &mut PreSubscribe)
318ImmBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
319CopyLoc[22](loc15: address)
320Call table::contains<address, u64>(&Table<address, u64>, address): bool
321Not
322BrFalse(328)
B46:
323CopyLoc[1](Arg1: &mut PreSubscribe)
324MutBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
325MoveLoc[22](loc15: address)
326MoveLoc[18](loc11: u64)
327Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
B47:
328CopyLoc[21](loc14: &mut u16)
329ReadRef
330LdU16(0)
331Gt
332BrFalse(334)
B48:
333Branch(346)
B49:
334MoveLoc[2](Arg2: &mut BoostingVault)
335Pop
336MoveLoc[21](loc14: &mut u16)
337Pop
338MoveLoc[1](Arg1: &mut PreSubscribe)
339Pop
340MoveLoc[6](Arg6: &mut TxContext)
341Pop
342MoveLoc[5](Arg5: &Clock)
343Pop
344LdConst[13](u64: 7007)
345Abort
B50:
346CopyLoc[21](loc14: &mut u16)
347ReadRef
348LdU16(1)
349Sub
350MoveLoc[21](loc14: &mut u16)
351WriteRef
352MoveLoc[1](Arg1: &mut PreSubscribe)
353ImmBorrowField[10](PreSubscribe.fee_type: TypeName)
354ReadRef
355Call type_name::get<Ty0>(): TypeName
356Eq
357BrFalse(359)
B51:
358Branch(367)
B52:
359MoveLoc[2](Arg2: &mut BoostingVault)
360Pop
361MoveLoc[6](Arg6: &mut TxContext)
362Pop
363MoveLoc[5](Arg5: &Clock)
364Pop
365LdConst[11](u64: 7005)
366Abort
B53:
367MoveLoc[2](Arg2: &mut BoostingVault)
368MoveLoc[4](Arg4: Balance<Ty0>)
369MoveLoc[5](Arg5: &Clock)
370Call deposit_to_vault<Ty0>(&mut BoostingVault, Balance<Ty0>, &Clock)
371MoveLoc[6](Arg6: &mut TxContext)
372FreezeRef
373Call tx_context::sender(&TxContext): address
374MoveLoc[3](Arg3: u8)
375MoveLoc[13](loc6: u64)
376Pack[21](PreSubscribeEvent)
377Call event::emit<PreSubscribeEvent>(PreSubscribeEvent)
378Ret
}
public add_whitelist_manager_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: vector<address>) {
L4: loc0: u64
L5: loc1: address
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4LdU64(0)
5StLoc[4](loc0: u64)
B1:
6CopyLoc[4](loc0: u64)
7ImmBorrowLoc[3](Arg3: vector<address>)
8VecLen(36)
9Lt
10BrFalse(32)
B2:
11Branch(12)
B3:
12ImmBorrowLoc[3](Arg3: vector<address>)
13CopyLoc[4](loc0: u64)
14VecImmBorrow(36)
15ReadRef
16StLoc[5](loc1: address)
17CopyLoc[2](Arg2: &mut PreSubscribe)
18ImmBorrowField[16](PreSubscribe.wl_manager: VecSet<address>)
19ImmBorrowLoc[5](loc1: address)
20Call vec_set::contains<address>(&VecSet<address>, &address): bool
21Not
22BrFalse(27)
B4:
23CopyLoc[2](Arg2: &mut PreSubscribe)
24MutBorrowField[16](PreSubscribe.wl_manager: VecSet<address>)
25MoveLoc[5](loc1: address)
26Call vec_set::insert<address>(&mut VecSet<address>, address)
B5:
27MoveLoc[4](loc0: u64)
28LdU64(1)
29Add
30StLoc[4](loc0: u64)
31Branch(6)
B6:
32MoveLoc[2](Arg2: &mut PreSubscribe)
33FreezeRef
34Call object::id<PreSubscribe>(&PreSubscribe): ID
35MoveLoc[3](Arg3: vector<address>)
36Pack[14](AddWLManagerEvent)
37Call event::emit<AddWLManagerEvent>(AddWLManagerEvent)
38Ret
}
public remove_whitelist_manager_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: vector<address>) {
L4: loc0: u64
L5: loc1: u64
L6: loc2: address
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4LdU64(0)
5StLoc[4](loc0: u64)
6ImmBorrowLoc[3](Arg3: vector<address>)
7VecLen(36)
8StLoc[5](loc1: u64)
B1:
9CopyLoc[4](loc0: u64)
10CopyLoc[5](loc1: u64)
11Lt
12BrFalse(33)
B2:
13Branch(14)
B3:
14ImmBorrowLoc[3](Arg3: vector<address>)
15CopyLoc[4](loc0: u64)
16VecImmBorrow(36)
17ReadRef
18StLoc[6](loc2: address)
19CopyLoc[2](Arg2: &mut PreSubscribe)
20ImmBorrowField[16](PreSubscribe.wl_manager: VecSet<address>)
21ImmBorrowLoc[6](loc2: address)
22Call vec_set::contains<address>(&VecSet<address>, &address): bool
23BrFalse(28)
B4:
24CopyLoc[2](Arg2: &mut PreSubscribe)
25MutBorrowField[16](PreSubscribe.wl_manager: VecSet<address>)
26ImmBorrowLoc[6](loc2: address)
27Call vec_set::remove<address>(&mut VecSet<address>, &address)
B5:
28MoveLoc[4](loc0: u64)
29LdU64(1)
30Add
31StLoc[4](loc0: u64)
32Branch(9)
B6:
33MoveLoc[2](Arg2: &mut PreSubscribe)
34FreezeRef
35Call object::id<PreSubscribe>(&PreSubscribe): ID
36MoveLoc[3](Arg3: vector<address>)
37Pack[15](RemoveWLManagerEvent)
38Call event::emit<RemoveWLManagerEvent>(RemoveWLManagerEvent)
39Ret
}
public add_whitelist_pre_subscribe(Arg0: &Config, Arg1: &mut PreSubscribe, Arg2: u8, Arg3: vector<address>, Arg4: &mut TxContext) {
L5: loc0: &address
L6: loc1: &address
L7: loc2: u64
L8: loc3: address
L9: loc4: &mut VecSet<address>
L10: loc5: address
L11: loc6: &mut VecSet<address>
B0:
0MoveLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4MoveLoc[4](Arg4: &mut TxContext)
5FreezeRef
6Call tx_context::sender(&TxContext): address
7StLoc[8](loc3: address)
8CopyLoc[1](Arg1: &mut PreSubscribe)
9ImmBorrowField[16](PreSubscribe.wl_manager: VecSet<address>)
10ImmBorrowLoc[8](loc3: address)
11Call vec_set::contains<address>(&VecSet<address>, &address): bool
12BrFalse(14)
B1:
13Branch(18)
B2:
14MoveLoc[1](Arg1: &mut PreSubscribe)
15Pop
16LdConst[9](u64: 7003)
17Abort
B3:
18CopyLoc[1](Arg1: &mut PreSubscribe)
19MutBorrowField[14](PreSubscribe.whitelisted: Table<u8, VecSet<address>>)
20CopyLoc[2](Arg2: u8)
21Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
22StLoc[11](loc6: &mut VecSet<address>)
23CopyLoc[1](Arg1: &mut PreSubscribe)
24MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
25CopyLoc[2](Arg2: u8)
26Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
27StLoc[9](loc4: &mut VecSet<address>)
28LdU64(0)
29StLoc[7](loc2: u64)
B4:
30CopyLoc[7](loc2: u64)
31ImmBorrowLoc[3](Arg3: vector<address>)
32VecLen(36)
33Lt
34BrFalse(78)
B5:
35Branch(36)
B6:
36ImmBorrowLoc[3](Arg3: vector<address>)
37CopyLoc[7](loc2: u64)
38VecImmBorrow(36)
39ReadRef
40StLoc[10](loc5: address)
41CopyLoc[11](loc6: &mut VecSet<address>)
42ImmBorrowLoc[10](loc5: address)
43StLoc[5](loc0: &address)
44FreezeRef
45MoveLoc[5](loc0: &address)
46Call vec_set::contains<address>(&VecSet<address>, &address): bool
47Not
48BrFalse(52)
B7:
49CopyLoc[11](loc6: &mut VecSet<address>)
50CopyLoc[10](loc5: address)
51Call vec_set::insert<address>(&mut VecSet<address>, address)
B8:
52CopyLoc[1](Arg1: &mut PreSubscribe)
53ImmBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
54ImmBorrowLoc[10](loc5: address)
55Call vec_set::contains<address>(&VecSet<address>, &address): bool
56Not
57BrFalse(62)
B9:
58CopyLoc[1](Arg1: &mut PreSubscribe)
59MutBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
60CopyLoc[10](loc5: address)
61Call vec_set::insert<address>(&mut VecSet<address>, address)
B10:
62CopyLoc[9](loc4: &mut VecSet<address>)
63ImmBorrowLoc[10](loc5: address)
64StLoc[6](loc1: &address)
65FreezeRef
66MoveLoc[6](loc1: &address)
67Call vec_set::contains<address>(&VecSet<address>, &address): bool
68Not
69BrFalse(73)
B11:
70CopyLoc[9](loc4: &mut VecSet<address>)
71MoveLoc[10](loc5: address)
72Call vec_set::insert<address>(&mut VecSet<address>, address)
B12:
73MoveLoc[7](loc2: u64)
74LdU64(1)
75Add
76StLoc[7](loc2: u64)
77Branch(30)
B13:
78MoveLoc[11](loc6: &mut VecSet<address>)
79Pop
80MoveLoc[9](loc4: &mut VecSet<address>)
81Pop
82MoveLoc[1](Arg1: &mut PreSubscribe)
83FreezeRef
84Call object::id<PreSubscribe>(&PreSubscribe): ID
85MoveLoc[2](Arg2: u8)
86MoveLoc[3](Arg3: vector<address>)
87Pack[16](AddWhitelistEvent)
88Call event::emit<AddWhitelistEvent>(AddWhitelistEvent)
89Ret
}
public remove_whitelist_pre_subscribe(Arg0: &Config, Arg1: &mut PreSubscribe, Arg2: u8, Arg3: vector<address>, Arg4: &mut TxContext) {
L5: loc0: &address
L6: loc1: u64
L7: loc2: u64
L8: loc3: address
L9: loc4: address
L10: loc5: &mut VecSet<address>
B0:
0MoveLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4MoveLoc[4](Arg4: &mut TxContext)
5FreezeRef
6Call tx_context::sender(&TxContext): address
7StLoc[8](loc3: address)
8CopyLoc[1](Arg1: &mut PreSubscribe)
9ImmBorrowField[16](PreSubscribe.wl_manager: VecSet<address>)
10ImmBorrowLoc[8](loc3: address)
11Call vec_set::contains<address>(&VecSet<address>, &address): bool
12BrFalse(14)
B1:
13Branch(18)
B2:
14MoveLoc[1](Arg1: &mut PreSubscribe)
15Pop
16LdConst[9](u64: 7003)
17Abort
B3:
18CopyLoc[1](Arg1: &mut PreSubscribe)
19MutBorrowField[14](PreSubscribe.whitelisted: Table<u8, VecSet<address>>)
20CopyLoc[2](Arg2: u8)
21Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
22StLoc[10](loc5: &mut VecSet<address>)
23LdU64(0)
24StLoc[6](loc1: u64)
25ImmBorrowLoc[3](Arg3: vector<address>)
26VecLen(36)
27StLoc[7](loc2: u64)
B4:
28CopyLoc[6](loc1: u64)
29CopyLoc[7](loc2: u64)
30Lt
31BrFalse(53)
B5:
32Branch(33)
B6:
33ImmBorrowLoc[3](Arg3: vector<address>)
34CopyLoc[6](loc1: u64)
35VecImmBorrow(36)
36ReadRef
37StLoc[9](loc4: address)
38CopyLoc[10](loc5: &mut VecSet<address>)
39ImmBorrowLoc[9](loc4: address)
40StLoc[5](loc0: &address)
41FreezeRef
42MoveLoc[5](loc0: &address)
43Call vec_set::contains<address>(&VecSet<address>, &address): bool
44BrFalse(48)
B7:
45CopyLoc[10](loc5: &mut VecSet<address>)
46ImmBorrowLoc[9](loc4: address)
47Call vec_set::remove<address>(&mut VecSet<address>, &address)
B8:
48MoveLoc[6](loc1: u64)
49LdU64(1)
50Add
51StLoc[6](loc1: u64)
52Branch(28)
B9:
53MoveLoc[10](loc5: &mut VecSet<address>)
54Pop
55MoveLoc[1](Arg1: &mut PreSubscribe)
56FreezeRef
57Call object::id<PreSubscribe>(&PreSubscribe): ID
58MoveLoc[2](Arg2: u8)
59MoveLoc[3](Arg3: vector<address>)
60Pack[17](RemoveWhitelistEvent)
61Call event::emit<RemoveWhitelistEvent>(RemoveWhitelistEvent)
62Ret
}
public remove_whitelist_subscribers_pre_subscribe(Arg0: &Config, Arg1: &mut PreSubscribe, Arg2: u8, Arg3: vector<address>, Arg4: &mut TxContext) {
L5: loc0: &address
L6: loc1: &address
L7: loc2: u64
L8: loc3: u64
L9: loc4: address
L10: loc5: &mut VecSet<address>
L11: loc6: address
L12: loc7: &mut VecSet<address>
B0:
0MoveLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4MoveLoc[4](Arg4: &mut TxContext)
5FreezeRef
6Call tx_context::sender(&TxContext): address
7StLoc[9](loc4: address)
8CopyLoc[1](Arg1: &mut PreSubscribe)
9ImmBorrowField[16](PreSubscribe.wl_manager: VecSet<address>)
10ImmBorrowLoc[9](loc4: address)
11Call vec_set::contains<address>(&VecSet<address>, &address): bool
12BrFalse(14)
B1:
13Branch(18)
B2:
14MoveLoc[1](Arg1: &mut PreSubscribe)
15Pop
16LdConst[9](u64: 7003)
17Abort
B3:
18CopyLoc[1](Arg1: &mut PreSubscribe)
19MutBorrowField[14](PreSubscribe.whitelisted: Table<u8, VecSet<address>>)
20CopyLoc[2](Arg2: u8)
21Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
22StLoc[12](loc7: &mut VecSet<address>)
23CopyLoc[1](Arg1: &mut PreSubscribe)
24MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
25CopyLoc[2](Arg2: u8)
26Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
27StLoc[10](loc5: &mut VecSet<address>)
28LdU64(0)
29StLoc[7](loc2: u64)
30ImmBorrowLoc[3](Arg3: vector<address>)
31VecLen(36)
32StLoc[8](loc3: u64)
B4:
33CopyLoc[7](loc2: u64)
34CopyLoc[8](loc3: u64)
35Lt
36BrFalse(77)
B5:
37Branch(38)
B6:
38ImmBorrowLoc[3](Arg3: vector<address>)
39CopyLoc[7](loc2: u64)
40VecImmBorrow(36)
41ReadRef
42StLoc[11](loc6: address)
43CopyLoc[12](loc7: &mut VecSet<address>)
44ImmBorrowLoc[11](loc6: address)
45StLoc[5](loc0: &address)
46FreezeRef
47MoveLoc[5](loc0: &address)
48Call vec_set::contains<address>(&VecSet<address>, &address): bool
49BrFalse(53)
B7:
50CopyLoc[12](loc7: &mut VecSet<address>)
51ImmBorrowLoc[11](loc6: address)
52Call vec_set::remove<address>(&mut VecSet<address>, &address)
B8:
53CopyLoc[1](Arg1: &mut PreSubscribe)
54ImmBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
55ImmBorrowLoc[11](loc6: address)
56Call vec_set::contains<address>(&VecSet<address>, &address): bool
57BrFalse(62)
B9:
58CopyLoc[1](Arg1: &mut PreSubscribe)
59MutBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
60ImmBorrowLoc[11](loc6: address)
61Call vec_set::remove<address>(&mut VecSet<address>, &address)
B10:
62CopyLoc[10](loc5: &mut VecSet<address>)
63ImmBorrowLoc[11](loc6: address)
64StLoc[6](loc1: &address)
65FreezeRef
66MoveLoc[6](loc1: &address)
67Call vec_set::contains<address>(&VecSet<address>, &address): bool
68BrFalse(72)
B11:
69CopyLoc[10](loc5: &mut VecSet<address>)
70ImmBorrowLoc[11](loc6: address)
71Call vec_set::remove<address>(&mut VecSet<address>, &address)
B12:
72MoveLoc[7](loc2: u64)
73LdU64(1)
74Add
75StLoc[7](loc2: u64)
76Branch(33)
B13:
77MoveLoc[12](loc7: &mut VecSet<address>)
78Pop
79MoveLoc[10](loc5: &mut VecSet<address>)
80Pop
81MoveLoc[1](Arg1: &mut PreSubscribe)
82FreezeRef
83Call object::id<PreSubscribe>(&PreSubscribe): ID
84MoveLoc[2](Arg2: u8)
85MoveLoc[3](Arg3: vector<address>)
86Pack[17](RemoveWhitelistEvent)
87Call event::emit<RemoveWhitelistEvent>(RemoveWhitelistEvent)
88Ret
}
public set_refund_available_pre_subscribe(Arg0: &AdminCap, Arg1: &Config, Arg2: &mut PreSubscribe, Arg3: bool) {
B0:
0MoveLoc[1](Arg1: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[3](Arg3: bool)
5CopyLoc[2](Arg2: &mut PreSubscribe)
6MutBorrowField[17](PreSubscribe.refund_available: bool)
7WriteRef
8MoveLoc[2](Arg2: &mut PreSubscribe)
9FreezeRef
10Call object::id<PreSubscribe>(&PreSubscribe): ID
11MoveLoc[3](Arg3: bool)
12Pack[18](SetRefundAvailableEvent)
13Call event::emit<SetRefundAvailableEvent>(SetRefundAvailableEvent)
14Ret
}
public deposit_pre_subscribe<Ty0>(Arg0: &Config, Arg1: &mut PreSubscribe, Arg2: &mut BoostingVault, Arg3: u8, Arg4: Balance<Ty0>, Arg5: &Clock, Arg6: &mut TxContext) {
L7: loc0: bool
L8: loc1: &address
L9: loc2: bool
L10: loc3: &address
L11: loc4: &address
L12: loc5: u64
L13: loc6: u64
L14: loc7: &mut VecSet<address>
L15: loc8: &mut VecSet<address>
L16: loc9: &mut VecSet<address>
L17: loc10: u64
L18: loc11: u64
L19: loc12: &mut u64
L20: loc13: address
B0:
0MoveLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[1](Arg1: &mut PreSubscribe)
5ImmBorrowField[6](PreSubscribe.paused: bool)
6ReadRef
7Not
8BrFalse(10)
B1:
9Branch(20)
B2:
10MoveLoc[2](Arg2: &mut BoostingVault)
11Pop
12MoveLoc[1](Arg1: &mut PreSubscribe)
13Pop
14MoveLoc[6](Arg6: &mut TxContext)
15Pop
16MoveLoc[5](Arg5: &Clock)
17Pop
18LdConst[12](u64: 7006)
19Abort
B3:
20CopyLoc[5](Arg5: &Clock)
21Call clock::timestamp_ms(&Clock): u64
22StLoc[13](loc6: u64)
23CopyLoc[13](loc6: u64)
24CopyLoc[1](Arg1: &mut PreSubscribe)
25ImmBorrowField[7](PreSubscribe.start_time: u64)
26ReadRef
27Ge
28BrFalse(40)
B4:
29MoveLoc[13](loc6: u64)
30CopyLoc[1](Arg1: &mut PreSubscribe)
31ImmBorrowField[7](PreSubscribe.start_time: u64)
32ReadRef
33CopyLoc[1](Arg1: &mut PreSubscribe)
34ImmBorrowField[8](PreSubscribe.duration: u64)
35ReadRef
36Add
37Le
38StLoc[7](loc0: bool)
39Branch(42)
B5:
40LdFalse
41StLoc[7](loc0: bool)
B6:
42MoveLoc[7](loc0: bool)
43BrFalse(45)
B7:
44Branch(55)
B8:
45MoveLoc[2](Arg2: &mut BoostingVault)
46Pop
47MoveLoc[1](Arg1: &mut PreSubscribe)
48Pop
49MoveLoc[6](Arg6: &mut TxContext)
50Pop
51MoveLoc[5](Arg5: &Clock)
52Pop
53LdConst[14](u64: 7008)
54Abort
B9:
55CopyLoc[3](Arg3: u8)
56LdConst[4](u8: 0)
57Eq
58BrFalse(62)
B10:
59LdTrue
60StLoc[9](loc2: bool)
61Branch(66)
B11:
62CopyLoc[3](Arg3: u8)
63LdConst[5](u8: 1)
64Eq
65StLoc[9](loc2: bool)
B12:
66MoveLoc[9](loc2: bool)
67BrFalse(84)
B13:
68CopyLoc[1](Arg1: &mut PreSubscribe)
69ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
70CopyLoc[3](Arg3: u8)
71Call table::contains<u8, u64>(&Table<u8, u64>, u8): bool
72BrFalse(74)
B14:
73Branch(94)
B15:
74MoveLoc[2](Arg2: &mut BoostingVault)
75Pop
76MoveLoc[1](Arg1: &mut PreSubscribe)
77Pop
78MoveLoc[6](Arg6: &mut TxContext)
79Pop
80MoveLoc[5](Arg5: &Clock)
81Pop
82LdConst[7](u64: 7001)
83Abort
B16:
84MoveLoc[2](Arg2: &mut BoostingVault)
85Pop
86MoveLoc[1](Arg1: &mut PreSubscribe)
87Pop
88MoveLoc[6](Arg6: &mut TxContext)
89Pop
90MoveLoc[5](Arg5: &Clock)
91Pop
92LdConst[7](u64: 7001)
93Abort
B17:
94CopyLoc[1](Arg1: &mut PreSubscribe)
95ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
96CopyLoc[3](Arg3: u8)
97Call table::borrow<u8, u64>(&Table<u8, u64>, u8): &u64
98ReadRef
99StLoc[17](loc10: u64)
100ImmBorrowLoc[4](Arg4: Balance<Ty0>)
101Call balance::value<Ty0>(&Balance<Ty0>): u64
102StLoc[12](loc5: u64)
103MoveLoc[6](Arg6: &mut TxContext)
104FreezeRef
105Call tx_context::sender(&TxContext): address
106StLoc[20](loc13: address)
107CopyLoc[1](Arg1: &mut PreSubscribe)
108ImmBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
109ImmBorrowLoc[20](loc13: address)
110Call vec_set::contains<address>(&VecSet<address>, &address): bool
111BrFalse(254)
B18:
112CopyLoc[3](Arg3: u8)
113LdConst[5](u8: 1)
114Eq
115BrFalse(245)
B19:
116CopyLoc[1](Arg1: &mut PreSubscribe)
117MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
118LdConst[4](u8: 0)
119Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
120StLoc[15](loc8: &mut VecSet<address>)
121CopyLoc[15](loc8: &mut VecSet<address>)
122ImmBorrowLoc[20](loc13: address)
123StLoc[10](loc3: &address)
124FreezeRef
125MoveLoc[10](loc3: &address)
126Call vec_set::contains<address>(&VecSet<address>, &address): bool
127Not
128BrFalse(139)
B20:
129MoveLoc[2](Arg2: &mut BoostingVault)
130Pop
131MoveLoc[15](loc8: &mut VecSet<address>)
132Pop
133MoveLoc[1](Arg1: &mut PreSubscribe)
134Pop
135MoveLoc[5](Arg5: &Clock)
136Pop
137LdConst[15](u64: 7009)
138Abort
B21:
139MoveLoc[15](loc8: &mut VecSet<address>)
140ImmBorrowLoc[20](loc13: address)
141Call vec_set::remove<address>(&mut VecSet<address>, &address)
142CopyLoc[1](Arg1: &mut PreSubscribe)
143ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
144LdConst[4](u8: 0)
145Call table::contains<u8, u64>(&Table<u8, u64>, u8): bool
146BrFalse(148)
B22:
147Branch(156)
B23:
148MoveLoc[2](Arg2: &mut BoostingVault)
149Pop
150MoveLoc[1](Arg1: &mut PreSubscribe)
151Pop
152MoveLoc[5](Arg5: &Clock)
153Pop
154LdConst[7](u64: 7001)
155Abort
B24:
156CopyLoc[1](Arg1: &mut PreSubscribe)
157ImmBorrowField[9](PreSubscribe.price_per_class: Table<u8, u64>)
158LdConst[4](u8: 0)
159Call table::borrow<u8, u64>(&Table<u8, u64>, u8): &u64
160ReadRef
161StLoc[18](loc11: u64)
162CopyLoc[12](loc5: u64)
163CopyLoc[17](loc10: u64)
164CopyLoc[18](loc11: u64)
165Sub
166Eq
167BrFalse(169)
B25:
168Branch(177)
B26:
169MoveLoc[2](Arg2: &mut BoostingVault)
170Pop
171MoveLoc[1](Arg1: &mut PreSubscribe)
172Pop
173MoveLoc[5](Arg5: &Clock)
174Pop
175LdConst[8](u64: 7002)
176Abort
B27:
177CopyLoc[1](Arg1: &mut PreSubscribe)
178MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
179LdConst[5](u8: 1)
180Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
181StLoc[14](loc7: &mut VecSet<address>)
182CopyLoc[14](loc7: &mut VecSet<address>)
183ImmBorrowLoc[20](loc13: address)
184StLoc[11](loc4: &address)
185FreezeRef
186MoveLoc[11](loc4: &address)
187Call vec_set::contains<address>(&VecSet<address>, &address): bool
188Not
189BrFalse(191)
B28:
190Branch(201)
B29:
191MoveLoc[2](Arg2: &mut BoostingVault)
192Pop
193MoveLoc[14](loc7: &mut VecSet<address>)
194Pop
195MoveLoc[1](Arg1: &mut PreSubscribe)
196Pop
197MoveLoc[5](Arg5: &Clock)
198Pop
199LdConst[15](u64: 7009)
200Abort
B30:
201MoveLoc[14](loc7: &mut VecSet<address>)
202CopyLoc[20](loc13: address)
203Call vec_set::insert<address>(&mut VecSet<address>, address)
204CopyLoc[1](Arg1: &mut PreSubscribe)
205MutBorrowField[14](PreSubscribe.whitelisted: Table<u8, VecSet<address>>)
206LdConst[4](u8: 0)
207Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
208StLoc[16](loc9: &mut VecSet<address>)
209CopyLoc[16](loc9: &mut VecSet<address>)
210ImmBorrowLoc[20](loc13: address)
211StLoc[8](loc1: &address)
212FreezeRef
213MoveLoc[8](loc1: &address)
214Call vec_set::contains<address>(&VecSet<address>, &address): bool
215BrFalse(220)
B31:
216MoveLoc[16](loc9: &mut VecSet<address>)
217ImmBorrowLoc[20](loc13: address)
218Call vec_set::remove<address>(&mut VecSet<address>, &address)
219Branch(222)
B32:
220MoveLoc[16](loc9: &mut VecSet<address>)
221Pop
B33:
222CopyLoc[1](Arg1: &mut PreSubscribe)
223ImmBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
224CopyLoc[20](loc13: address)
225Call table::contains<address, u64>(&Table<address, u64>, address): bool
226Not
227BrFalse(236)
B34:
228CopyLoc[1](Arg1: &mut PreSubscribe)
229MutBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
230CopyLoc[20](loc13: address)
231MoveLoc[17](loc10: u64)
232MoveLoc[18](loc11: u64)
233Sub
234Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
235Branch(253)
B35:
236CopyLoc[1](Arg1: &mut PreSubscribe)
237MutBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
238CopyLoc[20](loc13: address)
239Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64
240StLoc[19](loc12: &mut u64)
241MoveLoc[17](loc10: u64)
242MoveLoc[19](loc12: &mut u64)
243WriteRef
244Branch(253)
B36:
245MoveLoc[2](Arg2: &mut BoostingVault)
246Pop
247MoveLoc[1](Arg1: &mut PreSubscribe)
248Pop
249MoveLoc[5](Arg5: &Clock)
250Pop
251LdConst[15](u64: 7009)
252Abort
B37:
253Branch(288)
B38:
254CopyLoc[12](loc5: u64)
255CopyLoc[17](loc10: u64)
256Eq
257BrFalse(259)
B39:
258Branch(267)
B40:
259MoveLoc[2](Arg2: &mut BoostingVault)
260Pop
261MoveLoc[1](Arg1: &mut PreSubscribe)
262Pop
263MoveLoc[5](Arg5: &Clock)
264Pop
265LdConst[8](u64: 7002)
266Abort
B41:
267CopyLoc[1](Arg1: &mut PreSubscribe)
268MutBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
269CopyLoc[20](loc13: address)
270Call vec_set::insert<address>(&mut VecSet<address>, address)
271CopyLoc[1](Arg1: &mut PreSubscribe)
272MutBorrowField[13](PreSubscribe.subscribers_type: Table<u8, VecSet<address>>)
273CopyLoc[3](Arg3: u8)
274Call table::borrow_mut<u8, VecSet<address>>(&mut Table<u8, VecSet<address>>, u8): &mut VecSet<address>
275CopyLoc[20](loc13: address)
276Call vec_set::insert<address>(&mut VecSet<address>, address)
277CopyLoc[1](Arg1: &mut PreSubscribe)
278ImmBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
279CopyLoc[20](loc13: address)
280Call table::contains<address, u64>(&Table<address, u64>, address): bool
281Not
282BrFalse(288)
B42:
283CopyLoc[1](Arg1: &mut PreSubscribe)
284MutBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
285CopyLoc[20](loc13: address)
286MoveLoc[17](loc10: u64)
287Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
B43:
288CopyLoc[1](Arg1: &mut PreSubscribe)
289ImmBorrowField[10](PreSubscribe.fee_type: TypeName)
290ReadRef
291Call type_name::get<Ty0>(): TypeName
292Eq
293BrFalse(295)
B44:
294Branch(303)
B45:
295MoveLoc[2](Arg2: &mut BoostingVault)
296Pop
297MoveLoc[1](Arg1: &mut PreSubscribe)
298Pop
299MoveLoc[5](Arg5: &Clock)
300Pop
301LdConst[11](u64: 7005)
302Abort
B46:
303CopyLoc[1](Arg1: &mut PreSubscribe)
304ImmBorrowField[18](PreSubscribe.total_deposit: u64)
305ReadRef
306CopyLoc[12](loc5: u64)
307Add
308CopyLoc[1](Arg1: &mut PreSubscribe)
309MutBorrowField[18](PreSubscribe.total_deposit: u64)
310WriteRef
311MoveLoc[2](Arg2: &mut BoostingVault)
312MoveLoc[4](Arg4: Balance<Ty0>)
313MoveLoc[5](Arg5: &Clock)
314Call deposit_to_vault<Ty0>(&mut BoostingVault, Balance<Ty0>, &Clock)
315MoveLoc[1](Arg1: &mut PreSubscribe)
316FreezeRef
317Call object::id<PreSubscribe>(&PreSubscribe): ID
318MoveLoc[20](loc13: address)
319MoveLoc[3](Arg3: u8)
320MoveLoc[12](loc5: u64)
321Pack[19](DepositPreSubscribeEvent)
322Call event::emit<DepositPreSubscribeEvent>(DepositPreSubscribeEvent)
323Ret
}
public refund_pre_subscribe<Ty0>(Arg0: &Config, Arg1: &mut PreSubscribe, Arg2: &mut BoostingVault, Arg3: &Clock, Arg4: &mut TxContext) {
L5: loc0: u64
L6: loc1: address
L7: loc2: &Clock
L8: loc3: address
L9: loc4: &Clock
L10: loc5: bool
L11: loc6: bool
L12: loc7: bool
L13: loc8: u64
L14: loc9: address
B0:
0MoveLoc[0](Arg0: &Config)
1LdConst[0](vector<u8>: "BOO..)
2Call string::utf8(vector<u8>): String
3Call guild::verify_config(&Config, String)
4CopyLoc[1](Arg1: &mut PreSubscribe)
5ImmBorrowField[6](PreSubscribe.paused: bool)
6ReadRef
7Not
8BrFalse(10)
B1:
9Branch(20)
B2:
10MoveLoc[2](Arg2: &mut BoostingVault)
11Pop
12MoveLoc[1](Arg1: &mut PreSubscribe)
13Pop
14MoveLoc[4](Arg4: &mut TxContext)
15Pop
16MoveLoc[3](Arg3: &Clock)
17Pop
18LdConst[12](u64: 7006)
19Abort
B3:
20CopyLoc[4](Arg4: &mut TxContext)
21FreezeRef
22Call tx_context::sender(&TxContext): address
23StLoc[14](loc9: address)
24CopyLoc[1](Arg1: &mut PreSubscribe)
25CopyLoc[14](loc9: address)
26CopyLoc[3](Arg3: &Clock)
27StLoc[7](loc2: &Clock)
28StLoc[6](loc1: address)
29FreezeRef
30MoveLoc[6](loc1: address)
31LdConst[4](u8: 0)
32MoveLoc[7](loc2: &Clock)
33Call validate_claim_refund_pre_subscribe(&PreSubscribe, address, u8, &Clock): bool
34StLoc[12](loc7: bool)
35CopyLoc[1](Arg1: &mut PreSubscribe)
36CopyLoc[14](loc9: address)
37CopyLoc[3](Arg3: &Clock)
38StLoc[9](loc4: &Clock)
39StLoc[8](loc3: address)
40FreezeRef
41MoveLoc[8](loc3: address)
42LdConst[5](u8: 1)
43MoveLoc[9](loc4: &Clock)
44Call validate_claim_refund_pre_subscribe(&PreSubscribe, address, u8, &Clock): bool
45StLoc[11](loc6: bool)
46CopyLoc[12](loc7: bool)
47BrFalse(51)
B4:
48LdTrue
49StLoc[10](loc5: bool)
50Branch(53)
B5:
51CopyLoc[11](loc6: bool)
52StLoc[10](loc5: bool)
B6:
53MoveLoc[10](loc5: bool)
54BrFalse(56)
B7:
55Branch(66)
B8:
56MoveLoc[2](Arg2: &mut BoostingVault)
57Pop
58MoveLoc[1](Arg1: &mut PreSubscribe)
59Pop
60MoveLoc[4](Arg4: &mut TxContext)
61Pop
62MoveLoc[3](Arg3: &Clock)
63Pop
64LdConst[18](u64: 7012)
65Abort
B9:
66CopyLoc[1](Arg1: &mut PreSubscribe)
67ImmBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
68CopyLoc[14](loc9: address)
69Call table::contains<address, u64>(&Table<address, u64>, address): bool
70BrFalse(77)
B10:
71CopyLoc[1](Arg1: &mut PreSubscribe)
72MutBorrowField[15](PreSubscribe.refund_amounts: Table<address, u64>)
73CopyLoc[14](loc9: address)
74Call table::remove<address, u64>(&mut Table<address, u64>, address): u64
75StLoc[5](loc0: u64)
76Branch(79)
B11:
77LdU64(0)
78StLoc[5](loc0: u64)
B12:
79MoveLoc[5](loc0: u64)
80StLoc[13](loc8: u64)
81CopyLoc[13](loc8: u64)
82LdU64(0)
83Gt
84BrFalse(86)
B13:
85Branch(96)
B14:
86MoveLoc[2](Arg2: &mut BoostingVault)
87Pop
88MoveLoc[1](Arg1: &mut PreSubscribe)
89Pop
90MoveLoc[4](Arg4: &mut TxContext)
91Pop
92MoveLoc[3](Arg3: &Clock)
93Pop
94LdConst[18](u64: 7012)
95Abort
B15:
96CopyLoc[1](Arg1: &mut PreSubscribe)
97ImmBorrowField[19](PreSubscribe.total_refund: u64)
98ReadRef
99CopyLoc[13](loc8: u64)
100Add
101CopyLoc[1](Arg1: &mut PreSubscribe)
102MutBorrowField[19](PreSubscribe.total_refund: u64)
103WriteRef
104CopyLoc[1](Arg1: &mut PreSubscribe)
105MutBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
106ImmBorrowLoc[14](loc9: address)
107Call vec_set::remove<address>(&mut VecSet<address>, &address)
108MoveLoc[2](Arg2: &mut BoostingVault)
109CopyLoc[13](loc8: u64)
110MoveLoc[3](Arg3: &Clock)
111MoveLoc[4](Arg4: &mut TxContext)
112Call withdraw_from_vault<Ty0>(&mut BoostingVault, u64, &Clock, &mut TxContext): Coin<Ty0>
113CopyLoc[14](loc9: address)
114Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
115MoveLoc[1](Arg1: &mut PreSubscribe)
116FreezeRef
117Call object::id<PreSubscribe>(&PreSubscribe): ID
118MoveLoc[14](loc9: address)
119MoveLoc[12](loc7: bool)
120MoveLoc[11](loc6: bool)
121MoveLoc[13](loc8: u64)
122Pack[20](RefundPreSubscribeEvent)
123Call event::emit<RefundPreSubscribeEvent>(RefundPreSubscribeEvent)
124Ret
}
validate_claim_refund_pre_subscribe(Arg0: &PreSubscribe, Arg1: address, Arg2: u8, Arg3: &Clock): bool {
B0:
0CopyLoc[0](Arg0: &PreSubscribe)
1ImmBorrowField[17](PreSubscribe.refund_available: bool)
2ReadRef
3Not
4BrFalse(11)
B1:
5MoveLoc[0](Arg0: &PreSubscribe)
6Pop
7MoveLoc[3](Arg3: &Clock)
8Pop
9LdFalse
10Ret
B2:
11MoveLoc[3](Arg3: &Clock)
12Call clock::timestamp_ms(&Clock): u64
13CopyLoc[0](Arg0: &PreSubscribe)
14ImmBorrowField[7](PreSubscribe.start_time: u64)
15ReadRef
16CopyLoc[0](Arg0: &PreSubscribe)
17ImmBorrowField[8](PreSubscribe.duration: u64)
18ReadRef
19Add
20Le
21BrFalse(26)
B3:
22MoveLoc[0](Arg0: &PreSubscribe)
23Pop
24LdFalse
25Ret
B4:
26CopyLoc[0](Arg0: &PreSubscribe)
27ImmBorrowField[12](PreSubscribe.subscribers: VecSet<address>)
28ImmBorrowLoc[1](Arg1: address)
29Call vec_set::contains<address>(&VecSet<address>, &address): bool
30BrFalse(52)
B5:
31CopyLoc[0](Arg0: &PreSubscribe)
32ImmBorrowField[14](PreSubscribe.whitelisted: Table<u8, VecSet<address>>)
33CopyLoc[2](Arg2: u8)
34Call table::contains<u8, VecSet<address>>(&Table<u8, VecSet<address>>, u8): bool
35Not
36BrFalse(41)
B6:
37MoveLoc[0](Arg0: &PreSubscribe)
38Pop
39LdTrue
40Ret
B7:
41MoveLoc[0](Arg0: &PreSubscribe)
42ImmBorrowField[14](PreSubscribe.whitelisted: Table<u8, VecSet<address>>)
43MoveLoc[2](Arg2: u8)
44Call table::borrow<u8, VecSet<address>>(&Table<u8, VecSet<address>>, u8): &VecSet<address>
45ImmBorrowLoc[1](Arg1: address)
46Call vec_set::contains<address>(&VecSet<address>, &address): bool
47Not
48BrFalse(51)
B8:
49LdTrue
50Ret
B9:
51Branch(54)
B10:
52MoveLoc[0](Arg0: &PreSubscribe)
53Pop
B11:
54LdFalse
55Ret
}
public set_fund_receiver(Arg0: &AdminCap, Arg1: &mut BoostingVault, Arg2: address) {
B0:
0CopyLoc[2](Arg2: address)
1MoveLoc[1](Arg1: &mut BoostingVault)
2MutBorrowField[20](BoostingVault.fund_receiver: address)
3WriteRef
4MoveLoc[2](Arg2: address)
5Pack[4](SetFundReceiverEvent)
6Call event::emit<SetFundReceiverEvent>(SetFundReceiverEvent)
7Ret
}
public withdraw_amount_from_vault<Ty0>(Arg0: &TreasureCap, Arg1: &mut BoostingVault, Arg2: u64, Arg3: &Clock, Arg4: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut BoostingVault)
1MoveLoc[2](Arg2: u64)
2MoveLoc[3](Arg3: &Clock)
3MoveLoc[4](Arg4: &mut TxContext)
4Call withdraw_from_vault<Ty0>(&mut BoostingVault, u64, &Clock, &mut TxContext): Coin<Ty0>
5MoveLoc[1](Arg1: &mut BoostingVault)
6ImmBorrowField[20](BoostingVault.fund_receiver: address)
7ReadRef
8Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
9Ret
}
public deposit_fund_to_vault<Ty0>(Arg0: &TreasureCap, Arg1: &mut BoostingVault, Arg2: Balance<Ty0>, Arg3: &Clock) {
B0:
0MoveLoc[1](Arg1: &mut BoostingVault)
1MoveLoc[2](Arg2: Balance<Ty0>)
2MoveLoc[3](Arg3: &Clock)
3Call deposit_to_vault<Ty0>(&mut BoostingVault, Balance<Ty0>, &Clock)
4Ret
}
public set_whitelist_deposit(Arg0: &AdminCap, Arg1: &mut BoostingVault, Arg2: vector<address>) {
L3: loc0: &address
L4: loc1: u64
L5: loc2: u64
L6: loc3: address
L7: loc4: VecSet<address>
L8: loc5: &mut VecSet<address>
B0:
0CopyLoc[1](Arg1: &mut BoostingVault)
1ImmBorrowField[21](BoostingVault.id: UID)
2LdConst[2](vector<u8>: "BOO..)
3Call dynamic_field::exists_<vector<u8>>(&UID, vector<u8>): bool
4Not
5BrFalse(14)
B1:
6Call vec_set::empty<address>(): VecSet<address>
7StLoc[7](loc4: VecSet<address>)
8MoveLoc[1](Arg1: &mut BoostingVault)
9MutBorrowField[21](BoostingVault.id: UID)
10LdConst[2](vector<u8>: "BOO..)
11MoveLoc[7](loc4: VecSet<address>)
12Call dynamic_field::add<vector<u8>, VecSet<address>>(&mut UID, vector<u8>, VecSet<address>)
13Branch(52)
B2:
14MoveLoc[1](Arg1: &mut BoostingVault)
15MutBorrowField[21](BoostingVault.id: UID)
16LdConst[2](vector<u8>: "BOO..)
17Call dynamic_field::borrow_mut<vector<u8>, VecSet<address>>(&mut UID, vector<u8>): &mut VecSet<address>
18StLoc[8](loc5: &mut VecSet<address>)
19LdU64(0)
20StLoc[4](loc1: u64)
21ImmBorrowLoc[2](Arg2: vector<address>)
22VecLen(36)
23StLoc[5](loc2: u64)
B3:
24CopyLoc[4](loc1: u64)
25CopyLoc[5](loc2: u64)
26Lt
27BrFalse(50)
B4:
28Branch(29)
B5:
29ImmBorrowLoc[2](Arg2: vector<address>)
30CopyLoc[4](loc1: u64)
31VecImmBorrow(36)
32ReadRef
33StLoc[6](loc3: address)
34CopyLoc[8](loc5: &mut VecSet<address>)
35ImmBorrowLoc[6](loc3: address)
36StLoc[3](loc0: &address)
37FreezeRef
38MoveLoc[3](loc0: &address)
39Call vec_set::contains<address>(&VecSet<address>, &address): bool
40Not
41BrFalse(45)
B6:
42CopyLoc[8](loc5: &mut VecSet<address>)
43MoveLoc[6](loc3: address)
44Call vec_set::insert<address>(&mut VecSet<address>, address)
B7:
45MoveLoc[4](loc1: u64)
46LdU64(1)
47Add
48StLoc[4](loc1: u64)
49Branch(24)
B8:
50MoveLoc[8](loc5: &mut VecSet<address>)
51Pop
B9:
52Ret
}
public deposit_fund_to_vault_from_swap<Ty0>(Arg0: &mut BoostingVault, Arg1: Coin<Ty0>, Arg2: &Clock, Arg3: &mut TxContext) {
L4: loc0: &address
L5: loc1: address
B0:
0MoveLoc[3](Arg3: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[5](loc1: address)
4CopyLoc[0](Arg0: &mut BoostingVault)
5MutBorrowField[21](BoostingVault.id: UID)
6LdConst[2](vector<u8>: "BOO..)
7Call dynamic_field::borrow_mut<vector<u8>, VecSet<address>>(&mut UID, vector<u8>): &mut VecSet<address>
8ImmBorrowLoc[5](loc1: address)
9StLoc[4](loc0: &address)
10FreezeRef
11MoveLoc[4](loc0: &address)
12Call vec_set::contains<address>(&VecSet<address>, &address): bool
13BrFalse(15)
B1:
14Branch(21)
B2:
15MoveLoc[0](Arg0: &mut BoostingVault)
16Pop
17MoveLoc[2](Arg2: &Clock)
18Pop
19LdConst[9](u64: 7003)
20Abort
B3:
21MoveLoc[0](Arg0: &mut BoostingVault)
22MoveLoc[1](Arg1: Coin<Ty0>)
23Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
24MoveLoc[2](Arg2: &Clock)
25Call deposit_to_vault<Ty0>(&mut BoostingVault, Balance<Ty0>, &Clock)
26Ret
}
public paused(Arg0: &AdminCap, Arg1: &mut Config, Arg2: bool) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1MoveLoc[1](Arg1: &mut Config)
2LdConst[0](vector<u8>: "BOO..)
3Call string::utf8(vector<u8>): String
4MoveLoc[2](Arg2: bool)
5Call guild::paused_v2(&AdminCap, &mut Config, String, bool)
6Ret
}
Constants [
0 => vector<u8>: "BOOSTING_MODULE" // interpreted as UTF8 string
1 => vector<u8>: "BOOSTING_CLAIM_COMMISTION_TIME_RANGE" // interpreted as UTF8 string
2 => vector<u8>: "BOOSTING_WHITELIST_DEPOSIT" // interpreted as UTF8 string
3 => u64: 259200000
4 => u8: 0
5 => u8: 1
6 => u64: 7000
7 => u64: 7001
8 => u64: 7002
9 => u64: 7003
10 => u64: 7004
11 => u64: 7005
12 => u64: 7006
13 => u64: 7007
14 => u64: 7008
15 => u64: 7009
16 => u64: 7010
17 => u64: 7011
18 => u64: 7012
19 => u64: 7013
]
}