m
Module0xdfd3…93a3
- Move path
- 0x6c3d…d287::m
- Functions
- 4343 public, 0 entry
- Structs
- 0
- Friend modules
- None
m
Bytecode1065 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module 6c3d27609b46c3d0f110a247a81e07fdb48465837bbfeace0bee7bc78233d287.m {
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::config;
use 3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::pool;
use b24b6789e088b876afabca733bed2299fbc9e2d6369be4d1acfa17d8145454d9::router;
use b24b6789e088b876afabca733bed2299fbc9e2d6369be4d1acfa17d8145454d9::swap;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::config as 0config;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool as 0pool;
use dae28ab9ab072c647c4e8f2057a8f17dcc4847e42d6a8258df4b376ae183c872::manage;
use dae28ab9ab072c647c4e8f2057a8f17dcc4847e42d6a8258df4b376ae183c872::router as 0router;
use 5a5c1d10e4782dbbdec3eb8327ede04bd078b294b97cfdba447b11b846b383ac::config as 1config;
use 5a5c1d10e4782dbbdec3eb8327ede04bd078b294b97cfdba447b11b846b383ac::lb_pair;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::pool_manager;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::swap_router;
use 25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::versioned;
use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::config as 2config;
use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::pool as 1pool;
use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::rewarder;
use e74104c66dd9f16b3096db2cc00300e556aa92edc871be4bc052b5dfb80db239::stats;
use b49be008cf304b1dae7e7ece661b5f1b0e15324bc1422ec8c73b10eb4a6dcb19::price_provider;
use a0eba10b173538c8fecca1dff298e488402cc9ff374f8a12ca7758eebe830b66::spot_dex;
use 70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::pool as 2pool;
use 70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::trade;
use 70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::version;
use b84e63d22ea4822a0a333c250e790f69bf5c2ef0c63f4e120e05a6415991368f::v2;
use a0e3b011012b80af4957afa30e556486eb3da0a7d96eeb733cf16ccd3aec32e0::oracle_driven_pool;
use a0e3b011012b80af4957afa30e556486eb3da0a7d96eeb733cf16ccd3aec32e0::trader;
use 8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e::price_info;
use 8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e::state;
use efe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::market;
use efe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::mint;
use efe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::redeem;
use efe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::reserve;
use efe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::version as 0version;
use 80ca577876dec91ae6d22090e56c39bc60dce9086ab0729930c6900bc4162b4c::s_coin_converter;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool as 3pool;
use 91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::swap_router as 0swap_router;
public gc<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u128, Arg2: bool) {
L3: loc0: bool
L4: loc1: u128
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1FreezeRef
2Call 0pool::current_sqrt_price<Ty0, Ty1>(&Pool<Ty0, Ty1>): u128
3StLoc[4](loc1: u128)
4MoveLoc[2](Arg2: bool)
5BrFalse(11)
B1:
6MoveLoc[4](loc1: u128)
7MoveLoc[1](Arg1: u128)
8Ge
9StLoc[3](loc0: bool)
10Branch(15)
B2:
11MoveLoc[4](loc1: u128)
12MoveLoc[1](Arg1: u128)
13Le
14StLoc[3](loc0: bool)
B3:
15MoveLoc[3](loc0: bool)
16BrFalse(18)
B4:
17Branch(20)
B5:
18LdConst[1](u64: 101)
19Abort
B6:
20Ret
}
public gb<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: u128, Arg2: bool) {
L3: loc0: bool
L4: loc1: u128
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1FreezeRef
2Call pool::current_sqrt_price<Ty0, Ty1>(&Pool<Ty0, Ty1>): u128
3StLoc[4](loc1: u128)
4MoveLoc[2](Arg2: bool)
5BrFalse(11)
B1:
6MoveLoc[4](loc1: u128)
7MoveLoc[1](Arg1: u128)
8Ge
9StLoc[3](loc0: bool)
10Branch(15)
B2:
11MoveLoc[4](loc1: u128)
12MoveLoc[1](Arg1: u128)
13Le
14StLoc[3](loc0: bool)
B3:
15MoveLoc[3](loc0: bool)
16BrFalse(18)
B4:
17Branch(20)
B5:
18LdConst[1](u64: 101)
19Abort
B6:
20Ret
}
public ca<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Clock, Arg3: Balance<Ty0>, Arg4: u128): Balance<Ty1> {
L5: loc0: u64
L6: loc1: Balance<Ty1>
L7: loc2: FlashSwapReceipt<Ty0, Ty1>
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[5](loc0: u64)
3CopyLoc[0](Arg0: &GlobalConfig)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5LdTrue
6LdTrue
7MoveLoc[5](loc0: u64)
8MoveLoc[4](Arg4: u128)
9MoveLoc[2](Arg2: &Clock)
10Call 0pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
11StLoc[7](loc2: FlashSwapReceipt<Ty0, Ty1>)
12StLoc[6](loc1: Balance<Ty1>)
13Call balance::destroy_zero<Ty0>(Balance<Ty0>)
14MoveLoc[0](Arg0: &GlobalConfig)
15MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
16MoveLoc[3](Arg3: Balance<Ty0>)
17Call balance::zero<Ty1>(): Balance<Ty1>
18MoveLoc[7](loc2: FlashSwapReceipt<Ty0, Ty1>)
19Call 0pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
20MoveLoc[6](loc1: Balance<Ty1>)
21Ret
}
public cb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Clock, Arg3: Balance<Ty1>, Arg4: u128): Balance<Ty0> {
L5: loc0: u64
L6: loc1: Balance<Ty0>
L7: loc2: FlashSwapReceipt<Ty0, Ty1>
L8: loc3: Balance<Ty1>
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty1>)
1Call balance::value<Ty1>(&Balance<Ty1>): u64
2StLoc[5](loc0: u64)
3CopyLoc[0](Arg0: &GlobalConfig)
4CopyLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
5LdFalse
6LdTrue
7MoveLoc[5](loc0: u64)
8MoveLoc[4](Arg4: u128)
9MoveLoc[2](Arg2: &Clock)
10Call 0pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
11StLoc[7](loc2: FlashSwapReceipt<Ty0, Ty1>)
12StLoc[8](loc3: Balance<Ty1>)
13StLoc[6](loc1: Balance<Ty0>)
14MoveLoc[8](loc3: Balance<Ty1>)
15Call balance::destroy_zero<Ty1>(Balance<Ty1>)
16MoveLoc[0](Arg0: &GlobalConfig)
17MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
18Call balance::zero<Ty0>(): Balance<Ty0>
19MoveLoc[3](Arg3: Balance<Ty1>)
20MoveLoc[7](loc2: FlashSwapReceipt<Ty0, Ty1>)
21Call 0pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
22MoveLoc[6](loc1: Balance<Ty0>)
23Ret
}
public la<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Clock, Arg3: u64, Arg4: u128): Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {
L5: loc0: Balance<Ty1>
L6: loc1: FlashSwapReceipt<Ty0, Ty1>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2LdTrue
3LdTrue
4MoveLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: u128)
6MoveLoc[2](Arg2: &Clock)
7Call 0pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
8StLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
9StLoc[5](loc0: Balance<Ty1>)
10Call balance::destroy_zero<Ty0>(Balance<Ty0>)
11MoveLoc[5](loc0: Balance<Ty1>)
12MoveLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
13Ret
}
public lb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: &Clock, Arg3: u64, Arg4: u128): Balance<Ty0> * FlashSwapReceipt<Ty0, Ty1> {
L5: loc0: Balance<Ty0>
L6: loc1: FlashSwapReceipt<Ty0, Ty1>
L7: loc2: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2LdFalse
3LdTrue
4MoveLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: u128)
6MoveLoc[2](Arg2: &Clock)
7Call 0pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
8StLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
9StLoc[7](loc2: Balance<Ty1>)
10StLoc[5](loc0: Balance<Ty0>)
11MoveLoc[7](loc2: Balance<Ty1>)
12Call balance::destroy_zero<Ty1>(Balance<Ty1>)
13MoveLoc[5](loc0: Balance<Ty0>)
14MoveLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
15Ret
}
public lra<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: FlashSwapReceipt<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: Balance<Ty0>)
3Call balance::zero<Ty1>(): Balance<Ty1>
4MoveLoc[3](Arg3: FlashSwapReceipt<Ty0, Ty1>)
5Call 0pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
6Ret
}
public lrb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty1>, Arg3: FlashSwapReceipt<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2Call balance::zero<Ty0>(): Balance<Ty0>
3MoveLoc[2](Arg2: Balance<Ty1>)
4MoveLoc[3](Arg3: FlashSwapReceipt<Ty0, Ty1>)
5Call 0pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
6Ret
}
public fla<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: u64, Arg4: u128): Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {
L5: loc0: Balance<Ty1>
L6: loc1: FlashSwapReceipt<Ty0, Ty1>
B0:
0MoveLoc[0](Arg0: &Clock)
1MoveLoc[1](Arg1: &GlobalConfig)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3LdTrue
4LdTrue
5MoveLoc[3](Arg3: u64)
6MoveLoc[4](Arg4: u128)
7Call pool::flash_swap<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
8StLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
9StLoc[5](loc0: Balance<Ty1>)
10Call balance::destroy_zero<Ty0>(Balance<Ty0>)
11MoveLoc[5](loc0: Balance<Ty1>)
12MoveLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
13Ret
}
public flb<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: u64, Arg4: u128): Balance<Ty0> * FlashSwapReceipt<Ty0, Ty1> {
L5: loc0: Balance<Ty0>
L6: loc1: FlashSwapReceipt<Ty0, Ty1>
L7: loc2: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &Clock)
1MoveLoc[1](Arg1: &GlobalConfig)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3LdFalse
4LdTrue
5MoveLoc[3](Arg3: u64)
6MoveLoc[4](Arg4: u128)
7Call pool::flash_swap<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
8StLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
9StLoc[7](loc2: Balance<Ty1>)
10StLoc[5](loc0: Balance<Ty0>)
11MoveLoc[7](loc2: Balance<Ty1>)
12Call balance::destroy_zero<Ty1>(Balance<Ty1>)
13MoveLoc[5](loc0: Balance<Ty0>)
14MoveLoc[6](loc1: FlashSwapReceipt<Ty0, Ty1>)
15Ret
}
public flra<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: FlashSwapReceipt<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: Balance<Ty0>)
3Call balance::zero<Ty1>(): Balance<Ty1>
4MoveLoc[3](Arg3: FlashSwapReceipt<Ty0, Ty1>)
5Call pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
6Ret
}
public flrb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty1>, Arg3: FlashSwapReceipt<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2Call balance::zero<Ty0>(): Balance<Ty0>
3MoveLoc[2](Arg2: Balance<Ty1>)
4MoveLoc[3](Arg3: FlashSwapReceipt<Ty0, Ty1>)
5Call pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
6Ret
}
public mla<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Clock, Arg2: &Version, Arg3: u64, Arg4: u128, Arg5: &mut TxContext): Balance<Ty1> * FlashSwapReceipt {
L6: loc0: Balance<Ty1>
L7: loc1: FlashSwapReceipt
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1LdTrue
2LdTrue
3MoveLoc[3](Arg3: u64)
4MoveLoc[4](Arg4: u128)
5MoveLoc[1](Arg1: &Clock)
6MoveLoc[2](Arg2: &Version)
7MoveLoc[5](Arg5: &mut TxContext)
8FreezeRef
9Call trade::flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock, &Version, &TxContext): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt
10StLoc[7](loc1: FlashSwapReceipt)
11StLoc[6](loc0: Balance<Ty1>)
12Call balance::destroy_zero<Ty0>(Balance<Ty0>)
13MoveLoc[6](loc0: Balance<Ty1>)
14MoveLoc[7](loc1: FlashSwapReceipt)
15Ret
}
public mlb<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Clock, Arg2: &Version, Arg3: u64, Arg4: u128, Arg5: &mut TxContext): Balance<Ty0> * FlashSwapReceipt {
L6: loc0: Balance<Ty0>
L7: loc1: FlashSwapReceipt
L8: loc2: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1LdFalse
2LdTrue
3MoveLoc[3](Arg3: u64)
4MoveLoc[4](Arg4: u128)
5MoveLoc[1](Arg1: &Clock)
6MoveLoc[2](Arg2: &Version)
7MoveLoc[5](Arg5: &mut TxContext)
8FreezeRef
9Call trade::flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock, &Version, &TxContext): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt
10StLoc[7](loc1: FlashSwapReceipt)
11StLoc[8](loc2: Balance<Ty1>)
12StLoc[6](loc0: Balance<Ty0>)
13MoveLoc[8](loc2: Balance<Ty1>)
14Call balance::destroy_zero<Ty1>(Balance<Ty1>)
15MoveLoc[6](loc0: Balance<Ty0>)
16MoveLoc[7](loc1: FlashSwapReceipt)
17Ret
}
public mlra<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Version, Arg2: Balance<Ty0>, Arg3: FlashSwapReceipt, Arg4: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1MoveLoc[3](Arg3: FlashSwapReceipt)
2MoveLoc[2](Arg2: Balance<Ty0>)
3Call balance::zero<Ty1>(): Balance<Ty1>
4MoveLoc[1](Arg1: &Version)
5MoveLoc[4](Arg4: &mut TxContext)
6FreezeRef
7Call trade::repay_flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, FlashSwapReceipt, Balance<Ty0>, Balance<Ty1>, &Version, &TxContext)
8Ret
}
public mlrb<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Version, Arg2: Balance<Ty1>, Arg3: FlashSwapReceipt, Arg4: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
1MoveLoc[3](Arg3: FlashSwapReceipt)
2Call balance::zero<Ty0>(): Balance<Ty0>
3MoveLoc[2](Arg2: Balance<Ty1>)
4MoveLoc[1](Arg1: &Version)
5MoveLoc[4](Arg4: &mut TxContext)
6FreezeRef
7Call trade::repay_flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, FlashSwapReceipt, Balance<Ty0>, Balance<Ty1>, &Version, &TxContext)
8Ret
}
public sla<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Stats, Arg4: &PriceProvider, Arg5: &Clock, Arg6: u64, Arg7: u128): Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1> {
L8: loc0: Balance<Ty1>
L9: loc1: FlashSwapReceipt<Ty0, Ty1>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut RewarderGlobalVault)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3LdTrue
4LdTrue
5MoveLoc[6](Arg6: u64)
6MoveLoc[7](Arg7: u128)
7MoveLoc[3](Arg3: &mut Stats)
8MoveLoc[4](Arg4: &PriceProvider)
9MoveLoc[5](Arg5: &Clock)
10Call 1pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut RewarderGlobalVault, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &mut Stats, &PriceProvider, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
11StLoc[9](loc1: FlashSwapReceipt<Ty0, Ty1>)
12StLoc[8](loc0: Balance<Ty1>)
13Call balance::destroy_zero<Ty0>(Balance<Ty0>)
14MoveLoc[8](loc0: Balance<Ty1>)
15MoveLoc[9](loc1: FlashSwapReceipt<Ty0, Ty1>)
16Ret
}
public slb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Stats, Arg4: &PriceProvider, Arg5: &Clock, Arg6: u64, Arg7: u128): Balance<Ty0> * FlashSwapReceipt<Ty0, Ty1> {
L8: loc0: Balance<Ty0>
L9: loc1: FlashSwapReceipt<Ty0, Ty1>
L10: loc2: Balance<Ty1>
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut RewarderGlobalVault)
2MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
3LdFalse
4LdTrue
5MoveLoc[6](Arg6: u64)
6MoveLoc[7](Arg7: u128)
7MoveLoc[3](Arg3: &mut Stats)
8MoveLoc[4](Arg4: &PriceProvider)
9MoveLoc[5](Arg5: &Clock)
10Call 1pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut RewarderGlobalVault, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &mut Stats, &PriceProvider, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
11StLoc[9](loc1: FlashSwapReceipt<Ty0, Ty1>)
12StLoc[10](loc2: Balance<Ty1>)
13StLoc[8](loc0: Balance<Ty0>)
14MoveLoc[10](loc2: Balance<Ty1>)
15Call balance::destroy_zero<Ty1>(Balance<Ty1>)
16MoveLoc[8](loc0: Balance<Ty0>)
17MoveLoc[9](loc1: FlashSwapReceipt<Ty0, Ty1>)
18Ret
}
public slra<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: FlashSwapReceipt<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2MoveLoc[2](Arg2: Balance<Ty0>)
3Call balance::zero<Ty1>(): Balance<Ty1>
4MoveLoc[3](Arg3: FlashSwapReceipt<Ty0, Ty1>)
5Call 1pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
6Ret
}
public slrb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty1>, Arg3: FlashSwapReceipt<Ty0, Ty1>) {
B0:
0MoveLoc[0](Arg0: &GlobalConfig)
1MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
2Call balance::zero<Ty0>(): Balance<Ty0>
3MoveLoc[2](Arg2: Balance<Ty1>)
4MoveLoc[3](Arg3: FlashSwapReceipt<Ty0, Ty1>)
5Call 1pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
6Ret
}
public fa<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Balance<Ty0>, Arg4: u128): Balance<Ty1> {
L5: loc0: u64
L6: loc1: Balance<Ty1>
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[5](loc0: u64)
3MoveLoc[0](Arg0: &Clock)
4MoveLoc[1](Arg1: &GlobalConfig)
5MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
6MoveLoc[3](Arg3: Balance<Ty0>)
7Call balance::zero<Ty1>(): Balance<Ty1>
8LdTrue
9LdTrue
10MoveLoc[5](loc0: u64)
11LdU64(0)
12MoveLoc[4](Arg4: u128)
13Call pool::swap<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, bool, bool, u64, u64, u128): Balance<Ty0> * Balance<Ty1>
14StLoc[6](loc1: Balance<Ty1>)
15Call balance::destroy_zero<Ty0>(Balance<Ty0>)
16MoveLoc[6](loc1: Balance<Ty1>)
17Ret
}
public fb<Ty0, Ty1>(Arg0: &Clock, Arg1: &GlobalConfig, Arg2: &mut Pool<Ty0, Ty1>, Arg3: Balance<Ty1>, Arg4: u128): Balance<Ty0> {
L5: loc0: u64
L6: loc1: Balance<Ty0>
L7: loc2: Balance<Ty1>
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty1>)
1Call balance::value<Ty1>(&Balance<Ty1>): u64
2StLoc[5](loc0: u64)
3MoveLoc[0](Arg0: &Clock)
4MoveLoc[1](Arg1: &GlobalConfig)
5MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
6Call balance::zero<Ty0>(): Balance<Ty0>
7MoveLoc[3](Arg3: Balance<Ty1>)
8LdFalse
9LdTrue
10MoveLoc[5](loc0: u64)
11LdU64(0)
12MoveLoc[4](Arg4: u128)
13Call pool::swap<Ty0, Ty1>(&Clock, &GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, bool, bool, u64, u64, u128): Balance<Ty0> * Balance<Ty1>
14StLoc[7](loc2: Balance<Ty1>)
15StLoc[6](loc1: Balance<Ty0>)
16MoveLoc[7](loc2: Balance<Ty1>)
17Call balance::destroy_zero<Ty1>(Balance<Ty1>)
18MoveLoc[6](loc1: Balance<Ty0>)
19Ret
}
public va<Ty0, Ty1>(Arg0: &mut Dex_Info, Arg1: Balance<Ty0>, Arg2: &mut TxContext): Balance<Ty1> {
L3: loc0: u64
L4: loc1: Coin<Ty0>
B0:
0ImmBorrowLoc[1](Arg1: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[3](loc0: u64)
3MoveLoc[1](Arg1: Balance<Ty0>)
4CopyLoc[2](Arg2: &mut TxContext)
5Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
6StLoc[4](loc1: Coin<Ty0>)
7MoveLoc[3](loc0: u64)
8MoveLoc[4](loc1: Coin<Ty0>)
9LdU64(0)
10MoveLoc[0](Arg0: &mut Dex_Info)
11MoveLoc[2](Arg2: &mut TxContext)
12Call router::swap_exact_input_<Ty0, Ty1>(u64, Coin<Ty0>, u64, &mut Dex_Info, &mut TxContext): Coin<Ty1>
13Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
14Ret
}
public ma<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Clock, Arg2: &Version, Arg3: Balance<Ty0>, Arg4: u128, Arg5: &mut TxContext): Balance<Ty1> {
L6: loc0: u64
L7: loc1: Balance<Ty1>
L8: loc2: FlashSwapReceipt
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[6](loc0: u64)
3CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
4LdTrue
5LdTrue
6MoveLoc[6](loc0: u64)
7MoveLoc[4](Arg4: u128)
8MoveLoc[1](Arg1: &Clock)
9CopyLoc[2](Arg2: &Version)
10CopyLoc[5](Arg5: &mut TxContext)
11FreezeRef
12Call trade::flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock, &Version, &TxContext): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt
13StLoc[8](loc2: FlashSwapReceipt)
14StLoc[7](loc1: Balance<Ty1>)
15Call balance::destroy_zero<Ty0>(Balance<Ty0>)
16MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
17MoveLoc[8](loc2: FlashSwapReceipt)
18MoveLoc[3](Arg3: Balance<Ty0>)
19Call balance::zero<Ty1>(): Balance<Ty1>
20MoveLoc[2](Arg2: &Version)
21MoveLoc[5](Arg5: &mut TxContext)
22FreezeRef
23Call trade::repay_flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, FlashSwapReceipt, Balance<Ty0>, Balance<Ty1>, &Version, &TxContext)
24MoveLoc[7](loc1: Balance<Ty1>)
25Ret
}
public mb<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Clock, Arg2: &Version, Arg3: Balance<Ty1>, Arg4: u128, Arg5: &mut TxContext): Balance<Ty0> {
L6: loc0: u64
L7: loc1: Balance<Ty0>
L8: loc2: FlashSwapReceipt
L9: loc3: Balance<Ty1>
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty1>)
1Call balance::value<Ty1>(&Balance<Ty1>): u64
2StLoc[6](loc0: u64)
3CopyLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
4LdFalse
5LdTrue
6MoveLoc[6](loc0: u64)
7MoveLoc[4](Arg4: u128)
8MoveLoc[1](Arg1: &Clock)
9CopyLoc[2](Arg2: &Version)
10CopyLoc[5](Arg5: &mut TxContext)
11FreezeRef
12Call trade::flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &Clock, &Version, &TxContext): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt
13StLoc[8](loc2: FlashSwapReceipt)
14StLoc[9](loc3: Balance<Ty1>)
15StLoc[7](loc1: Balance<Ty0>)
16MoveLoc[9](loc3: Balance<Ty1>)
17Call balance::destroy_zero<Ty1>(Balance<Ty1>)
18MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
19MoveLoc[8](loc2: FlashSwapReceipt)
20Call balance::zero<Ty0>(): Balance<Ty0>
21MoveLoc[3](Arg3: Balance<Ty1>)
22MoveLoc[2](Arg2: &Version)
23MoveLoc[5](Arg5: &mut TxContext)
24FreezeRef
25Call trade::repay_flash_swap<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, FlashSwapReceipt, Balance<Ty0>, Balance<Ty1>, &Version, &TxContext)
26MoveLoc[7](loc1: Balance<Ty0>)
27Ret
}
public ka<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Balance<Ty0>, Arg2: &mut TxContext): Balance<Ty1> {
L3: loc0: u64
L4: loc1: Coin<Ty0>
B0:
0ImmBorrowLoc[1](Arg1: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[3](loc0: u64)
3MoveLoc[1](Arg1: Balance<Ty0>)
4CopyLoc[2](Arg2: &mut TxContext)
5Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
6StLoc[4](loc1: Coin<Ty0>)
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8MoveLoc[4](loc1: Coin<Ty0>)
9MoveLoc[3](loc0: u64)
10LdU64(0)
11MoveLoc[2](Arg2: &mut TxContext)
12Call spot_dex::swap_token_x<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Coin<Ty0>, u64, u64, &mut TxContext): Coin<Ty1>
13Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
14Ret
}
public kb<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: Balance<Ty1>, Arg2: &mut TxContext): Balance<Ty0> {
L3: loc0: u64
L4: loc1: Coin<Ty1>
B0:
0ImmBorrowLoc[1](Arg1: Balance<Ty1>)
1Call balance::value<Ty1>(&Balance<Ty1>): u64
2StLoc[3](loc0: u64)
3MoveLoc[1](Arg1: Balance<Ty1>)
4CopyLoc[2](Arg2: &mut TxContext)
5Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
6StLoc[4](loc1: Coin<Ty1>)
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8MoveLoc[4](loc1: Coin<Ty1>)
9MoveLoc[3](loc0: u64)
10LdU64(0)
11MoveLoc[2](Arg2: &mut TxContext)
12Call spot_dex::swap_token_y<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, Coin<Ty1>, u64, u64, &mut TxContext): Coin<Ty0>
13Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
14Ret
}
public xa<Ty0, Ty1>(Arg0: &mut PoolRegistry, Arg1: &Versioned, Arg2: &Clock, Arg3: u64, Arg4: Balance<Ty0>, Arg5: u128, Arg6: &mut TxContext): Balance<Ty1> {
L7: loc0: Coin<Ty0>
B0:
0MoveLoc[4](Arg4: Balance<Ty0>)
1CopyLoc[6](Arg6: &mut TxContext)
2Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
3StLoc[7](loc0: Coin<Ty0>)
4MoveLoc[0](Arg0: &mut PoolRegistry)
5MoveLoc[3](Arg3: u64)
6MoveLoc[7](loc0: Coin<Ty0>)
7LdU64(0)
8MoveLoc[5](Arg5: u128)
9LdConst[0](u64: 1844..)
10MoveLoc[1](Arg1: &Versioned)
11MoveLoc[2](Arg2: &Clock)
12MoveLoc[6](Arg6: &mut TxContext)
13Call swap_router::swap_exact_input<Ty0, Ty1>(&mut PoolRegistry, u64, Coin<Ty0>, u64, u128, u64, &Versioned, &Clock, &mut TxContext): Coin<Ty1>
14Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
15Ret
}
public ta<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &Clock, Arg2: &Versioned, Arg3: Balance<Ty0>, Arg4: u128, Arg5: &mut TxContext): Balance<Ty1> {
L6: loc0: u64
L7: loc1: Coin<Ty0>
L8: loc2: u64
L9: loc3: Coin<Ty0>
L10: loc4: Coin<Ty1>
L11: loc5: address
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[6](loc0: u64)
3CopyLoc[5](Arg5: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6StLoc[11](loc5: address)
7CopyLoc[1](Arg1: &Clock)
8Call clock::timestamp_ms(&Clock): u64
9LdU64(60000)
10Add
11StLoc[8](loc2: u64)
12MoveLoc[3](Arg3: Balance<Ty0>)
13CopyLoc[5](Arg5: &mut TxContext)
14Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
15StLoc[7](loc1: Coin<Ty0>)
16MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
17MoveLoc[7](loc1: Coin<Ty0>)
18VecPack(50, 1)
19MoveLoc[6](loc0: u64)
20LdU64(0)
21MoveLoc[4](Arg4: u128)
22LdTrue
23MoveLoc[11](loc5: address)
24MoveLoc[8](loc2: u64)
25MoveLoc[1](Arg1: &Clock)
26MoveLoc[2](Arg2: &Versioned)
27MoveLoc[5](Arg5: &mut TxContext)
28Call 0swap_router::swap_a_b_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, vector<Coin<Ty0>>, u64, u64, u128, bool, address, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty1> * Coin<Ty0>
29StLoc[9](loc3: Coin<Ty0>)
30StLoc[10](loc4: Coin<Ty1>)
31MoveLoc[9](loc3: Coin<Ty0>)
32Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
33Call balance::destroy_zero<Ty0>(Balance<Ty0>)
34MoveLoc[10](loc4: Coin<Ty1>)
35Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
36Ret
}
public tb<Ty0, Ty1, Ty2>(Arg0: &mut Pool<Ty0, Ty1, Ty2>, Arg1: &Clock, Arg2: &Versioned, Arg3: Balance<Ty1>, Arg4: u128, Arg5: &mut TxContext): Balance<Ty0> {
L6: loc0: u64
L7: loc1: Coin<Ty1>
L8: loc2: u64
L9: loc3: Coin<Ty1>
L10: loc4: Coin<Ty0>
L11: loc5: address
B0:
0ImmBorrowLoc[3](Arg3: Balance<Ty1>)
1Call balance::value<Ty1>(&Balance<Ty1>): u64
2StLoc[6](loc0: u64)
3CopyLoc[5](Arg5: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6StLoc[11](loc5: address)
7CopyLoc[1](Arg1: &Clock)
8Call clock::timestamp_ms(&Clock): u64
9LdU64(60000)
10Add
11StLoc[8](loc2: u64)
12MoveLoc[3](Arg3: Balance<Ty1>)
13CopyLoc[5](Arg5: &mut TxContext)
14Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
15StLoc[7](loc1: Coin<Ty1>)
16MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1, Ty2>)
17MoveLoc[7](loc1: Coin<Ty1>)
18VecPack(85, 1)
19MoveLoc[6](loc0: u64)
20LdU64(0)
21MoveLoc[4](Arg4: u128)
22LdTrue
23MoveLoc[11](loc5: address)
24MoveLoc[8](loc2: u64)
25MoveLoc[1](Arg1: &Clock)
26MoveLoc[2](Arg2: &Versioned)
27MoveLoc[5](Arg5: &mut TxContext)
28Call 0swap_router::swap_b_a_with_return_<Ty0, Ty1, Ty2>(&mut Pool<Ty0, Ty1, Ty2>, vector<Coin<Ty1>>, u64, u64, u128, bool, address, u64, &Clock, &Versioned, &mut TxContext): Coin<Ty0> * Coin<Ty1>
29StLoc[9](loc3: Coin<Ty1>)
30StLoc[10](loc4: Coin<Ty0>)
31MoveLoc[9](loc3: Coin<Ty1>)
32Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
33Call balance::destroy_zero<Ty1>(Balance<Ty1>)
34MoveLoc[10](loc4: Coin<Ty0>)
35Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
36Ret
}
public sa<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Stats, Arg4: &PriceProvider, Arg5: &Clock, Arg6: Balance<Ty0>, Arg7: u128): Balance<Ty1> {
L8: loc0: u64
L9: loc1: Balance<Ty1>
L10: loc2: FlashSwapReceipt<Ty0, Ty1>
B0:
0ImmBorrowLoc[6](Arg6: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[8](loc0: u64)
3CopyLoc[0](Arg0: &GlobalConfig)
4MoveLoc[1](Arg1: &mut RewarderGlobalVault)
5CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
6LdTrue
7LdTrue
8MoveLoc[8](loc0: u64)
9MoveLoc[7](Arg7: u128)
10MoveLoc[3](Arg3: &mut Stats)
11MoveLoc[4](Arg4: &PriceProvider)
12MoveLoc[5](Arg5: &Clock)
13Call 1pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut RewarderGlobalVault, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &mut Stats, &PriceProvider, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
14StLoc[10](loc2: FlashSwapReceipt<Ty0, Ty1>)
15StLoc[9](loc1: Balance<Ty1>)
16Call balance::destroy_zero<Ty0>(Balance<Ty0>)
17MoveLoc[0](Arg0: &GlobalConfig)
18MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
19MoveLoc[6](Arg6: Balance<Ty0>)
20Call balance::zero<Ty1>(): Balance<Ty1>
21MoveLoc[10](loc2: FlashSwapReceipt<Ty0, Ty1>)
22Call 1pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
23MoveLoc[9](loc1: Balance<Ty1>)
24Ret
}
public sb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut RewarderGlobalVault, Arg2: &mut Pool<Ty0, Ty1>, Arg3: &mut Stats, Arg4: &PriceProvider, Arg5: &Clock, Arg6: Balance<Ty1>, Arg7: u128): Balance<Ty0> {
L8: loc0: u64
L9: loc1: Balance<Ty0>
L10: loc2: FlashSwapReceipt<Ty0, Ty1>
L11: loc3: Balance<Ty1>
B0:
0ImmBorrowLoc[6](Arg6: Balance<Ty1>)
1Call balance::value<Ty1>(&Balance<Ty1>): u64
2StLoc[8](loc0: u64)
3CopyLoc[0](Arg0: &GlobalConfig)
4MoveLoc[1](Arg1: &mut RewarderGlobalVault)
5CopyLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
6LdFalse
7LdTrue
8MoveLoc[8](loc0: u64)
9MoveLoc[7](Arg7: u128)
10MoveLoc[3](Arg3: &mut Stats)
11MoveLoc[4](Arg4: &PriceProvider)
12MoveLoc[5](Arg5: &Clock)
13Call 1pool::flash_swap<Ty0, Ty1>(&GlobalConfig, &mut RewarderGlobalVault, &mut Pool<Ty0, Ty1>, bool, bool, u64, u128, &mut Stats, &PriceProvider, &Clock): Balance<Ty0> * Balance<Ty1> * FlashSwapReceipt<Ty0, Ty1>
14StLoc[10](loc2: FlashSwapReceipt<Ty0, Ty1>)
15StLoc[11](loc3: Balance<Ty1>)
16StLoc[9](loc1: Balance<Ty0>)
17MoveLoc[11](loc3: Balance<Ty1>)
18Call balance::destroy_zero<Ty1>(Balance<Ty1>)
19MoveLoc[0](Arg0: &GlobalConfig)
20MoveLoc[2](Arg2: &mut Pool<Ty0, Ty1>)
21Call balance::zero<Ty0>(): Balance<Ty0>
22MoveLoc[6](Arg6: Balance<Ty1>)
23MoveLoc[10](loc2: FlashSwapReceipt<Ty0, Ty1>)
24Call 1pool::repay_flash_swap<Ty0, Ty1>(&GlobalConfig, &mut Pool<Ty0, Ty1>, Balance<Ty0>, Balance<Ty1>, FlashSwapReceipt<Ty0, Ty1>)
25MoveLoc[9](loc1: Balance<Ty0>)
26Ret
}
public oa<Ty0, Ty1>(Arg0: &mut TradingPair<Ty0, Ty1>, Arg1: &Clock, Arg2: &State, Arg3: &PriceInfoObject, Arg4: &PriceInfoObject, Arg5: Balance<Ty0>, Arg6: &mut TxContext): Balance<Ty1> {
L7: loc0: Coin<Ty0>
B0:
0MoveLoc[5](Arg5: Balance<Ty0>)
1CopyLoc[6](Arg6: &mut TxContext)
2Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
3StLoc[7](loc0: Coin<Ty0>)
4MoveLoc[0](Arg0: &mut TradingPair<Ty0, Ty1>)
5MoveLoc[1](Arg1: &Clock)
6MoveLoc[2](Arg2: &State)
7MoveLoc[3](Arg3: &PriceInfoObject)
8MoveLoc[4](Arg4: &PriceInfoObject)
9MoveLoc[7](loc0: Coin<Ty0>)
10MoveLoc[6](Arg6: &mut TxContext)
11Call v2::swap_x_to_y<Ty0, Ty1>(&mut TradingPair<Ty0, Ty1>, &Clock, &State, &PriceInfoObject, &PriceInfoObject, Coin<Ty0>, &mut TxContext): Coin<Ty1>
12Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
13Ret
}
public ob<Ty0, Ty1>(Arg0: &mut TradingPair<Ty0, Ty1>, Arg1: &Clock, Arg2: &State, Arg3: &PriceInfoObject, Arg4: &PriceInfoObject, Arg5: Balance<Ty1>, Arg6: &mut TxContext): Balance<Ty0> {
L7: loc0: Coin<Ty1>
B0:
0MoveLoc[5](Arg5: Balance<Ty1>)
1CopyLoc[6](Arg6: &mut TxContext)
2Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
3StLoc[7](loc0: Coin<Ty1>)
4MoveLoc[0](Arg0: &mut TradingPair<Ty0, Ty1>)
5MoveLoc[1](Arg1: &Clock)
6MoveLoc[2](Arg2: &State)
7MoveLoc[3](Arg3: &PriceInfoObject)
8MoveLoc[4](Arg4: &PriceInfoObject)
9MoveLoc[7](loc0: Coin<Ty1>)
10MoveLoc[6](Arg6: &mut TxContext)
11Call v2::swap_y_to_x<Ty0, Ty1>(&mut TradingPair<Ty0, Ty1>, &Clock, &State, &PriceInfoObject, &PriceInfoObject, Coin<Ty1>, &mut TxContext): Coin<Ty0>
12Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
13Ret
}
public pa<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Clock, Arg2: &PriceInfoObject, Arg3: &PriceInfoObject, Arg4: Balance<Ty0>, Arg5: &mut TxContext): Balance<Ty1> {
L6: loc0: u64
L7: loc1: Coin<Ty0>
L8: loc2: Coin<Ty1>
B0:
0ImmBorrowLoc[4](Arg4: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[6](loc0: u64)
3MoveLoc[4](Arg4: Balance<Ty0>)
4CopyLoc[5](Arg5: &mut TxContext)
5Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
6StLoc[7](loc1: Coin<Ty0>)
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8MoveLoc[1](Arg1: &Clock)
9MoveLoc[2](Arg2: &PriceInfoObject)
10MoveLoc[3](Arg3: &PriceInfoObject)
11MutBorrowLoc[7](loc1: Coin<Ty0>)
12MoveLoc[6](loc0: u64)
13LdU64(0)
14MoveLoc[5](Arg5: &mut TxContext)
15Call trader::sell_base_coin<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &Clock, &PriceInfoObject, &PriceInfoObject, &mut Coin<Ty0>, u64, u64, &mut TxContext): Coin<Ty1>
16StLoc[8](loc2: Coin<Ty1>)
17MoveLoc[7](loc1: Coin<Ty0>)
18Call coin::destroy_zero<Ty0>(Coin<Ty0>)
19MoveLoc[8](loc2: Coin<Ty1>)
20Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
21Ret
}
public pb<Ty0, Ty1>(Arg0: &mut Pool<Ty0, Ty1>, Arg1: &Clock, Arg2: &PriceInfoObject, Arg3: &PriceInfoObject, Arg4: Balance<Ty1>, Arg5: &mut TxContext): Balance<Ty0> {
L6: loc0: u64
L7: loc1: Coin<Ty1>
L8: loc2: Coin<Ty0>
B0:
0ImmBorrowLoc[4](Arg4: Balance<Ty1>)
1Call balance::value<Ty1>(&Balance<Ty1>): u64
2StLoc[6](loc0: u64)
3MoveLoc[4](Arg4: Balance<Ty1>)
4CopyLoc[5](Arg5: &mut TxContext)
5Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
6StLoc[7](loc1: Coin<Ty1>)
7MoveLoc[0](Arg0: &mut Pool<Ty0, Ty1>)
8MoveLoc[1](Arg1: &Clock)
9MoveLoc[2](Arg2: &PriceInfoObject)
10MoveLoc[3](Arg3: &PriceInfoObject)
11MutBorrowLoc[7](loc1: Coin<Ty1>)
12MoveLoc[6](loc0: u64)
13LdU64(0)
14MoveLoc[5](Arg5: &mut TxContext)
15Call trader::sell_quote_coin<Ty0, Ty1>(&mut Pool<Ty0, Ty1>, &Clock, &PriceInfoObject, &PriceInfoObject, &mut Coin<Ty1>, u64, u64, &mut TxContext): Coin<Ty0>
16StLoc[8](loc2: Coin<Ty0>)
17MoveLoc[7](loc1: Coin<Ty1>)
18Call coin::destroy_zero<Ty1>(Coin<Ty1>)
19MoveLoc[8](loc2: Coin<Ty0>)
20Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
21Ret
}
public da<Ty0, Ty1>(Arg0: &Global, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty0>, Arg3: &mut TxContext): Balance<Ty1> {
L4: loc0: Coin<Ty0>
B0:
0MoveLoc[2](Arg2: Balance<Ty0>)
1CopyLoc[3](Arg3: &mut TxContext)
2Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
3StLoc[4](loc0: Coin<Ty0>)
4MoveLoc[0](Arg0: &Global)
5MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
6MoveLoc[4](loc0: Coin<Ty0>)
7LdU64(0)
8MoveLoc[3](Arg3: &mut TxContext)
9Call 0router::swap_exact_x_to_y_with_return<Ty0, Ty1>(&Global, &mut Pool<Ty0, Ty1>, Coin<Ty0>, u64, &mut TxContext): Coin<Ty1>
10Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
11Ret
}
public db<Ty0, Ty1>(Arg0: &Global, Arg1: &mut Pool<Ty0, Ty1>, Arg2: Balance<Ty1>, Arg3: &mut TxContext): Balance<Ty0> {
L4: loc0: Coin<Ty1>
B0:
0MoveLoc[2](Arg2: Balance<Ty1>)
1CopyLoc[3](Arg3: &mut TxContext)
2Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
3StLoc[4](loc0: Coin<Ty1>)
4MoveLoc[0](Arg0: &Global)
5MoveLoc[1](Arg1: &mut Pool<Ty0, Ty1>)
6MoveLoc[4](loc0: Coin<Ty1>)
7LdU64(0)
8MoveLoc[3](Arg3: &mut TxContext)
9Call 0router::swap_exact_y_to_x_with_return<Ty0, Ty1>(&Global, &mut Pool<Ty0, Ty1>, Coin<Ty1>, u64, &mut TxContext): Coin<Ty0>
10Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
11Ret
}
public na<Ty0, Ty1>(Arg0: &Version, Arg1: &mut Market, Arg2: &mut SCoinTreasury<Ty1, Ty0>, Arg3: &Clock, Arg4: Balance<Ty0>, Arg5: &mut TxContext): Balance<Ty1> {
L6: loc0: Coin<Ty0>
L7: loc1: Coin<MarketCoin<Ty0>>
B0:
0MoveLoc[4](Arg4: Balance<Ty0>)
1CopyLoc[5](Arg5: &mut TxContext)
2Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
3StLoc[6](loc0: Coin<Ty0>)
4MoveLoc[0](Arg0: &Version)
5MoveLoc[1](Arg1: &mut Market)
6MoveLoc[6](loc0: Coin<Ty0>)
7MoveLoc[3](Arg3: &Clock)
8CopyLoc[5](Arg5: &mut TxContext)
9Call mint::mint<Ty0>(&Version, &mut Market, Coin<Ty0>, &Clock, &mut TxContext): Coin<MarketCoin<Ty0>>
10StLoc[7](loc1: Coin<MarketCoin<Ty0>>)
11MoveLoc[2](Arg2: &mut SCoinTreasury<Ty1, Ty0>)
12MoveLoc[7](loc1: Coin<MarketCoin<Ty0>>)
13MoveLoc[5](Arg5: &mut TxContext)
14Call s_coin_converter::mint_s_coin<Ty1, Ty0>(&mut SCoinTreasury<Ty1, Ty0>, Coin<MarketCoin<Ty0>>, &mut TxContext): Coin<Ty1>
15Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
16Ret
}
public nb<Ty0, Ty1>(Arg0: &Version, Arg1: &mut Market, Arg2: &mut SCoinTreasury<Ty1, Ty0>, Arg3: &Clock, Arg4: Balance<Ty1>, Arg5: &mut TxContext): Balance<Ty0> {
L6: loc0: Coin<Ty1>
L7: loc1: Coin<MarketCoin<Ty0>>
B0:
0MoveLoc[4](Arg4: Balance<Ty1>)
1CopyLoc[5](Arg5: &mut TxContext)
2Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
3StLoc[6](loc0: Coin<Ty1>)
4MoveLoc[2](Arg2: &mut SCoinTreasury<Ty1, Ty0>)
5MoveLoc[6](loc0: Coin<Ty1>)
6CopyLoc[5](Arg5: &mut TxContext)
7Call s_coin_converter::burn_s_coin<Ty1, Ty0>(&mut SCoinTreasury<Ty1, Ty0>, Coin<Ty1>, &mut TxContext): Coin<MarketCoin<Ty0>>
8StLoc[7](loc1: Coin<MarketCoin<Ty0>>)
9MoveLoc[0](Arg0: &Version)
10MoveLoc[1](Arg1: &mut Market)
11MoveLoc[7](loc1: Coin<MarketCoin<Ty0>>)
12MoveLoc[3](Arg3: &Clock)
13MoveLoc[5](Arg5: &mut TxContext)
14Call redeem::redeem<Ty0>(&Version, &mut Market, Coin<MarketCoin<Ty0>>, &Clock, &mut TxContext): Coin<Ty0>
15Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
16Ret
}
public ra<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut LBPair<Ty0, Ty1>, Arg2: &Clock, Arg3: Balance<Ty0>, Arg4: &mut TxContext): Balance<Ty1> {
L5: loc0: Coin<Ty0>
L6: loc1: Coin<Ty1>
B0:
0MoveLoc[3](Arg3: Balance<Ty0>)
1CopyLoc[4](Arg4: &mut TxContext)
2Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
3StLoc[5](loc0: Coin<Ty0>)
4MoveLoc[0](Arg0: &GlobalConfig)
5MoveLoc[1](Arg1: &mut LBPair<Ty0, Ty1>)
6LdTrue
7LdU64(0)
8MoveLoc[5](loc0: Coin<Ty0>)
9CopyLoc[4](Arg4: &mut TxContext)
10Call coin::zero<Ty1>(&mut TxContext): Coin<Ty1>
11MoveLoc[2](Arg2: &Clock)
12MoveLoc[4](Arg4: &mut TxContext)
13Call lb_pair::swap<Ty0, Ty1>(&GlobalConfig, &mut LBPair<Ty0, Ty1>, bool, u64, Coin<Ty0>, Coin<Ty1>, &Clock, &mut TxContext): Coin<Ty0> * Coin<Ty1>
14StLoc[6](loc1: Coin<Ty1>)
15Call coin::destroy_zero<Ty0>(Coin<Ty0>)
16MoveLoc[6](loc1: Coin<Ty1>)
17Call coin::into_balance<Ty1>(Coin<Ty1>): Balance<Ty1>
18Ret
}
public rb<Ty0, Ty1>(Arg0: &GlobalConfig, Arg1: &mut LBPair<Ty0, Ty1>, Arg2: &Clock, Arg3: Balance<Ty1>, Arg4: &mut TxContext): Balance<Ty0> {
L5: loc0: Coin<Ty1>
L6: loc1: Coin<Ty1>
L7: loc2: Coin<Ty0>
B0:
0MoveLoc[3](Arg3: Balance<Ty1>)
1CopyLoc[4](Arg4: &mut TxContext)
2Call coin::from_balance<Ty1>(Balance<Ty1>, &mut TxContext): Coin<Ty1>
3StLoc[5](loc0: Coin<Ty1>)
4MoveLoc[0](Arg0: &GlobalConfig)
5MoveLoc[1](Arg1: &mut LBPair<Ty0, Ty1>)
6LdFalse
7LdU64(0)
8CopyLoc[4](Arg4: &mut TxContext)
9Call coin::zero<Ty0>(&mut TxContext): Coin<Ty0>
10MoveLoc[5](loc0: Coin<Ty1>)
11MoveLoc[2](Arg2: &Clock)
12MoveLoc[4](Arg4: &mut TxContext)
13Call lb_pair::swap<Ty0, Ty1>(&GlobalConfig, &mut LBPair<Ty0, Ty1>, bool, u64, Coin<Ty0>, Coin<Ty1>, &Clock, &mut TxContext): Coin<Ty0> * Coin<Ty1>
14StLoc[6](loc1: Coin<Ty1>)
15StLoc[7](loc2: Coin<Ty0>)
16MoveLoc[6](loc1: Coin<Ty1>)
17Call coin::destroy_zero<Ty1>(Coin<Ty1>)
18MoveLoc[7](loc2: Coin<Ty0>)
19Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
20Ret
}
public gz<Ty0>(Arg0: Balance<Ty0>, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
B0:
0ImmBorrowLoc[0](Arg0: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2MoveLoc[1](Arg1: u64)
3Ge
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[2](Arg2: &mut TxContext)
7Pop
8LdConst[2](u64: 100)
9Abort
B3:
10MoveLoc[0](Arg0: Balance<Ty0>)
11MoveLoc[2](Arg2: &mut TxContext)
12Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
13Ret
}
Constants [
0 => u64: 18446744073709551615
1 => u64: 101
2 => u64: 100
]
}