interface
Module0x1c54…f9f0
- Move path
- 0x1c54…f9f0::interface
- Functions
- 99 public, 8 entry
- Structs
- 0
- Friend modules
- None
Bytecode678 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module 1c546375729ff951aae57fbd4711168f5d321df22e00a86f6d9bdf6317baf9f0.interface {
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::pay;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 1c546375729ff951aae57fbd4711168f5d321df22e00a86f6d9bdf6317baf9f0::event;
use 1c546375729ff951aae57fbd4711168f5d321df22e00a86f6d9bdf6317baf9f0::implements;
use 1c546375729ff951aae57fbd4711168f5d321df22e00a86f6d9bdf6317baf9f0::math;
public get_pool_info<Ty0, Ty1>(Arg0: &mut Global, Arg1: u64, Arg2: bool, Arg3: u256): ID * String * vector<u256> {
L4: loc0: u256
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
L8: loc4: ID
L9: loc5: u256
L10: loc6: u256
L11: loc7: bool
L12: loc8: String
L13: loc9: u64
L14: loc10: u256
L15: loc11: &mut Pool<Ty0, Ty1>
L16: loc12: u256
L17: loc13: u256
L18: loc14: vector<u256>
B0:
0Call implements::is_order<Ty0, Ty1>(): bool
1StLoc[11](loc7: bool)
2MoveLoc[0](Arg0: &mut Global)
3MoveLoc[11](loc7: bool)
4Call implements::get_mut_pool<Ty0, Ty1>(&mut Global, bool): &mut Pool<Ty0, Ty1>
5StLoc[15](loc11: &mut Pool<Ty0, Ty1>)
6CopyLoc[15](loc11: &mut Pool<Ty0, Ty1>)
7FreezeRef
8Call implements::global_id<Ty0, Ty1>(&Pool<Ty0, Ty1>): ID
9StLoc[8](loc4: ID)
10Call implements::generate_lp_name<Ty0, Ty1>(): String
11StLoc[12](loc8: String)
12MoveLoc[15](loc11: &mut Pool<Ty0, Ty1>)
13FreezeRef
14Call implements::get_reserves_size<Ty0, Ty1>(&Pool<Ty0, Ty1>): u64 * u64 * u64
15StLoc[13](loc9: u64)
16StLoc[7](loc3: u64)
17StLoc[6](loc2: u64)
18MoveLoc[2](Arg2: bool)
19BrFalse(40)
B1:
20CopyLoc[1](Arg1: u64)
21CopyLoc[6](loc2: u64)
22CopyLoc[7](loc3: u64)
23Call implements::get_amount_out(u64, u64, u64): u64
24StLoc[5](loc1: u64)
25CopyLoc[6](loc2: u64)
26LdConst[0](u64: 1000..)
27CopyLoc[7](loc3: u64)
28Call math::mul_div_to_u256(u64, u64, u64): u256
29StLoc[10](loc6: u256)
30CopyLoc[6](loc2: u64)
31CopyLoc[1](Arg1: u64)
32Add
33LdConst[0](u64: 1000..)
34CopyLoc[7](loc3: u64)
35CopyLoc[5](loc1: u64)
36Sub
37Call math::mul_div_to_u256(u64, u64, u64): u256
38StLoc[16](loc12: u256)
39Branch(59)
B2:
40CopyLoc[1](Arg1: u64)
41CopyLoc[7](loc3: u64)
42CopyLoc[6](loc2: u64)
43Call implements::get_amount_out(u64, u64, u64): u64
44StLoc[5](loc1: u64)
45CopyLoc[7](loc3: u64)
46LdConst[0](u64: 1000..)
47CopyLoc[6](loc2: u64)
48Call math::mul_div_to_u256(u64, u64, u64): u256
49StLoc[10](loc6: u256)
50CopyLoc[7](loc3: u64)
51CopyLoc[1](Arg1: u64)
52Add
53LdConst[0](u64: 1000..)
54CopyLoc[6](loc2: u64)
55CopyLoc[5](loc1: u64)
56Sub
57Call math::mul_div_to_u256(u64, u64, u64): u256
58StLoc[16](loc12: u256)
B3:
59CopyLoc[16](loc12: u256)
60CopyLoc[10](loc6: u256)
61Sub
62LdConst[0](u64: 1000..)
63CastU256
64Mul
65CopyLoc[10](loc6: u256)
66Div
67StLoc[17](loc13: u256)
68MoveLoc[1](Arg1: u64)
69CastU256
70LdConst[0](u64: 1000..)
71CastU256
72Mul
73CopyLoc[10](loc6: u256)
74Div
75StLoc[9](loc5: u256)
76CopyLoc[3](Arg3: u256)
77LdConst[0](u64: 1000..)
78CastU256
79Ge
80BrFalse(84)
B4:
81LdU256(0)
82StLoc[4](loc0: u256)
83Branch(93)
B5:
84CopyLoc[9](loc5: u256)
85MoveLoc[9](loc5: u256)
86MoveLoc[3](Arg3: u256)
87Mul
88LdConst[0](u64: 1000..)
89CastU256
90Div
91Sub
92StLoc[4](loc0: u256)
B6:
93MoveLoc[4](loc0: u256)
94StLoc[14](loc10: u256)
95VecPack(21, 0)
96StLoc[18](loc14: vector<u256>)
97MutBorrowLoc[18](loc14: vector<u256>)
98MoveLoc[6](loc2: u64)
99CastU256
100VecPushBack(21)
101MutBorrowLoc[18](loc14: vector<u256>)
102MoveLoc[7](loc3: u64)
103CastU256
104VecPushBack(21)
105MutBorrowLoc[18](loc14: vector<u256>)
106MoveLoc[13](loc9: u64)
107CastU256
108VecPushBack(21)
109MutBorrowLoc[18](loc14: vector<u256>)
110MoveLoc[5](loc1: u64)
111CastU256
112VecPushBack(21)
113MutBorrowLoc[18](loc14: vector<u256>)
114MoveLoc[14](loc10: u256)
115VecPushBack(21)
116MutBorrowLoc[18](loc14: vector<u256>)
117LdConst[0](u64: 1000..)
118CastU256
119VecPushBack(21)
120MutBorrowLoc[18](loc14: vector<u256>)
121MoveLoc[10](loc6: u256)
122VecPushBack(21)
123MutBorrowLoc[18](loc14: vector<u256>)
124MoveLoc[16](loc12: u256)
125VecPushBack(21)
126MutBorrowLoc[18](loc14: vector<u256>)
127MoveLoc[17](loc13: u256)
128VecPushBack(21)
129MoveLoc[8](loc4: ID)
130MoveLoc[12](loc8: String)
131MoveLoc[18](loc14: vector<u256>)
132Ret
}
entry public add_liquidity<Ty0, Ty1>(Arg0: &mut Global, Arg1: Coin<Ty0>, Arg2: u64, Arg3: Coin<Ty1>, Arg4: u64, Arg5: &mut TxContext) {
L6: loc0: u64
L7: loc1: u64
L8: loc2: ID
L9: loc3: bool
L10: loc4: Coin<LP<Ty0, Ty1>>
L11: loc5: String
L12: loc6: u64
L13: loc7: &mut Pool<Ty0, Ty1>
L14: loc8: vector<u64>
B0:
0CopyLoc[0](Arg0: &mut Global)
1FreezeRef
2Call implements::is_emergency(&Global): bool
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut Global)
7Pop
8MoveLoc[5](Arg5: &mut TxContext)
9Pop
10LdConst[2](u64: 102)
11Abort
B3:
12Call implements::is_order<Ty0, Ty1>(): bool
13StLoc[9](loc3: bool)
14CopyLoc[0](Arg0: &mut Global)
15FreezeRef
16Call implements::has_registered<Ty0, Ty1>(&Global): bool
17Not
18BrFalse(22)
B4:
19CopyLoc[0](Arg0: &mut Global)
20CopyLoc[9](loc3: bool)
21Call implements::register_pool<Ty0, Ty1>(&mut Global, bool)
B5:
22MoveLoc[0](Arg0: &mut Global)
23CopyLoc[9](loc3: bool)
24Call implements::get_mut_pool<Ty0, Ty1>(&mut Global, bool): &mut Pool<Ty0, Ty1>
25StLoc[13](loc7: &mut Pool<Ty0, Ty1>)
26CopyLoc[13](loc7: &mut Pool<Ty0, Ty1>)
27MoveLoc[1](Arg1: Coin<Ty0>)
28MoveLoc[2](Arg2: u64)
29MoveLoc[3](Arg3: Coin<Ty1>)
30MoveLoc[4](Arg4: u64)
31MoveLoc[9](loc3: bool)
32CopyLoc[5](Arg5: &mut TxContext)
33Call implements::add_liquidity<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Coin<Ty0>, u64, Coin<Ty1>, u64, bool, &mut TxContext): Coin<LP<Ty0, Ty1>> * vector<u64>
34StLoc[14](loc8: vector<u64>)
35StLoc[10](loc4: Coin<LP<Ty0, Ty1>>)
36ImmBorrowLoc[14](loc8: vector<u64>)
37VecLen(20)
38LdU64(3)
39Eq
40BrFalse(42)
B6:
41Branch(48)
B7:
42MoveLoc[13](loc7: &mut Pool<Ty0, Ty1>)
43Pop
44MoveLoc[5](Arg5: &mut TxContext)
45Pop
46LdConst[4](u64: 104)
47Abort
B8:
48MutBorrowLoc[14](loc8: vector<u64>)
49VecPopBack(20)
50StLoc[12](loc6: u64)
51MutBorrowLoc[14](loc8: vector<u64>)
52VecPopBack(20)
53StLoc[6](loc0: u64)
54MutBorrowLoc[14](loc8: vector<u64>)
55VecPopBack(20)
56StLoc[7](loc1: u64)
57MoveLoc[10](loc4: Coin<LP<Ty0, Ty1>>)
58MoveLoc[5](Arg5: &mut TxContext)
59FreezeRef
60Call tx_context::sender(&TxContext): address
61Call transfer::public_transfer<Coin<LP<Ty0, Ty1>>>(Coin<LP<Ty0, Ty1>>, address)
62MoveLoc[13](loc7: &mut Pool<Ty0, Ty1>)
63FreezeRef
64Call implements::global_id<Ty0, Ty1>(&Pool<Ty0, Ty1>): ID
65StLoc[8](loc2: ID)
66Call implements::generate_lp_name<Ty0, Ty1>(): String
67StLoc[11](loc5: String)
68MoveLoc[8](loc2: ID)
69MoveLoc[11](loc5: String)
70MoveLoc[6](loc0: u64)
71MoveLoc[7](loc1: u64)
72MoveLoc[12](loc6: u64)
73Call event::added_event(ID, String, u64, u64, u64)
74Ret
}
entry public remove_liquidity<Ty0, Ty1>(Arg0: &mut Global, Arg1: Coin<LP<Ty0, Ty1>>, Arg2: &mut TxContext) {
L3: loc0: Coin<Ty0>
L4: loc1: u64
L5: loc2: Coin<Ty1>
L6: loc3: u64
L7: loc4: ID
L8: loc5: bool
L9: loc6: String
L10: loc7: u64
L11: loc8: &mut Pool<Ty0, Ty1>
B0:
0CopyLoc[0](Arg0: &mut Global)
1FreezeRef
2Call implements::is_emergency(&Global): bool
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut Global)
7Pop
8MoveLoc[2](Arg2: &mut TxContext)
9Pop
10LdConst[2](u64: 102)
11Abort
B3:
12Call implements::is_order<Ty0, Ty1>(): bool
13StLoc[8](loc5: bool)
14MoveLoc[0](Arg0: &mut Global)
15CopyLoc[8](loc5: bool)
16Call implements::get_mut_pool<Ty0, Ty1>(&mut Global, bool): &mut Pool<Ty0, Ty1>
17StLoc[11](loc8: &mut Pool<Ty0, Ty1>)
18ImmBorrowLoc[1](Arg1: Coin<LP<Ty0, Ty1>>)
19Call coin::value<LP<Ty0, Ty1>>(&Coin<LP<Ty0, Ty1>>): u64
20StLoc[10](loc7: u64)
21CopyLoc[11](loc8: &mut Pool<Ty0, Ty1>)
22MoveLoc[1](Arg1: Coin<LP<Ty0, Ty1>>)
23MoveLoc[8](loc5: bool)
24CopyLoc[2](Arg2: &mut TxContext)
25Call implements::remove_liquidity<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Coin<LP<Ty0, Ty1>>, bool, &mut TxContext): Coin<Ty0> * Coin<Ty1>
26StLoc[5](loc2: Coin<Ty1>)
27StLoc[3](loc0: Coin<Ty0>)
28ImmBorrowLoc[3](loc0: Coin<Ty0>)
29Call coin::value<Ty0>(&Coin<Ty0>): u64
30StLoc[4](loc1: u64)
31ImmBorrowLoc[5](loc2: Coin<Ty1>)
32Call coin::value<Ty1>(&Coin<Ty1>): u64
33StLoc[6](loc3: u64)
34MoveLoc[3](loc0: Coin<Ty0>)
35CopyLoc[2](Arg2: &mut TxContext)
36FreezeRef
37Call tx_context::sender(&TxContext): address
38Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
39MoveLoc[5](loc2: Coin<Ty1>)
40MoveLoc[2](Arg2: &mut TxContext)
41FreezeRef
42Call tx_context::sender(&TxContext): address
43Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)
44MoveLoc[11](loc8: &mut Pool<Ty0, Ty1>)
45FreezeRef
46Call implements::global_id<Ty0, Ty1>(&Pool<Ty0, Ty1>): ID
47StLoc[7](loc4: ID)
48Call implements::generate_lp_name<Ty0, Ty1>(): String
49StLoc[9](loc6: String)
50MoveLoc[7](loc4: ID)
51MoveLoc[9](loc6: String)
52MoveLoc[4](loc1: u64)
53MoveLoc[6](loc3: u64)
54MoveLoc[10](loc7: u64)
55Call event::removed_event(ID, String, u64, u64, u64)
56Ret
}
entry public swap<Ty0, Ty1>(Arg0: &mut Global, Arg1: Coin<Ty0>, Arg2: u64, Arg3: &mut TxContext) {
L4: loc0: u64
L5: loc1: u64
L6: loc2: u64
L7: loc3: u64
L8: loc4: ID
L9: loc5: bool
L10: loc6: String
L11: loc7: vector<u64>
B0:
0CopyLoc[0](Arg0: &mut Global)
1FreezeRef
2Call implements::is_emergency(&Global): bool
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut Global)
7Pop
8MoveLoc[3](Arg3: &mut TxContext)
9Pop
10LdConst[2](u64: 102)
11Abort
B3:
12Call implements::is_order<Ty0, Ty1>(): bool
13StLoc[9](loc5: bool)
14CopyLoc[0](Arg0: &mut Global)
15MoveLoc[1](Arg1: Coin<Ty0>)
16MoveLoc[2](Arg2: u64)
17MoveLoc[9](loc5: bool)
18MoveLoc[3](Arg3: &mut TxContext)
19Call implements::swap_out<Ty0, Ty1>(&mut Global, Coin<Ty0>, u64, bool, &mut TxContext): vector<u64>
20StLoc[11](loc7: vector<u64>)
21MutBorrowLoc[11](loc7: vector<u64>)
22VecPopBack(20)
23StLoc[7](loc3: u64)
24MutBorrowLoc[11](loc7: vector<u64>)
25VecPopBack(20)
26StLoc[6](loc2: u64)
27MutBorrowLoc[11](loc7: vector<u64>)
28VecPopBack(20)
29StLoc[5](loc1: u64)
30MutBorrowLoc[11](loc7: vector<u64>)
31VecPopBack(20)
32StLoc[4](loc0: u64)
33MoveLoc[0](Arg0: &mut Global)
34FreezeRef
35Call implements::id<Ty0, Ty1>(&Global): ID
36StLoc[8](loc4: ID)
37Call implements::generate_lp_name<Ty0, Ty1>(): String
38StLoc[10](loc6: String)
39MoveLoc[8](loc4: ID)
40MoveLoc[10](loc6: String)
41MoveLoc[4](loc0: u64)
42MoveLoc[5](loc1: u64)
43MoveLoc[6](loc2: u64)
44MoveLoc[7](loc3: u64)
45Call event::swapped_event(ID, String, u64, u64, u64, u64)
46Ret
}
entry public multi_add_liquidity<Ty0, Ty1>(Arg0: &mut Global, Arg1: vector<Coin<Ty0>>, Arg2: u64, Arg3: u64, Arg4: vector<Coin<Ty1>>, Arg5: u64, Arg6: u64, Arg7: &mut TxContext) {
L8: loc0: bool
L9: loc1: Coin<Ty0>
L10: loc2: Coin<Ty1>
L11: loc3: Coin<Ty0>
L12: loc4: Coin<Ty1>
B0:
0CopyLoc[0](Arg0: &mut Global)
1FreezeRef
2Call implements::is_emergency(&Global): bool
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut Global)
7Pop
8MoveLoc[7](Arg7: &mut TxContext)
9Pop
10LdConst[2](u64: 102)
11Abort
B3:
12ImmBorrowLoc[1](Arg1: vector<Coin<Ty0>>)
13Call vector::is_empty<Coin<Ty0>>(&vector<Coin<Ty0>>): bool
14Not
15BrFalse(21)
B4:
16ImmBorrowLoc[4](Arg4: vector<Coin<Ty1>>)
17Call vector::is_empty<Coin<Ty1>>(&vector<Coin<Ty1>>): bool
18Not
19StLoc[8](loc0: bool)
20Branch(23)
B5:
21LdFalse
22StLoc[8](loc0: bool)
B6:
23MoveLoc[8](loc0: bool)
24BrFalse(26)
B7:
25Branch(32)
B8:
26MoveLoc[0](Arg0: &mut Global)
27Pop
28MoveLoc[7](Arg7: &mut TxContext)
29Pop
30LdConst[5](u64: 105)
31Abort
B9:
32MutBorrowLoc[1](Arg1: vector<Coin<Ty0>>)
33VecPopBack(38)
34StLoc[11](loc3: Coin<Ty0>)
35MutBorrowLoc[11](loc3: Coin<Ty0>)
36MoveLoc[1](Arg1: vector<Coin<Ty0>>)
37Call pay::join_vec<Ty0>(&mut Coin<Ty0>, vector<Coin<Ty0>>)
38MutBorrowLoc[11](loc3: Coin<Ty0>)
39MoveLoc[2](Arg2: u64)
40CopyLoc[7](Arg7: &mut TxContext)
41Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
42StLoc[9](loc1: Coin<Ty0>)
43MutBorrowLoc[4](Arg4: vector<Coin<Ty1>>)
44VecPopBack(39)
45StLoc[12](loc4: Coin<Ty1>)
46MutBorrowLoc[12](loc4: Coin<Ty1>)
47MoveLoc[4](Arg4: vector<Coin<Ty1>>)
48Call pay::join_vec<Ty1>(&mut Coin<Ty1>, vector<Coin<Ty1>>)
49MutBorrowLoc[12](loc4: Coin<Ty1>)
50MoveLoc[5](Arg5: u64)
51CopyLoc[7](Arg7: &mut TxContext)
52Call coin::split<Ty1>(&mut Coin<Ty1>, u64, &mut TxContext): Coin<Ty1>
53StLoc[10](loc2: Coin<Ty1>)
54MoveLoc[0](Arg0: &mut Global)
55MoveLoc[9](loc1: Coin<Ty0>)
56MoveLoc[3](Arg3: u64)
57MoveLoc[10](loc2: Coin<Ty1>)
58MoveLoc[6](Arg6: u64)
59CopyLoc[7](Arg7: &mut TxContext)
60Call add_liquidity<Ty0, Ty1>(&mut Global, Coin<Ty0>, u64, Coin<Ty1>, u64, &mut TxContext)
61ImmBorrowLoc[11](loc3: Coin<Ty0>)
62Call coin::value<Ty0>(&Coin<Ty0>): u64
63LdU64(0)
64Gt
65BrFalse(72)
B10:
66MoveLoc[11](loc3: Coin<Ty0>)
67CopyLoc[7](Arg7: &mut TxContext)
68FreezeRef
69Call tx_context::sender(&TxContext): address
70Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
71Branch(74)
B11:
72MoveLoc[11](loc3: Coin<Ty0>)
73Call coin::destroy_zero<Ty0>(Coin<Ty0>)
B12:
74ImmBorrowLoc[12](loc4: Coin<Ty1>)
75Call coin::value<Ty1>(&Coin<Ty1>): u64
76LdU64(0)
77Gt
78BrFalse(85)
B13:
79MoveLoc[12](loc4: Coin<Ty1>)
80MoveLoc[7](Arg7: &mut TxContext)
81FreezeRef
82Call tx_context::sender(&TxContext): address
83Call transfer::public_transfer<Coin<Ty1>>(Coin<Ty1>, address)
84Branch(89)
B14:
85MoveLoc[7](Arg7: &mut TxContext)
86Pop
87MoveLoc[12](loc4: Coin<Ty1>)
88Call coin::destroy_zero<Ty1>(Coin<Ty1>)
B15:
89Ret
}
entry public multi_remove_liquidity<Ty0, Ty1>(Arg0: &mut Global, Arg1: vector<Coin<LP<Ty0, Ty1>>>, Arg2: &mut TxContext) {
L3: loc0: Coin<LP<Ty0, Ty1>>
B0:
0CopyLoc[0](Arg0: &mut Global)
1FreezeRef
2Call implements::is_emergency(&Global): bool
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut Global)
7Pop
8MoveLoc[2](Arg2: &mut TxContext)
9Pop
10LdConst[2](u64: 102)
11Abort
B3:
12ImmBorrowLoc[1](Arg1: vector<Coin<LP<Ty0, Ty1>>>)
13Call vector::is_empty<Coin<LP<Ty0, Ty1>>>(&vector<Coin<LP<Ty0, Ty1>>>): bool
14Not
15BrFalse(17)
B4:
16Branch(23)
B5:
17MoveLoc[0](Arg0: &mut Global)
18Pop
19MoveLoc[2](Arg2: &mut TxContext)
20Pop
21LdConst[5](u64: 105)
22Abort
B6:
23MutBorrowLoc[1](Arg1: vector<Coin<LP<Ty0, Ty1>>>)
24VecPopBack(28)
25StLoc[3](loc0: Coin<LP<Ty0, Ty1>>)
26MutBorrowLoc[3](loc0: Coin<LP<Ty0, Ty1>>)
27MoveLoc[1](Arg1: vector<Coin<LP<Ty0, Ty1>>>)
28Call pay::join_vec<LP<Ty0, Ty1>>(&mut Coin<LP<Ty0, Ty1>>, vector<Coin<LP<Ty0, Ty1>>>)
29MoveLoc[0](Arg0: &mut Global)
30MoveLoc[3](loc0: Coin<LP<Ty0, Ty1>>)
31MoveLoc[2](Arg2: &mut TxContext)
32Call remove_liquidity<Ty0, Ty1>(&mut Global, Coin<LP<Ty0, Ty1>>, &mut TxContext)
33Ret
}
entry public multi_swap<Ty0, Ty1>(Arg0: &mut Global, Arg1: vector<Coin<Ty0>>, Arg2: u64, Arg3: u64, Arg4: &mut TxContext) {
L5: loc0: Coin<Ty0>
L6: loc1: Coin<Ty0>
B0:
0CopyLoc[0](Arg0: &mut Global)
1FreezeRef
2Call implements::is_emergency(&Global): bool
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut Global)
7Pop
8MoveLoc[4](Arg4: &mut TxContext)
9Pop
10LdConst[2](u64: 102)
11Abort
B3:
12ImmBorrowLoc[1](Arg1: vector<Coin<Ty0>>)
13Call vector::is_empty<Coin<Ty0>>(&vector<Coin<Ty0>>): bool
14Not
15BrFalse(17)
B4:
16Branch(23)
B5:
17MoveLoc[0](Arg0: &mut Global)
18Pop
19MoveLoc[4](Arg4: &mut TxContext)
20Pop
21LdConst[5](u64: 105)
22Abort
B6:
23MutBorrowLoc[1](Arg1: vector<Coin<Ty0>>)
24VecPopBack(38)
25StLoc[6](loc1: Coin<Ty0>)
26MutBorrowLoc[6](loc1: Coin<Ty0>)
27MoveLoc[1](Arg1: vector<Coin<Ty0>>)
28Call pay::join_vec<Ty0>(&mut Coin<Ty0>, vector<Coin<Ty0>>)
29MutBorrowLoc[6](loc1: Coin<Ty0>)
30MoveLoc[2](Arg2: u64)
31CopyLoc[4](Arg4: &mut TxContext)
32Call coin::split<Ty0>(&mut Coin<Ty0>, u64, &mut TxContext): Coin<Ty0>
33StLoc[5](loc0: Coin<Ty0>)
34MoveLoc[0](Arg0: &mut Global)
35MoveLoc[5](loc0: Coin<Ty0>)
36MoveLoc[3](Arg3: u64)
37CopyLoc[4](Arg4: &mut TxContext)
38Call swap<Ty0, Ty1>(&mut Global, Coin<Ty0>, u64, &mut TxContext)
39ImmBorrowLoc[6](loc1: Coin<Ty0>)
40Call coin::value<Ty0>(&Coin<Ty0>): u64
41LdU64(0)
42Gt
43BrFalse(50)
B7:
44MoveLoc[6](loc1: Coin<Ty0>)
45MoveLoc[4](Arg4: &mut TxContext)
46FreezeRef
47Call tx_context::sender(&TxContext): address
48Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
49Branch(54)
B8:
50MoveLoc[4](Arg4: &mut TxContext)
51Pop
52MoveLoc[6](loc1: Coin<Ty0>)
53Call coin::destroy_zero<Ty0>(Coin<Ty0>)
B9:
54Ret
}
entry public swap_v2<Ty0, Ty1>(Arg0: &Clock, Arg1: &mut Global, Arg2: Coin<Ty0>, Arg3: u64, Arg4: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut Global)
1MoveLoc[2](Arg2: Coin<Ty0>)
2MoveLoc[3](Arg3: u64)
3CopyLoc[4](Arg4: &mut TxContext)
4Call swap<Ty0, Ty1>(&mut Global, Coin<Ty0>, u64, &mut TxContext)
5MoveLoc[1](Arg1: &mut Global)
6MoveLoc[0](Arg0: &Clock)
7MoveLoc[4](Arg4: &mut TxContext)
8FreezeRef
9Call tx_context::sender(&TxContext): address
10LdU64(5)
11Call implements::add_points(&mut Global, &Clock, address, u64)
12Ret
}
entry public add_liquidity_v2<Ty0, Ty1>(Arg0: &Clock, Arg1: &mut Global, Arg2: Coin<Ty0>, Arg3: u64, Arg4: Coin<Ty1>, Arg5: u64, Arg6: &mut TxContext) {
B0:
0CopyLoc[1](Arg1: &mut Global)
1MoveLoc[2](Arg2: Coin<Ty0>)
2MoveLoc[3](Arg3: u64)
3MoveLoc[4](Arg4: Coin<Ty1>)
4MoveLoc[5](Arg5: u64)
5CopyLoc[6](Arg6: &mut TxContext)
6Call add_liquidity<Ty0, Ty1>(&mut Global, Coin<Ty0>, u64, Coin<Ty1>, u64, &mut TxContext)
7MoveLoc[1](Arg1: &mut Global)
8MoveLoc[0](Arg0: &Clock)
9MoveLoc[6](Arg6: &mut TxContext)
10FreezeRef
11Call tx_context::sender(&TxContext): address
12LdU64(5)
13Call implements::add_points(&mut Global, &Clock, address, u64)
14Ret
}
Constants [
0 => u64: 1000000000000000000
1 => u64: 101
2 => u64: 102
3 => u64: 103
4 => u64: 104
5 => u64: 105
]
}