admin
Module0x67b3…928a
- Move path
- 0x3492…c267::admin
- Functions
- 1715 public, 15 entry
- Structs
- 2
- Friend modules
- None
admin
Bytecode759 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267.admin {
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::config;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::constants;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::errors;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::pool;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
struct AdminCap has key {
id: UID
}
struct ProtocolFeeCap has key {
id: UID
}
init(Arg0: &mut TxContext) {
L1: loc0: AdminCap
L2: loc1: address
L3: loc2: ProtocolFeeCap
B0:
0CopyLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Pack[0](AdminCap)
3StLoc[1](loc0: AdminCap)
4CopyLoc[0](Arg0: &mut TxContext)
5Call object::new(&mut TxContext): UID
6Pack[1](ProtocolFeeCap)
7StLoc[3](loc2: ProtocolFeeCap)
8MoveLoc[0](Arg0: &mut TxContext)
9FreezeRef
10Call tx_context::sender(&TxContext): address
11StLoc[2](loc1: address)
12MoveLoc[1](loc0: AdminCap)
13CopyLoc[2](loc1: address)
14Call transfer::transfer<AdminCap>(AdminCap, address)
15MoveLoc[3](loc2: ProtocolFeeCap)
16MoveLoc[2](loc1: address)
17Call transfer::transfer<ProtocolFeeCap>(ProtocolFeeCap, address)
18Ret
}
entry public transer_admin_cap(Arg0: &GlobalConfig, Arg1: AdminCap, Arg2: address) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[1](Arg1: AdminCap)
3CopyLoc[2](Arg2: address)
4Call transfer::transfer<AdminCap>(AdminCap, address)
5MoveLoc[2](Arg2: address)
6Call events::emit_admin_cap_transfer_event(address)
7Ret
}
entry public transer_protocol_fee_cap(Arg0: &GlobalConfig, Arg1: ProtocolFeeCap, Arg2: address) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[1](Arg1: ProtocolFeeCap)
3CopyLoc[2](Arg2: address)
4Call transfer::transfer<ProtocolFeeCap>(ProtocolFeeCap, address)
5MoveLoc[2](Arg2: address)
6Call events::emit_protocol_fee_cap_transfer_event(address)
7Ret
}
entry public claim_protocol_fee<Ty0, Ty1>(Arg0: &ProtocolFeeCap, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: u64, Arg4: u64, Arg5: address, Arg6: &mut TxContext) {
L7: loc0: Balance<Ty0>
L8: loc1: u64
L9: loc2: Balance<Ty1>
L10: loc3: u64
L11: loc4: u64
L12: loc5: u64
L13: loc6: u128
B0:
0MoveLoc[1](Arg1: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3FreezeRef
4Call pool::get_protocol_fee_for_coin_a<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64
5StLoc[11](loc4: u64)
6CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
7FreezeRef
8Call pool::get_protocol_fee_for_coin_b<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64
9StLoc[12](loc5: u64)
10CopyLoc[3](Arg3: u64)
11CopyLoc[11](loc4: u64)
12Le
13BrFalse(15)
B1:
14Branch(21)
B2:
15MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
16Pop
17MoveLoc[6](Arg6: &mut TxContext)
18Pop
19Call errors::insufficient_amount(): u64
20Abort
B3:
21CopyLoc[4](Arg4: u64)
22CopyLoc[12](loc5: u64)
23Le
24BrFalse(26)
B4:
25Branch(32)
B5:
26MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
27Pop
28MoveLoc[6](Arg6: &mut TxContext)
29Pop
30Call errors::insufficient_amount(): u64
31Abort
B6:
32CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
33MoveLoc[11](loc4: u64)
34CopyLoc[3](Arg3: u64)
35Sub
36MoveLoc[12](loc5: u64)
37CopyLoc[4](Arg4: u64)
38Sub
39Call pool::set_protocol_fee_amount<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64)
40CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
41CopyLoc[3](Arg3: u64)
42CopyLoc[4](Arg4: u64)
43Call pool::withdraw_balances<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64, u64): Balance<Ty0> * Balance<Ty1>
44StLoc[9](loc2: Balance<Ty1>)
45StLoc[7](loc0: Balance<Ty0>)
46CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
47Call pool::increase_sequence_number<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): u128
48StLoc[13](loc6: u128)
49MoveLoc[7](loc0: Balance<Ty0>)
50CopyLoc[5](Arg5: address)
51CopyLoc[6](Arg6: &mut TxContext)
52Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
53MoveLoc[9](loc2: Balance<Ty1>)
54CopyLoc[5](Arg5: address)
55CopyLoc[6](Arg6: &mut TxContext)
56Call utils::transfer_balance<Ty1>(Balance<Ty1>, address, &mut TxContext)
57CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
58FreezeRef
59Call pool::coin_reserves<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64 * u64
60StLoc[10](loc3: u64)
61StLoc[8](loc1: u64)
62MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
63FreezeRef
64Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
65MoveLoc[6](Arg6: &mut TxContext)
66FreezeRef
67Call tx_context::sender(&TxContext): address
68MoveLoc[5](Arg5: address)
69MoveLoc[3](Arg3: u64)
70MoveLoc[4](Arg4: u64)
71MoveLoc[8](loc1: u64)
72MoveLoc[10](loc3: u64)
73MoveLoc[13](loc6: u128)
74Call events::emit_protocol_fee_collected(ID, address, address, u64, u64, u64, u64, u128)
75Ret
}
entry public remove_reward_manager(Arg0: &AdminCap, Arg1: &mut GlobalConfig, Arg2: address) {
B0:
0CopyLoc[1](Arg1: &mut GlobalConfig)
1FreezeRef
2Call config::verify_version(&GlobalConfig)
3MoveLoc[1](Arg1: &mut GlobalConfig)
4CopyLoc[2](Arg2: address)
5Call config::remove_reward_manager(&mut GlobalConfig, address)
6MoveLoc[2](Arg2: address)
7LdFalse
8Call events::emit_reward_manager_update_event(address, bool)
9Ret
}
entry public update_pool_pause_status<Ty0, Ty1>(Arg0: &AdminCap, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: bool) {
B0:
0MoveLoc[1](Arg1: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3MoveLoc[3](Arg3: bool)
4Call pool::update_pause_status<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool)
5Ret
}
entry public add_reward_manager(Arg0: &AdminCap, Arg1: &mut GlobalConfig, Arg2: address) {
B0:
0CopyLoc[1](Arg1: &mut GlobalConfig)
1FreezeRef
2Call config::verify_version(&GlobalConfig)
3MoveLoc[1](Arg1: &mut GlobalConfig)
4CopyLoc[2](Arg2: address)
5Call config::set_reward_manager(&mut GlobalConfig, address)
6MoveLoc[2](Arg2: address)
7LdTrue
8Call events::emit_reward_manager_update_event(address, bool)
9Ret
}
entry public initialize_pool_reward<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: u64, Arg4: Coin<Ty2>, Arg5: String, Arg6: u8, Arg7: u64, Arg8: &Clock, Arg9: &mut TxContext) {
L10: loc0: bool
L11: loc1: address
L12: loc2: bool
L13: loc3: bool
L14: loc4: String
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3CopyLoc[9](Arg9: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Call config::verify_reward_manager(&GlobalConfig, address): bool
7StLoc[13](loc3: bool)
8CopyLoc[13](loc3: bool)
9BrFalse(15)
B1:
10MoveLoc[9](Arg9: &mut TxContext)
11Pop
12LdTrue
13StLoc[10](loc0: bool)
14Branch(24)
B2:
15CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16MoveLoc[9](Arg9: &mut TxContext)
17FreezeRef
18Call tx_context::sender(&TxContext): address
19StLoc[11](loc1: address)
20FreezeRef
21MoveLoc[11](loc1: address)
22Call pool::verify_pool_manager<Ty0, Ty1>(&Pool<Ty0, Ty1>, address): bool
23StLoc[10](loc0: bool)
B3:
24MoveLoc[10](loc0: bool)
25BrFalse(27)
B4:
26Branch(33)
B5:
27MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
28Pop
29MoveLoc[8](Arg8: &Clock)
30Pop
31Call errors::not_authorized(): u64
32Abort
B6:
33Call utils::get_type_string<Ty2>(): String
34StLoc[14](loc4: String)
35CopyLoc[14](loc4: String)
36Call constants::blue_reward_type(): String
37Neq
38BrFalse(42)
B7:
39LdTrue
40StLoc[12](loc2: bool)
41Branch(44)
B8:
42MoveLoc[13](loc3: bool)
43StLoc[12](loc2: bool)
B9:
44MoveLoc[12](loc2: bool)
45BrFalse(47)
B10:
46Branch(53)
B11:
47MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
48Pop
49MoveLoc[8](Arg8: &Clock)
50Pop
51Call errors::not_authorized(): u64
52Abort
B12:
53MoveLoc[7](Arg7: u64)
54ImmBorrowLoc[4](Arg4: Coin<Ty2>)
55Call coin::value<Ty2>(&Coin<Ty2>): u64
56Eq
57BrFalse(59)
B13:
58Branch(65)
B14:
59MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
60Pop
61MoveLoc[8](Arg8: &Clock)
62Pop
63Call errors::reward_amount_and_provided_balance_do_not_match(): u64
64Abort
B15:
65CopyLoc[2](Arg2: u64)
66MoveLoc[8](Arg8: &Clock)
67Call utils::timestamp_seconds(&Clock): u64
68Gt
69BrFalse(71)
B16:
70Branch(75)
B17:
71MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
72Pop
73Call errors::invalid_timestamp(): u64
74Abort
B18:
75CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
76MoveLoc[14](loc4: String)
77MoveLoc[5](Arg5: String)
78MoveLoc[6](Arg6: u8)
79MoveLoc[2](Arg2: u64)
80Call pool::default_reward_info(String, String, u8, u64): PoolRewardInfo
81Call pool::add_reward_info<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, PoolRewardInfo)
82MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
83MoveLoc[4](Arg4: Coin<Ty2>)
84Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
85MoveLoc[3](Arg3: u64)
86Call pool::update_pool_reward_emission<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, Balance<Ty2>, u64)
87Ret
}
entry public update_pool_reward_emission<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: Coin<Ty2>, Arg4: u64, Arg5: &Clock, Arg6: &TxContext) {
L7: loc0: bool
L8: loc1: address
L9: loc2: bool
L10: loc3: bool
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3CopyLoc[6](Arg6: &TxContext)
4Call tx_context::sender(&TxContext): address
5Call config::verify_reward_manager(&GlobalConfig, address): bool
6StLoc[10](loc3: bool)
7CopyLoc[10](loc3: bool)
8BrFalse(14)
B1:
9MoveLoc[6](Arg6: &TxContext)
10Pop
11LdTrue
12StLoc[7](loc0: bool)
13Branch(22)
B2:
14CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
15MoveLoc[6](Arg6: &TxContext)
16Call tx_context::sender(&TxContext): address
17StLoc[8](loc1: address)
18FreezeRef
19MoveLoc[8](loc1: address)
20Call pool::verify_pool_manager<Ty0, Ty1>(&Pool<Ty0, Ty1>, address): bool
21StLoc[7](loc0: bool)
B3:
22MoveLoc[7](loc0: bool)
23BrFalse(25)
B4:
24Branch(31)
B5:
25MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
26Pop
27MoveLoc[5](Arg5: &Clock)
28Pop
29Call errors::not_authorized(): u64
30Abort
B6:
31Call utils::get_type_string<Ty2>(): String
32Call constants::blue_reward_type(): String
33Neq
34BrFalse(38)
B7:
35LdTrue
36StLoc[9](loc2: bool)
37Branch(40)
B8:
38MoveLoc[10](loc3: bool)
39StLoc[9](loc2: bool)
B9:
40MoveLoc[9](loc2: bool)
41BrFalse(43)
B10:
42Branch(49)
B11:
43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
44Pop
45MoveLoc[5](Arg5: &Clock)
46Pop
47Call errors::not_authorized(): u64
48Abort
B12:
49MoveLoc[4](Arg4: u64)
50ImmBorrowLoc[3](Arg3: Coin<Ty2>)
51Call coin::value<Ty2>(&Coin<Ty2>): u64
52Eq
53BrFalse(55)
B13:
54Branch(61)
B14:
55MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
56Pop
57MoveLoc[5](Arg5: &Clock)
58Pop
59Call errors::reward_amount_and_provided_balance_do_not_match(): u64
60Abort
B15:
61CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
62MoveLoc[5](Arg5: &Clock)
63Call utils::timestamp_seconds(&Clock): u64
64Call pool::update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>
65Pop
66MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
67MoveLoc[3](Arg3: Coin<Ty2>)
68Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
69MoveLoc[2](Arg2: u64)
70Call pool::update_pool_reward_emission<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, Balance<Ty2>, u64)
71Ret
}
public add_seconds_to_reward_emission<Ty0, Ty1, Ty2>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64, Arg3: &Clock, Arg4: &TxContext) {
L5: loc0: bool
L6: loc1: address
L7: loc2: bool
L8: loc3: bool
B0:
0CopyLoc[0](Arg0: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[0](Arg0: &GlobalConfig)
3CopyLoc[4](Arg4: &TxContext)
4Call tx_context::sender(&TxContext): address
5Call config::verify_reward_manager(&GlobalConfig, address): bool
6StLoc[8](loc3: bool)
7CopyLoc[8](loc3: bool)
8BrFalse(14)
B1:
9MoveLoc[4](Arg4: &TxContext)
10Pop
11LdTrue
12StLoc[5](loc0: bool)
13Branch(22)
B2:
14CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
15MoveLoc[4](Arg4: &TxContext)
16Call tx_context::sender(&TxContext): address
17StLoc[6](loc1: address)
18FreezeRef
19MoveLoc[6](loc1: address)
20Call pool::verify_pool_manager<Ty0, Ty1>(&Pool<Ty0, Ty1>, address): bool
21StLoc[5](loc0: bool)
B3:
22MoveLoc[5](loc0: bool)
23BrFalse(25)
B4:
24Branch(31)
B5:
25MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
26Pop
27MoveLoc[3](Arg3: &Clock)
28Pop
29Call errors::not_authorized(): u64
30Abort
B6:
31Call utils::get_type_string<Ty2>(): String
32Call constants::blue_reward_type(): String
33Neq
34BrFalse(38)
B7:
35LdTrue
36StLoc[7](loc2: bool)
37Branch(40)
B8:
38MoveLoc[8](loc3: bool)
39StLoc[7](loc2: bool)
B9:
40MoveLoc[7](loc2: bool)
41BrFalse(43)
B10:
42Branch(49)
B11:
43MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
44Pop
45MoveLoc[3](Arg3: &Clock)
46Pop
47Call errors::not_authorized(): u64
48Abort
B12:
49CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
50MoveLoc[3](Arg3: &Clock)
51Call utils::timestamp_seconds(&Clock): u64
52Call pool::update_reward_infos<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64): vector<u128>
53Pop
54MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
55Call balance::zero<Ty2>(): Balance<Ty2>
56MoveLoc[2](Arg2: u64)
57Call pool::update_pool_reward_emission<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, Balance<Ty2>, u64)
58Ret
}
entry public update_supported_version(Arg0: &AdminCap, Arg1: &mut GlobalConfig) {
B0:
0MoveLoc[1](Arg1: &mut GlobalConfig)
1Call config::increase_version(&mut GlobalConfig): u64 * u64
2Call events::emit_supported_version_update_event(u64, u64)
3Ret
}
L3: loc0: u64
L4: loc1: u128
B0:
0CopyLoc[2](Arg2: u64)
1Call constants::max_protocol_fee_share(): u64
2Le
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
6Pop
7Call errors::invalid_protocol_fee_share(): u64
8Abort
B3:
9CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10FreezeRef
11Call pool::protocol_fee_share<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64
12StLoc[3](loc0: u64)
13CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
14CopyLoc[2](Arg2: u64)
15Call pool::set_protocol_fee_share<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64)
16CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
17Call pool::increase_sequence_number<Ty0, Ty1>(&mut Pool<Ty0, Ty1>): u128
18StLoc[4](loc1: u128)
19MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
20FreezeRef
21Call object::id<Pool<Ty0, Ty1>>(&Pool<Ty0, Ty1>): ID
22MoveLoc[3](loc0: u64)
23MoveLoc[2](Arg2: u64)
24MoveLoc[4](loc1: u128)
25Call events::emit_protocol_fee_share_updated_event(ID, u64, u64, u128)
26Ret
}
entry public increase_observation_cardinality_next<Ty0, Ty1>(Arg0: &AdminCap, Arg1: &mut Pool<Ty0, Ty1>, Arg2: u64) {
B0:
0CopyLoc[2](Arg2: u64)
1Call constants::max_observation_cardinality(): u64
2Lt
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
6Pop
7Call errors::invalid_observation_cardinality(): u64
8Abort
B3:
9MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
10MoveLoc[2](Arg2: u64)
11Call pool::increase_observation_cardinality_next<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, u64)
12Ret
}
entry public set_pool_manager<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: address, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: address)
3MoveLoc[3](Arg3: &mut TxContext)
4FreezeRef
5Call pool::set_manager<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, address, &TxContext)
6Ret
}
entry public set_pool_creation_fee<Ty0>(Arg0: &AdminCap, Arg1: &mut GlobalConfig, Arg2: u64, Arg3: &mut TxContext) {
L4: loc0: String
L5: loc1: String
L6: loc2: &mut u64
L7: loc3: String
L8: loc4: &mut Table<String, u64>
L9: loc5: String
L10: loc6: u64
L11: loc7: &mut UID
B0:
0CopyLoc[1](Arg1: &mut GlobalConfig)
1FreezeRef
2Call config::verify_version(&GlobalConfig)
3MoveLoc[1](Arg1: &mut GlobalConfig)
4Call config::get_config_id(&mut GlobalConfig): &mut UID
5StLoc[11](loc7: &mut UID)
6Call constants::pool_creation_fee_dynamic_key(): String
7StLoc[9](loc5: String)
8Call utils::get_type_string<Ty0>(): String
9StLoc[7](loc3: String)
10CopyLoc[11](loc7: &mut UID)
11CopyLoc[9](loc5: String)
12StLoc[4](loc0: String)
13FreezeRef
14MoveLoc[4](loc0: String)
15Call dynamic_field::exists_<String>(&UID, String): bool
16Not
17BrFalse(24)
B1:
18CopyLoc[11](loc7: &mut UID)
19CopyLoc[9](loc5: String)
20MoveLoc[3](Arg3: &mut TxContext)
21Call table::new<String, u64>(&mut TxContext): Table<String, u64>
22Call dynamic_field::add<String, Table<String, u64>>(&mut UID, String, Table<String, u64>)
23Branch(26)
B2:
24MoveLoc[3](Arg3: &mut TxContext)
25Pop
B3:
26MoveLoc[11](loc7: &mut UID)
27MoveLoc[9](loc5: String)
28Call dynamic_field::borrow_mut<String, Table<String, u64>>(&mut UID, String): &mut Table<String, u64>
29StLoc[8](loc4: &mut Table<String, u64>)
30CopyLoc[8](loc4: &mut Table<String, u64>)
31CopyLoc[7](loc3: String)
32StLoc[5](loc1: String)
33FreezeRef
34MoveLoc[5](loc1: String)
35Call table::contains<String, u64>(&Table<String, u64>, String): bool
36Not
37BrFalse(42)
B4:
38CopyLoc[8](loc4: &mut Table<String, u64>)
39CopyLoc[7](loc3: String)
40LdU64(0)
41Call table::add<String, u64>(&mut Table<String, u64>, String, u64)
B5:
42MoveLoc[8](loc4: &mut Table<String, u64>)
43CopyLoc[7](loc3: String)
44Call table::borrow_mut<String, u64>(&mut Table<String, u64>, String): &mut u64
45StLoc[6](loc2: &mut u64)
46CopyLoc[6](loc2: &mut u64)
47ReadRef
48StLoc[10](loc6: u64)
49CopyLoc[2](Arg2: u64)
50MoveLoc[6](loc2: &mut u64)
51WriteRef
52MoveLoc[7](loc3: String)
53MoveLoc[10](loc6: u64)
54MoveLoc[2](Arg2: u64)
55Call events::emit_pool_creation_fee_update_event(String, u64, u64)
56Ret
}
entry public claim_pool_creation_fee<Ty0>(Arg0: &ProtocolFeeCap, Arg1: &mut GlobalConfig, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
L5: loc0: String
L6: loc1: &mut Balance<Ty0>
L7: loc2: u64
L8: loc3: u64
L9: loc4: Balance<Ty0>
L10: loc5: String
L11: loc6: &mut UID
B0:
0CopyLoc[1](Arg1: &mut GlobalConfig)
1FreezeRef
2Call config::verify_version(&GlobalConfig)
3MoveLoc[1](Arg1: &mut GlobalConfig)
4Call config::get_config_id(&mut GlobalConfig): &mut UID
5StLoc[11](loc6: &mut UID)
6Call utils::get_type_string<Ty0>(): String
7StLoc[10](loc5: String)
8CopyLoc[2](Arg2: u64)
9LdU64(0)
10Gt
11BrFalse(13)
B1:
12Branch(19)
B2:
13MoveLoc[11](loc6: &mut UID)
14Pop
15MoveLoc[4](Arg4: &mut TxContext)
16Pop
17Call errors::zero_amount(): u64
18Abort
B3:
19CopyLoc[11](loc6: &mut UID)
20CopyLoc[10](loc5: String)
21StLoc[5](loc0: String)
22FreezeRef
23MoveLoc[5](loc0: String)
24Call dynamic_field::exists_<String>(&UID, String): bool
25BrFalse(27)
B4:
26Branch(33)
B5:
27MoveLoc[11](loc6: &mut UID)
28Pop
29MoveLoc[4](Arg4: &mut TxContext)
30Pop
31Call errors::fee_coin_not_supported(): u64
32Abort
B6:
33MoveLoc[11](loc6: &mut UID)
34CopyLoc[10](loc5: String)
35Call dynamic_field::borrow_mut<String, Balance<Ty0>>(&mut UID, String): &mut Balance<Ty0>
36StLoc[6](loc1: &mut Balance<Ty0>)
37CopyLoc[6](loc1: &mut Balance<Ty0>)
38FreezeRef
39Call balance::value<Ty0>(&Balance<Ty0>): u64
40StLoc[8](loc3: u64)
41CopyLoc[8](loc3: u64)
42CopyLoc[2](Arg2: u64)
43Ge
44BrFalse(46)
B7:
45Branch(52)
B8:
46MoveLoc[4](Arg4: &mut TxContext)
47Pop
48MoveLoc[6](loc1: &mut Balance<Ty0>)
49Pop
50Call errors::insufficient_amount(): u64
51Abort
B9:
52CopyLoc[6](loc1: &mut Balance<Ty0>)
53CopyLoc[2](Arg2: u64)
54Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
55StLoc[9](loc4: Balance<Ty0>)
56MoveLoc[6](loc1: &mut Balance<Ty0>)
57FreezeRef
58Call balance::value<Ty0>(&Balance<Ty0>): u64
59StLoc[7](loc2: u64)
60MoveLoc[9](loc4: Balance<Ty0>)
61CopyLoc[3](Arg3: address)
62MoveLoc[4](Arg4: &mut TxContext)
63Call utils::transfer_balance<Ty0>(Balance<Ty0>, address, &mut TxContext)
64MoveLoc[10](loc5: String)
65MoveLoc[2](Arg2: u64)
66MoveLoc[3](Arg3: address)
67MoveLoc[8](loc3: u64)
68MoveLoc[7](loc2: u64)
69Call events::emit_pool_creation_fee_claimed(String, u64, address, u64, u64)
70Ret
}
entry add_reward_reserves_to_pool<Ty0, Ty1, Ty2>(Arg0: &AdminCap, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Coin<Ty2>) {
B0:
0MoveLoc[1](Arg1: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3MoveLoc[3](Arg3: Coin<Ty2>)
4Call coin::into_balance<Ty2>(Coin<Ty2>): Balance<Ty2>
5Call pool::increase_reward_coin_reserves<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1>, Balance<Ty2>)
6Ret
}
entry set_pool_icon_url<Ty0, Ty1>(Arg0: &AdminCap, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: String) {
B0:
0MoveLoc[1](Arg1: &GlobalConfig)
1Call config::verify_version(&GlobalConfig)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3MoveLoc[3](Arg3: String)
4Call pool::set_pool_icon_url<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, String)
5Ret
}
}