buck
Module0x3466…98bb
- Move path
- 0xce7f…4db2::buck
- Functions
- 9580 public, 5 entry
- Structs
- 14
- Friend modules
- None
buck
Bytecode3184 lines
The on-chain disassembly. Offsets are instruction numbers within each function.
// Move bytecode v7
module ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2.buck {
use 00db9a10bb9536ab367b7d1ffa404c1d6c55f009076df1139dc108dd86608bbe::linked_table;
use 00db9a10bb9536ab367b7d1ffa404c1d6c55f009076df1139dc108dd86608bbe::math;
use f145ee6d09aae034924f80672bc76db2415dfd1b1bed863ac289af9d94e2c4fc::bucket_oracle;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::bkt;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::bottle;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck_events;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::bucket;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::constants;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::interest;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::math as 0math;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::pipe;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::reservoir;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::strap;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::tank;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::well;
use ce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::well_events;
use 1798f84ee72176114ddbf5525a6d964c5f8ea1b3738d08d50d0d3de4cf584884::float;
use 1798f84ee72176114ddbf5525a6d964c5f8ea1b3738d08d50d0d3de4cf584884::sbuck;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::sui;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::url;
struct BUCK has drop {
dummy_field: bool
}
struct BucketProtocol has key {
id: UID,
version: u64,
buck_treasury_cap: TreasuryCap<BUCK>,
min_bottle_size: u64
}
struct BucketType<phantom Ty0> has copy, drop, store {
dummy_field: bool
}
struct WellType<phantom Ty0> has copy, drop, store {
dummy_field: bool
}
struct TankType<phantom Ty0> has copy, drop, store {
dummy_field: bool
}
struct AdminCap has store, key {
id: UID
}
struct FlashMintConfig has store, key {
id: UID,
fee_rate: u64,
max_amount: u64,
total_amount: u64
}
struct FlashMintReceipt {
config_id: ID,
mint_amount: u64,
fee_amount: u64
}
struct NoFeePermission has key {
id: UID
}
struct ReservoirType<phantom Ty0> has copy, drop, store {
dummy_field: bool
}
struct SBuckRateKey has copy, drop, store {
dummy_field: bool
}
struct SBuckEmission has store, key {
id: UID,
latest_time: u64,
rate: Float
}
struct BUCKET_PROTOCOL has drop {
dummy_field: bool
}
struct TestVersion has store, key {
id: UID,
version: u64
}
init(Arg0: BUCK, Arg1: &mut TxContext) {
L2: loc0: AdminCap
B0:
0MoveLoc[0](Arg0: BUCK)
1CopyLoc[1](Arg1: &mut TxContext)
2Call new_protocol(BUCK, &mut TxContext): BucketProtocol * AdminCap
3StLoc[2](loc0: AdminCap)
4Call transfer::share_object<BucketProtocol>(BucketProtocol)
5MoveLoc[2](loc0: AdminCap)
6MoveLoc[1](Arg1: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Call transfer::transfer<AdminCap>(AdminCap, address)
10Ret
}
new_protocol(Arg0: BUCK, Arg1: &mut TxContext): BucketProtocol * AdminCap {
L2: loc0: AdminCap
L3: loc1: CoinMetadata<BUCK>
L4: loc2: TreasuryCap<BUCK>
L5: loc3: UID
L6: loc4: BucketProtocol
B0:
0MoveLoc[0](Arg0: BUCK)
1Call constants::buck_decimal(): u8
2LdConst[19](vector<u8>: "BUC..)
3LdConst[20](vector<u8>: "Buc..)
4LdConst[21](vector<u8>: "the..)
5LdConst[22](vector<u8>: "htt..)
6Call url::new_unsafe_from_bytes(vector<u8>): Url
7Call option::some<Url>(Url): Option<Url>
8CopyLoc[1](Arg1: &mut TxContext)
9Call coin::create_currency<BUCK>(BUCK, u8, vector<u8>, vector<u8>, vector<u8>, Option<Url>, &mut TxContext): TreasuryCap<BUCK> * CoinMetadata<BUCK>
10StLoc[3](loc1: CoinMetadata<BUCK>)
11StLoc[4](loc2: TreasuryCap<BUCK>)
12MoveLoc[3](loc1: CoinMetadata<BUCK>)
13Call transfer::public_freeze_object<CoinMetadata<BUCK>>(CoinMetadata<BUCK>)
14CopyLoc[1](Arg1: &mut TxContext)
15Call object::new(&mut TxContext): UID
16StLoc[5](loc3: UID)
17MutBorrowLoc[5](loc3: UID)
18LdFalse
19PackGeneric[0](WellType<BUCK>)
20CopyLoc[1](Arg1: &mut TxContext)
21Call well::new<BUCK>(&mut TxContext): Well<BUCK>
22Call dynamic_object_field::add<WellType<BUCK>, Well<BUCK>>(&mut UID, WellType<BUCK>, Well<BUCK>)
23MoveLoc[5](loc3: UID)
24LdConst[0](u64: 7)
25MoveLoc[4](loc2: TreasuryCap<BUCK>)
26LdU64(10000000000)
27Pack[1](BucketProtocol)
28StLoc[6](loc4: BucketProtocol)
29CopyLoc[1](Arg1: &mut TxContext)
30Call object::new(&mut TxContext): UID
31Pack[5](AdminCap)
32StLoc[2](loc0: AdminCap)
33ImmBorrowLoc[2](loc0: AdminCap)
34MutBorrowLoc[6](loc4: BucketProtocol)
35LdU64(110)
36LdU64(150)
37LdU8(9)
38Call option::none<u64>(): Option<u64>
39MoveLoc[1](Arg1: &mut TxContext)
40Call create_bucket<SUI>(&AdminCap, &mut BucketProtocol, u64, u64, u8, Option<u64>, &mut TxContext)
41MoveLoc[6](loc4: BucketProtocol)
42MoveLoc[2](loc0: AdminCap)
43Ret
}
public borrow<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: Balance<Ty0>, Arg4: u64, Arg5: Option<address>, Arg6: &mut TxContext): Balance<BUCK> {
L7: loc0: &Clock
L8: loc1: address
L9: loc2: &mut Bucket<Ty0>
L10: loc3: Balance<BUCK>
L11: loc4: u64
L12: loc5: u64
L13: loc6: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[0](BucketProtocol.min_bottle_size: u64)
5ReadRef
6StLoc[13](loc6: u64)
7CopyLoc[0](Arg0: &mut BucketProtocol)
8Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
9StLoc[9](loc2: &mut Bucket<Ty0>)
10CopyLoc[9](loc2: &mut Bucket<Ty0>)
11CopyLoc[2](Arg2: &Clock)
12StLoc[7](loc0: &Clock)
13FreezeRef
14MoveLoc[7](loc0: &Clock)
15Call compute_base_rate_fee<Ty0>(&Bucket<Ty0>, &Clock): u64
16StLoc[12](loc5: u64)
17CopyLoc[4](Arg4: u64)
18MoveLoc[12](loc5: u64)
19Call constants::fee_precision(): u64
20Call math::mul_factor(u64, u64, u64): u64
21StLoc[11](loc4: u64)
22ImmBorrowLoc[3](Arg3: Balance<Ty0>)
23Call balance::value<Ty0>(&Balance<Ty0>): u64
24Call buck_events::emit_collateral_increased<Ty0>(u64)
25CopyLoc[6](Arg6: &mut TxContext)
26FreezeRef
27Call tx_context::sender(&TxContext): address
28StLoc[8](loc1: address)
29MoveLoc[9](loc2: &mut Bucket<Ty0>)
30MoveLoc[1](Arg1: &BucketOracle)
31MoveLoc[8](loc1: address)
32MoveLoc[2](Arg2: &Clock)
33MoveLoc[3](Arg3: Balance<Ty0>)
34CopyLoc[4](Arg4: u64)
35CopyLoc[11](loc4: u64)
36Add
37MoveLoc[5](Arg5: Option<address>)
38MoveLoc[13](loc6: u64)
39MoveLoc[6](Arg6: &mut TxContext)
40Call bucket::handle_borrow<Ty0>(&mut Bucket<Ty0>, &BucketOracle, address, &Clock, Balance<Ty0>, u64, Option<address>, u64, &mut TxContext)
41CopyLoc[0](Arg0: &mut BucketProtocol)
42MoveLoc[11](loc4: u64)
43Call mint_buck<Ty0>(&mut BucketProtocol, u64): Balance<BUCK>
44StLoc[10](loc3: Balance<BUCK>)
45ImmBorrowLoc[10](loc3: Balance<BUCK>)
46LdConst[23](vector<u8>: "bor..)
47Call well_events::emit_collect_fee_from<BUCK>(&Balance<BUCK>, vector<u8>)
48CopyLoc[0](Arg0: &mut BucketProtocol)
49Call borrow_well_mut<BUCK>(&mut BucketProtocol): &mut Well<BUCK>
50MoveLoc[10](loc3: Balance<BUCK>)
51Call well::collect_fee<BUCK>(&mut Well<BUCK>, Balance<BUCK>)
52MoveLoc[0](Arg0: &mut BucketProtocol)
53MoveLoc[4](Arg4: u64)
54Call mint_buck<Ty0>(&mut BucketProtocol, u64): Balance<BUCK>
55Ret
}
public top_up<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<Ty0>, Arg2: address, Arg3: Option<address>) {
B0:
0LdConst[18](u64: 404)
1Abort
}
public top_up_coll<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<Ty0>, Arg2: address, Arg3: Option<address>, Arg4: &Clock) {
L5: loc0: &mut Bucket<Ty0>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
5StLoc[5](loc0: &mut Bucket<Ty0>)
6ImmBorrowLoc[1](Arg1: Balance<Ty0>)
7Call balance::value<Ty0>(&Balance<Ty0>): u64
8Call buck_events::emit_collateral_increased<Ty0>(u64)
9MoveLoc[5](loc0: &mut Bucket<Ty0>)
10MoveLoc[1](Arg1: Balance<Ty0>)
11MoveLoc[2](Arg2: address)
12MoveLoc[3](Arg3: Option<address>)
13MoveLoc[4](Arg4: &Clock)
14Call bucket::handle_top_up<Ty0>(&mut Bucket<Ty0>, Balance<Ty0>, address, Option<address>, &Clock)
15Ret
}
public withdraw<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: u64, Arg4: Option<address>, Arg5: &TxContext): Balance<Ty0> {
L6: loc0: &mut Bucket<Ty0>
L7: loc1: address
B0:
0MoveLoc[0](Arg0: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2StLoc[6](loc0: &mut Bucket<Ty0>)
3CopyLoc[6](loc0: &mut Bucket<Ty0>)
4FreezeRef
5Call bucket::is_not_locked<Ty0>(&Bucket<Ty0>): bool
6BrFalse(8)
B1:
7Branch(18)
B2:
8MoveLoc[1](Arg1: &BucketOracle)
9Pop
10MoveLoc[5](Arg5: &TxContext)
11Pop
12MoveLoc[2](Arg2: &Clock)
13Pop
14MoveLoc[6](loc0: &mut Bucket<Ty0>)
15Pop
16LdConst[12](u64: 14)
17Abort
B3:
18CopyLoc[3](Arg3: u64)
19Call buck_events::emit_collateral_decreased<Ty0>(u64)
20MoveLoc[5](Arg5: &TxContext)
21Call tx_context::sender(&TxContext): address
22StLoc[7](loc1: address)
23MoveLoc[6](loc0: &mut Bucket<Ty0>)
24MoveLoc[1](Arg1: &BucketOracle)
25MoveLoc[7](loc1: address)
26MoveLoc[2](Arg2: &Clock)
27MoveLoc[3](Arg3: u64)
28MoveLoc[4](Arg4: Option<address>)
29Call bucket::handle_withdraw<Ty0>(&mut Bucket<Ty0>, &BucketOracle, address, &Clock, u64, Option<address>): Balance<Ty0>
30Ret
}
public repay<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<BUCK>, Arg2: &TxContext): Balance<Ty0> {
B0:
0LdConst[18](u64: 404)
1Abort
}
public repay_debt<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<BUCK>, Arg2: &Clock, Arg3: &TxContext): Balance<Ty0> {
L4: loc0: u64
L5: loc1: &mut Bucket<Ty0>
L6: loc2: Balance<Ty0>
L7: loc3: address
L8: loc4: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[0](BucketProtocol.min_bottle_size: u64)
5ReadRef
6StLoc[8](loc4: u64)
7MoveLoc[3](Arg3: &TxContext)
8Call tx_context::sender(&TxContext): address
9StLoc[7](loc3: address)
10ImmBorrowLoc[1](Arg1: Balance<BUCK>)
11Call balance::value<BUCK>(&Balance<BUCK>): u64
12StLoc[4](loc0: u64)
13CopyLoc[0](Arg0: &mut BucketProtocol)
14MoveLoc[1](Arg1: Balance<BUCK>)
15Call burn_buck<Ty0>(&mut BucketProtocol, Balance<BUCK>)
16MoveLoc[0](Arg0: &mut BucketProtocol)
17Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
18StLoc[5](loc1: &mut Bucket<Ty0>)
19CopyLoc[5](loc1: &mut Bucket<Ty0>)
20FreezeRef
21Call bucket::is_not_locked<Ty0>(&Bucket<Ty0>): bool
22BrFalse(24)
B1:
23Branch(30)
B2:
24MoveLoc[2](Arg2: &Clock)
25Pop
26MoveLoc[5](loc1: &mut Bucket<Ty0>)
27Pop
28LdConst[12](u64: 14)
29Abort
B3:
30MoveLoc[5](loc1: &mut Bucket<Ty0>)
31MoveLoc[7](loc3: address)
32MoveLoc[4](loc0: u64)
33MoveLoc[8](loc4: u64)
34LdTrue
35MoveLoc[2](Arg2: &Clock)
36Call bucket::handle_repay<Ty0>(&mut Bucket<Ty0>, address, u64, u64, bool, &Clock): Balance<Ty0>
37StLoc[6](loc2: Balance<Ty0>)
38ImmBorrowLoc[6](loc2: Balance<Ty0>)
39Call balance::value<Ty0>(&Balance<Ty0>): u64
40Call buck_events::emit_collateral_decreased<Ty0>(u64)
41MoveLoc[6](loc2: Balance<Ty0>)
42Ret
}
public redeem<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: Balance<BUCK>, Arg4: Option<address>): Balance<Ty0> {
L5: loc0: &Clock
L6: loc1: u64
L7: loc2: u64
L8: loc3: &mut Bucket<Ty0>
L9: loc4: Balance<Ty0>
L10: loc5: u64
L11: loc6: Balance<Ty0>
L12: loc7: u64
L13: loc8: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3ImmBorrowLoc[3](Arg3: Balance<BUCK>)
4Call balance::value<BUCK>(&Balance<BUCK>): u64
5StLoc[6](loc1: u64)
6CopyLoc[0](Arg0: &mut BucketProtocol)
7Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
8StLoc[8](loc3: &mut Bucket<Ty0>)
9CopyLoc[8](loc3: &mut Bucket<Ty0>)
10FreezeRef
11Call bucket::is_not_locked<Ty0>(&Bucket<Ty0>): bool
12BrFalse(14)
B1:
13Branch(24)
B2:
14MoveLoc[0](Arg0: &mut BucketProtocol)
15Pop
16MoveLoc[1](Arg1: &BucketOracle)
17Pop
18MoveLoc[2](Arg2: &Clock)
19Pop
20MoveLoc[8](loc3: &mut Bucket<Ty0>)
21Pop
22LdConst[12](u64: 14)
23Abort
B3:
24CopyLoc[8](loc3: &mut Bucket<Ty0>)
25FreezeRef
26Call bucket::get_minted_buck_amount<Ty0>(&Bucket<Ty0>): u64
27StLoc[7](loc2: u64)
28CopyLoc[8](loc3: &mut Bucket<Ty0>)
29MoveLoc[1](Arg1: &BucketOracle)
30CopyLoc[2](Arg2: &Clock)
31CopyLoc[6](loc1: u64)
32MoveLoc[4](Arg4: Option<address>)
33Call bucket::handle_redeem<Ty0>(&mut Bucket<Ty0>, &BucketOracle, &Clock, u64, Option<address>): Balance<Ty0>
34StLoc[9](loc4: Balance<Ty0>)
35ImmBorrowLoc[9](loc4: Balance<Ty0>)
36Call balance::value<Ty0>(&Balance<Ty0>): u64
37StLoc[10](loc5: u64)
38CopyLoc[8](loc3: &mut Bucket<Ty0>)
39CopyLoc[2](Arg2: &Clock)
40StLoc[5](loc0: &Clock)
41FreezeRef
42MoveLoc[5](loc0: &Clock)
43Call compute_base_rate_fee<Ty0>(&Bucket<Ty0>, &Clock): u64
44Call constants::fee_precision(): u64
45MoveLoc[6](loc1: u64)
46MoveLoc[7](loc2: u64)
47Call math::mul_factor(u64, u64, u64): u64
48LdU64(2)
49Div
50Add
51StLoc[13](loc8: u64)
52MoveLoc[10](loc5: u64)
53CopyLoc[13](loc8: u64)
54Call constants::fee_precision(): u64
55Call math::mul_factor(u64, u64, u64): u64
56StLoc[12](loc7: u64)
57MoveLoc[8](loc3: &mut Bucket<Ty0>)
58MoveLoc[13](loc8: u64)
59MoveLoc[2](Arg2: &Clock)
60Call clock::timestamp_ms(&Clock): u64
61Call bucket::update_base_rate_fee<Ty0>(&mut Bucket<Ty0>, u64, u64)
62MutBorrowLoc[9](loc4: Balance<Ty0>)
63MoveLoc[12](loc7: u64)
64Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
65StLoc[11](loc6: Balance<Ty0>)
66ImmBorrowLoc[11](loc6: Balance<Ty0>)
67LdConst[24](vector<u8>: "red..)
68Call well_events::emit_collect_fee_from<Ty0>(&Balance<Ty0>, vector<u8>)
69CopyLoc[0](Arg0: &mut BucketProtocol)
70Call borrow_well_mut<Ty0>(&mut BucketProtocol): &mut Well<Ty0>
71MoveLoc[11](loc6: Balance<Ty0>)
72Call well::collect_fee<Ty0>(&mut Well<Ty0>, Balance<Ty0>)
73ImmBorrowLoc[9](loc4: Balance<Ty0>)
74Call balance::value<Ty0>(&Balance<Ty0>): u64
75Call buck_events::emit_collateral_decreased<Ty0>(u64)
76MoveLoc[0](Arg0: &mut BucketProtocol)
77MoveLoc[3](Arg3: Balance<BUCK>)
78Call burn_buck<Ty0>(&mut BucketProtocol, Balance<BUCK>)
79MoveLoc[9](loc4: Balance<Ty0>)
80Ret
}
public is_liquidatable<Ty0>(Arg0: &BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: address): bool {
B0:
0MoveLoc[0](Arg0: &BucketProtocol)
1Call borrow_bucket<Ty0>(&BucketProtocol): &Bucket<Ty0>
2MoveLoc[1](Arg1: &BucketOracle)
3MoveLoc[2](Arg2: &Clock)
4MoveLoc[3](Arg3: address)
5Call bucket::is_liquidatable<Ty0>(&Bucket<Ty0>, &BucketOracle, &Clock, address): bool
6Ret
}
public liquidate_under_normal_mode<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: address): Balance<Ty0> {
L4: loc0: &Bucket<Ty0>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4FreezeRef
5Call borrow_bucket<Ty0>(&BucketProtocol): &Bucket<Ty0>
6StLoc[4](loc0: &Bucket<Ty0>)
7CopyLoc[4](loc0: &Bucket<Ty0>)
8CopyLoc[1](Arg1: &BucketOracle)
9CopyLoc[2](Arg2: &Clock)
10Call bucket::is_in_recovery_mode<Ty0>(&Bucket<Ty0>, &BucketOracle, &Clock): bool
11Not
12BrFalse(14)
B1:
13Branch(24)
B2:
14MoveLoc[0](Arg0: &mut BucketProtocol)
15Pop
16MoveLoc[1](Arg1: &BucketOracle)
17Pop
18MoveLoc[2](Arg2: &Clock)
19Pop
20MoveLoc[4](loc0: &Bucket<Ty0>)
21Pop
22LdConst[0](u64: 7)
23Abort
B3:
24MoveLoc[4](loc0: &Bucket<Ty0>)
25Call bucket::is_not_locked<Ty0>(&Bucket<Ty0>): bool
26BrFalse(28)
B4:
27Branch(36)
B5:
28MoveLoc[0](Arg0: &mut BucketProtocol)
29Pop
30MoveLoc[1](Arg1: &BucketOracle)
31Pop
32MoveLoc[2](Arg2: &Clock)
33Pop
34LdConst[12](u64: 14)
35Abort
B6:
36MoveLoc[0](Arg0: &mut BucketProtocol)
37MoveLoc[1](Arg1: &BucketOracle)
38MoveLoc[2](Arg2: &Clock)
39MoveLoc[3](Arg3: address)
40Call option::none<u64>(): Option<u64>
41Call normally_liquidate<Ty0>(&mut BucketProtocol, &BucketOracle, &Clock, address, Option<u64>): Balance<Ty0>
42Ret
}
public liquidate_under_recovery_mode<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: address): Balance<Ty0> {
L4: loc0: &Clock
L5: loc1: address
L6: loc2: u64
L7: loc3: u64
L8: loc4: &BucketOracle
L9: loc5: &Clock
L10: loc6: address
L11: loc7: &BucketOracle
L12: loc8: &BucketOracle
L13: loc9: &Clock
L14: loc10: bool
L15: loc11: u64
L16: loc12: Balance<Ty0>
L17: loc13: Balance<Ty0>
L18: loc14: &Clock
L19: loc15: address
L20: loc16: &BucketOracle
L21: loc17: &Clock
L22: loc18: address
L23: loc19: u64
L24: loc20: u64
L25: loc21: Balance<BUCK>
L26: loc22: &mut Bucket<Ty0>
L27: loc23: u64
L28: loc24: Balance<Ty0>
L29: loc25: Balance<Ty0>
L30: loc26: Balance<Ty0>
L31: loc27: u64
L32: loc28: u64
L33: loc29: u64
L34: loc30: Balance<Ty0>
L35: loc31: Balance<Ty0>
L36: loc32: Balance<Ty0>
L37: loc33: u64
L38: loc34: u64
L39: loc35: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4CopyLoc[1](Arg1: &BucketOracle)
5CopyLoc[2](Arg2: &Clock)
6CopyLoc[3](Arg3: address)
7StLoc[19](loc15: address)
8StLoc[18](loc14: &Clock)
9StLoc[11](loc7: &BucketOracle)
10FreezeRef
11MoveLoc[11](loc7: &BucketOracle)
12MoveLoc[18](loc14: &Clock)
13MoveLoc[19](loc15: address)
14Call is_liquidatable<Ty0>(&BucketProtocol, &BucketOracle, &Clock, address): bool
15BrFalse(17)
B1:
16Branch(25)
B2:
17MoveLoc[0](Arg0: &mut BucketProtocol)
18Pop
19MoveLoc[1](Arg1: &BucketOracle)
20Pop
21MoveLoc[2](Arg2: &Clock)
22Pop
23LdConst[1](u64: 1)
24Abort
B3:
25CopyLoc[0](Arg0: &mut BucketProtocol)
26FreezeRef
27Call borrow_tank<Ty0>(&BucketProtocol): &Tank<BUCK, Ty0>
28Call tank::is_not_locked<BUCK, Ty0>(&Tank<BUCK, Ty0>): bool
29BrFalse(31)
B4:
30Branch(39)
B5:
31MoveLoc[0](Arg0: &mut BucketProtocol)
32Pop
33MoveLoc[1](Arg1: &BucketOracle)
34Pop
35MoveLoc[2](Arg2: &Clock)
36Pop
37LdConst[3](u64: 4)
38Abort
B6:
39CopyLoc[0](Arg0: &mut BucketProtocol)
40FreezeRef
41Call borrow_tank<Ty0>(&BucketProtocol): &Tank<BUCK, Ty0>
42Call tank::get_reserve_balance<BUCK, Ty0>(&Tank<BUCK, Ty0>): u64
43StLoc[38](loc34: u64)
44CopyLoc[0](Arg0: &mut BucketProtocol)
45Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
46StLoc[26](loc22: &mut Bucket<Ty0>)
47CopyLoc[26](loc22: &mut Bucket<Ty0>)
48CopyLoc[1](Arg1: &BucketOracle)
49CopyLoc[2](Arg2: &Clock)
50StLoc[21](loc17: &Clock)
51StLoc[20](loc16: &BucketOracle)
52FreezeRef
53MoveLoc[20](loc16: &BucketOracle)
54MoveLoc[21](loc17: &Clock)
55Call bucket::is_in_recovery_mode<Ty0>(&Bucket<Ty0>, &BucketOracle, &Clock): bool
56BrFalse(58)
B7:
57Branch(68)
B8:
58MoveLoc[0](Arg0: &mut BucketProtocol)
59Pop
60MoveLoc[1](Arg1: &BucketOracle)
61Pop
62MoveLoc[2](Arg2: &Clock)
63Pop
64MoveLoc[26](loc22: &mut Bucket<Ty0>)
65Pop
66LdConst[5](u64: 6)
67Abort
B9:
68CopyLoc[26](loc22: &mut Bucket<Ty0>)
69FreezeRef
70Call bucket::is_not_locked<Ty0>(&Bucket<Ty0>): bool
71BrFalse(73)
B10:
72Branch(83)
B11:
73MoveLoc[0](Arg0: &mut BucketProtocol)
74Pop
75MoveLoc[1](Arg1: &BucketOracle)
76Pop
77MoveLoc[2](Arg2: &Clock)
78Pop
79MoveLoc[26](loc22: &mut Bucket<Ty0>)
80Pop
81LdConst[12](u64: 14)
82Abort
B12:
83CopyLoc[26](loc22: &mut Bucket<Ty0>)
84FreezeRef
85Call bucket::is_interest_table_exists<Ty0>(&Bucket<Ty0>): bool
86BrFalse(104)
B13:
87CopyLoc[26](loc22: &mut Bucket<Ty0>)
88CopyLoc[3](Arg3: address)
89CopyLoc[2](Arg2: &Clock)
90Call bucket::accrue_interests_by_debtor<Ty0>(&mut Bucket<Ty0>, address, &Clock): u64
91Pop
92CopyLoc[26](loc22: &mut Bucket<Ty0>)
93CopyLoc[3](Arg3: address)
94CopyLoc[2](Arg2: &Clock)
95StLoc[4](loc0: &Clock)
96StLoc[22](loc18: address)
97FreezeRef
98MoveLoc[22](loc18: address)
99MoveLoc[4](loc0: &Clock)
100Call bucket::get_bottle_info_with_interest_by_debtor<Ty0>(&Bucket<Ty0>, address, &Clock): u64 * u64
101StLoc[7](loc3: u64)
102StLoc[6](loc2: u64)
103Branch(112)
B14:
104CopyLoc[26](loc22: &mut Bucket<Ty0>)
105CopyLoc[3](Arg3: address)
106StLoc[5](loc1: address)
107FreezeRef
108MoveLoc[5](loc1: address)
109Call bucket::get_bottle_info_by_debtor<Ty0>(&Bucket<Ty0>, address): u64 * u64
110StLoc[7](loc3: u64)
111StLoc[6](loc2: u64)
B15:
112MoveLoc[6](loc2: u64)
113MoveLoc[7](loc3: u64)
114StLoc[23](loc19: u64)
115Pop
116CopyLoc[26](loc22: &mut Bucket<Ty0>)
117CopyLoc[1](Arg1: &BucketOracle)
118CopyLoc[2](Arg2: &Clock)
119CopyLoc[3](Arg3: address)
120StLoc[10](loc6: address)
121StLoc[9](loc5: &Clock)
122StLoc[8](loc4: &BucketOracle)
123FreezeRef
124MoveLoc[8](loc4: &BucketOracle)
125MoveLoc[9](loc5: &Clock)
126MoveLoc[10](loc6: address)
127Call bucket::get_bottle_icr<Ty0>(&Bucket<Ty0>, &BucketOracle, &Clock, address): u64
128StLoc[32](loc28: u64)
129CopyLoc[26](loc22: &mut Bucket<Ty0>)
130CopyLoc[1](Arg1: &BucketOracle)
131CopyLoc[2](Arg2: &Clock)
132StLoc[13](loc9: &Clock)
133StLoc[12](loc8: &BucketOracle)
134FreezeRef
135MoveLoc[12](loc8: &BucketOracle)
136MoveLoc[13](loc9: &Clock)
137Call bucket::get_bucket_tcr<Ty0>(&Bucket<Ty0>, &BucketOracle, &Clock): u64
138StLoc[39](loc35: u64)
139MoveLoc[26](loc22: &mut Bucket<Ty0>)
140FreezeRef
141Call bucket::get_minimum_collateral_ratio<Ty0>(&Bucket<Ty0>): u64
142LdU64(100)
143Mul
144StLoc[33](loc29: u64)
145CopyLoc[32](loc28: u64)
146CopyLoc[33](loc29: u64)
147Lt
148BrFalse(162)
B16:
149CopyLoc[0](Arg0: &mut BucketProtocol)
150MoveLoc[1](Arg1: &BucketOracle)
151MoveLoc[2](Arg2: &Clock)
152MoveLoc[3](Arg3: address)
153MoveLoc[39](loc35: u64)
154Call option::some<u64>(u64): Option<u64>
155Call normally_liquidate<Ty0>(&mut BucketProtocol, &BucketOracle, &Clock, address, Option<u64>): Balance<Ty0>
156StLoc[34](loc30: Balance<Ty0>)
157Call balance::zero<Ty0>(): Balance<Ty0>
158MoveLoc[34](loc30: Balance<Ty0>)
159StLoc[17](loc13: Balance<Ty0>)
160StLoc[16](loc12: Balance<Ty0>)
161Branch(287)
B17:
162CopyLoc[32](loc28: u64)
163MoveLoc[33](loc29: u64)
164Ge
165BrFalse(171)
B18:
166MoveLoc[32](loc28: u64)
167CopyLoc[39](loc35: u64)
168Lt
169StLoc[14](loc10: bool)
170Branch(173)
B19:
171LdFalse
172StLoc[14](loc10: bool)
B20:
173MoveLoc[14](loc10: bool)
174BrFalse(232)
B21:
175CopyLoc[38](loc34: u64)
176LdU64(0)
177Gt
178BrFalse(180)
B22:
179Branch(188)
B23:
180MoveLoc[0](Arg0: &mut BucketProtocol)
181Pop
182MoveLoc[1](Arg1: &BucketOracle)
183Pop
184MoveLoc[2](Arg2: &Clock)
185Pop
186LdConst[7](u64: 9)
187Abort
B24:
188CopyLoc[23](loc19: u64)
189CopyLoc[38](loc34: u64)
190Le
191BrFalse(195)
B25:
192CopyLoc[23](loc19: u64)
193StLoc[15](loc11: u64)
194Branch(197)
B26:
195MoveLoc[38](loc34: u64)
196StLoc[15](loc11: u64)
B27:
197MoveLoc[15](loc11: u64)
198StLoc[24](loc20: u64)
199CopyLoc[0](Arg0: &mut BucketProtocol)
200Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
201CopyLoc[3](Arg3: address)
202CopyLoc[24](loc20: u64)
203CopyLoc[1](Arg1: &BucketOracle)
204CopyLoc[2](Arg2: &Clock)
205Call bucket::handle_repay_capped<Ty0>(&mut Bucket<Ty0>, address, u64, &BucketOracle, &Clock): Balance<Ty0>
206StLoc[28](loc24: Balance<Ty0>)
207ImmBorrowLoc[28](loc24: Balance<Ty0>)
208Call balance::value<Ty0>(&Balance<Ty0>): u64
209StLoc[27](loc23: u64)
210MoveLoc[23](loc19: u64)
211CopyLoc[24](loc20: u64)
212Eq
213BrFalse(231)
B28:
214CopyLoc[0](Arg0: &mut BucketProtocol)
215FreezeRef
216Call borrow_bucket<Ty0>(&BucketProtocol): &Bucket<Ty0>
217Call bucket::borrow_surplus_bottle_table<Ty0>(&Bucket<Ty0>): &Table<address, Bottle>
218CopyLoc[3](Arg3: address)
219Call table::contains<address, Bottle>(&Table<address, Bottle>, address): bool
220BrFalse(222)
B29:
221Branch(230)
B30:
222MoveLoc[0](Arg0: &mut BucketProtocol)
223Pop
224MoveLoc[1](Arg1: &BucketOracle)
225Pop
226MoveLoc[2](Arg2: &Clock)
227Pop
228LdConst[8](u64: 10)
229Abort
B31:
230Branch(240)
B32:
231Branch(240)
B33:
232MoveLoc[0](Arg0: &mut BucketProtocol)
233Pop
234MoveLoc[1](Arg1: &BucketOracle)
235Pop
236MoveLoc[2](Arg2: &Clock)
237Pop
238LdConst[1](u64: 1)
239Abort
B34:
240ImmBorrowLoc[28](loc24: Balance<Ty0>)
241Call balance::value<Ty0>(&Balance<Ty0>): u64
242Call constants::liquidation_rebate(): u64
243Call constants::fee_precision(): u64
244Call math::mul_factor(u64, u64, u64): u64
245StLoc[37](loc33: u64)
246ImmBorrowLoc[28](loc24: Balance<Ty0>)
247Call balance::value<Ty0>(&Balance<Ty0>): u64
248Call constants::liquidation_fee(): u64
249Call constants::fee_precision(): u64
250Call math::mul_factor(u64, u64, u64): u64
251StLoc[31](loc27: u64)
252MutBorrowLoc[28](loc24: Balance<Ty0>)
253MoveLoc[37](loc33: u64)
254Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
255StLoc[35](loc31: Balance<Ty0>)
256MutBorrowLoc[28](loc24: Balance<Ty0>)
257MoveLoc[31](loc27: u64)
258Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
259StLoc[29](loc25: Balance<Ty0>)
260CopyLoc[0](Arg0: &mut BucketProtocol)
261Call borrow_tank_mut<Ty0>(&mut BucketProtocol): &mut Tank<BUCK, Ty0>
262MoveLoc[28](loc24: Balance<Ty0>)
263CopyLoc[24](loc20: u64)
264Call tank::absorb<BUCK, Ty0>(&mut Tank<BUCK, Ty0>, Balance<Ty0>, u64): Balance<BUCK>
265StLoc[25](loc21: Balance<BUCK>)
266CopyLoc[0](Arg0: &mut BucketProtocol)
267MoveLoc[25](loc21: Balance<BUCK>)
268Call burn_buck<Ty0>(&mut BucketProtocol, Balance<BUCK>)
269CopyLoc[0](Arg0: &mut BucketProtocol)
270Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
271Call bucket::update_snapshot<Ty0>(&mut Bucket<Ty0>)
272CopyLoc[27](loc23: u64)
273Call buck_events::emit_collateral_decreased<Ty0>(u64)
274MoveLoc[1](Arg1: &BucketOracle)
275MoveLoc[2](Arg2: &Clock)
276Call bucket_oracle::get_price<Ty0>(&BucketOracle, &Clock): u64 * u64
277MoveLoc[27](loc23: u64)
278MoveLoc[24](loc20: u64)
279MoveLoc[39](loc35: u64)
280Call option::some<u64>(u64): Option<u64>
281MoveLoc[3](Arg3: address)
282Call buck_events::emit_liquidation<Ty0>(u64, u64, u64, u64, Option<u64>, address)
283MoveLoc[29](loc25: Balance<Ty0>)
284MoveLoc[35](loc31: Balance<Ty0>)
285StLoc[17](loc13: Balance<Ty0>)
286StLoc[16](loc12: Balance<Ty0>)
B35:
287MoveLoc[16](loc12: Balance<Ty0>)
288MoveLoc[17](loc13: Balance<Ty0>)
289StLoc[36](loc32: Balance<Ty0>)
290StLoc[30](loc26: Balance<Ty0>)
291ImmBorrowLoc[30](loc26: Balance<Ty0>)
292LdConst[25](vector<u8>: "liq..)
293Call well_events::emit_collect_fee_from<Ty0>(&Balance<Ty0>, vector<u8>)
294MoveLoc[0](Arg0: &mut BucketProtocol)
295Call borrow_well_mut<Ty0>(&mut BucketProtocol): &mut Well<Ty0>
296MoveLoc[30](loc26: Balance<Ty0>)
297Call well::collect_fee<Ty0>(&mut Well<Ty0>, Balance<Ty0>)
298MoveLoc[36](loc32: Balance<Ty0>)
299Ret
}
normally_liquidate<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: address, Arg4: Option<u64>): Balance<Ty0> {
L5: loc0: u64
L6: loc1: u64
L7: loc2: u64
L8: loc3: &BucketOracle
L9: loc4: &Clock
L10: loc5: address
L11: loc6: address
L12: loc7: &Clock
L13: loc8: address
L14: loc9: u64
L15: loc10: u64
L16: loc11: Balance<BUCK>
L17: loc12: &mut Bucket<Ty0>
L18: loc13: u64
L19: loc14: Balance<Ty0>
L20: loc15: Balance<Ty0>
L21: loc16: u64
L22: loc17: u64
L23: loc18: Balance<Ty0>
L24: loc19: u64
L25: loc20: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[0](BucketProtocol.min_bottle_size: u64)
5ReadRef
6StLoc[22](loc17: u64)
7CopyLoc[0](Arg0: &mut BucketProtocol)
8CopyLoc[1](Arg1: &BucketOracle)
9CopyLoc[2](Arg2: &Clock)
10CopyLoc[3](Arg3: address)
11StLoc[10](loc5: address)
12StLoc[9](loc4: &Clock)
13StLoc[8](loc3: &BucketOracle)
14FreezeRef
15MoveLoc[8](loc3: &BucketOracle)
16MoveLoc[9](loc4: &Clock)
17MoveLoc[10](loc5: address)
18Call is_liquidatable<Ty0>(&BucketProtocol, &BucketOracle, &Clock, address): bool
19BrFalse(21)
B1:
20Branch(29)
B2:
21MoveLoc[0](Arg0: &mut BucketProtocol)
22Pop
23MoveLoc[1](Arg1: &BucketOracle)
24Pop
25MoveLoc[2](Arg2: &Clock)
26Pop
27LdConst[1](u64: 1)
28Abort
B3:
29CopyLoc[0](Arg0: &mut BucketProtocol)
30FreezeRef
31Call borrow_tank<Ty0>(&BucketProtocol): &Tank<BUCK, Ty0>
32Call tank::is_not_locked<BUCK, Ty0>(&Tank<BUCK, Ty0>): bool
33BrFalse(35)
B4:
34Branch(43)
B5:
35MoveLoc[0](Arg0: &mut BucketProtocol)
36Pop
37MoveLoc[1](Arg1: &BucketOracle)
38Pop
39MoveLoc[2](Arg2: &Clock)
40Pop
41LdConst[3](u64: 4)
42Abort
B6:
43CopyLoc[0](Arg0: &mut BucketProtocol)
44FreezeRef
45Call borrow_tank<Ty0>(&BucketProtocol): &Tank<BUCK, Ty0>
46Call tank::get_reserve_balance<BUCK, Ty0>(&Tank<BUCK, Ty0>): u64
47StLoc[25](loc20: u64)
48CopyLoc[0](Arg0: &mut BucketProtocol)
49Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
50StLoc[17](loc12: &mut Bucket<Ty0>)
51CopyLoc[17](loc12: &mut Bucket<Ty0>)
52FreezeRef
53Call bucket::is_interest_table_exists<Ty0>(&Bucket<Ty0>): bool
54BrFalse(72)
B7:
55CopyLoc[17](loc12: &mut Bucket<Ty0>)
56CopyLoc[3](Arg3: address)
57CopyLoc[2](Arg2: &Clock)
58Call bucket::accrue_interests_by_debtor<Ty0>(&mut Bucket<Ty0>, address, &Clock): u64
59Pop
60CopyLoc[17](loc12: &mut Bucket<Ty0>)
61CopyLoc[3](Arg3: address)
62CopyLoc[2](Arg2: &Clock)
63StLoc[12](loc7: &Clock)
64StLoc[11](loc6: address)
65FreezeRef
66MoveLoc[11](loc6: address)
67MoveLoc[12](loc7: &Clock)
68Call bucket::get_bottle_info_with_interest_by_debtor<Ty0>(&Bucket<Ty0>, address, &Clock): u64 * u64
69StLoc[6](loc1: u64)
70StLoc[5](loc0: u64)
71Branch(80)
B8:
72CopyLoc[17](loc12: &mut Bucket<Ty0>)
73CopyLoc[3](Arg3: address)
74StLoc[13](loc8: address)
75FreezeRef
76MoveLoc[13](loc8: address)
77Call bucket::get_bottle_info_by_debtor<Ty0>(&Bucket<Ty0>, address): u64 * u64
78StLoc[6](loc1: u64)
79StLoc[5](loc0: u64)
B9:
80MoveLoc[5](loc0: u64)
81MoveLoc[6](loc1: u64)
82StLoc[14](loc9: u64)
83Pop
84CopyLoc[14](loc9: u64)
85CopyLoc[25](loc20: u64)
86Le
87BrFalse(91)
B10:
88MoveLoc[14](loc9: u64)
89StLoc[7](loc2: u64)
90Branch(93)
B11:
91MoveLoc[25](loc20: u64)
92StLoc[7](loc2: u64)
B12:
93MoveLoc[7](loc2: u64)
94StLoc[15](loc10: u64)
95Call balance::zero<Ty0>(): Balance<Ty0>
96StLoc[23](loc18: Balance<Ty0>)
97Call balance::zero<Ty0>(): Balance<Ty0>
98StLoc[20](loc15: Balance<Ty0>)
99MoveLoc[17](loc12: &mut Bucket<Ty0>)
100CopyLoc[3](Arg3: address)
101CopyLoc[15](loc10: u64)
102MoveLoc[22](loc17: u64)
103LdFalse
104CopyLoc[2](Arg2: &Clock)
105Call bucket::handle_repay<Ty0>(&mut Bucket<Ty0>, address, u64, u64, bool, &Clock): Balance<Ty0>
106StLoc[19](loc14: Balance<Ty0>)
107ImmBorrowLoc[19](loc14: Balance<Ty0>)
108Call balance::value<Ty0>(&Balance<Ty0>): u64
109StLoc[18](loc13: u64)
110ImmBorrowLoc[19](loc14: Balance<Ty0>)
111Call balance::value<Ty0>(&Balance<Ty0>): u64
112Call buck_events::emit_collateral_decreased<Ty0>(u64)
113ImmBorrowLoc[19](loc14: Balance<Ty0>)
114Call balance::value<Ty0>(&Balance<Ty0>): u64
115Call constants::liquidation_rebate(): u64
116Call constants::fee_precision(): u64
117Call math::mul_factor(u64, u64, u64): u64
118StLoc[24](loc19: u64)
119ImmBorrowLoc[19](loc14: Balance<Ty0>)
120Call balance::value<Ty0>(&Balance<Ty0>): u64
121Call constants::liquidation_fee(): u64
122Call constants::fee_precision(): u64
123Call math::mul_factor(u64, u64, u64): u64
124StLoc[21](loc16: u64)
125MutBorrowLoc[23](loc18: Balance<Ty0>)
126MutBorrowLoc[19](loc14: Balance<Ty0>)
127MoveLoc[24](loc19: u64)
128Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
129Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
130Pop
131MutBorrowLoc[20](loc15: Balance<Ty0>)
132MutBorrowLoc[19](loc14: Balance<Ty0>)
133MoveLoc[21](loc16: u64)
134Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
135Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
136Pop
137CopyLoc[0](Arg0: &mut BucketProtocol)
138Call borrow_tank_mut<Ty0>(&mut BucketProtocol): &mut Tank<BUCK, Ty0>
139MoveLoc[19](loc14: Balance<Ty0>)
140CopyLoc[15](loc10: u64)
141Call tank::absorb<BUCK, Ty0>(&mut Tank<BUCK, Ty0>, Balance<Ty0>, u64): Balance<BUCK>
142StLoc[16](loc11: Balance<BUCK>)
143CopyLoc[0](Arg0: &mut BucketProtocol)
144MoveLoc[16](loc11: Balance<BUCK>)
145Call burn_buck<Ty0>(&mut BucketProtocol, Balance<BUCK>)
146CopyLoc[0](Arg0: &mut BucketProtocol)
147Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
148Call bucket::update_snapshot<Ty0>(&mut Bucket<Ty0>)
149ImmBorrowLoc[20](loc15: Balance<Ty0>)
150LdConst[25](vector<u8>: "liq..)
151Call well_events::emit_collect_fee_from<Ty0>(&Balance<Ty0>, vector<u8>)
152MoveLoc[0](Arg0: &mut BucketProtocol)
153Call borrow_well_mut<Ty0>(&mut BucketProtocol): &mut Well<Ty0>
154MoveLoc[20](loc15: Balance<Ty0>)
155Call well::collect_fee<Ty0>(&mut Well<Ty0>, Balance<Ty0>)
156MoveLoc[1](Arg1: &BucketOracle)
157MoveLoc[2](Arg2: &Clock)
158Call bucket_oracle::get_price<Ty0>(&BucketOracle, &Clock): u64 * u64
159MoveLoc[18](loc13: u64)
160MoveLoc[15](loc10: u64)
161MoveLoc[4](Arg4: Option<u64>)
162MoveLoc[3](Arg3: address)
163Call buck_events::emit_liquidation<Ty0>(u64, u64, u64, u64, Option<u64>, address)
164MoveLoc[23](loc18: Balance<Ty0>)
165Ret
}
public flash_borrow<Ty0>(Arg0: &mut BucketProtocol, Arg1: u64): Balance<Ty0> * FlashReceipt<Ty0> {
L2: loc0: &mut Bucket<Ty0>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
5StLoc[2](loc0: &mut Bucket<Ty0>)
6CopyLoc[1](Arg1: u64)
7Call buck_events::emit_flash_loan<Ty0>(u64)
8MoveLoc[2](loc0: &mut Bucket<Ty0>)
9MoveLoc[1](Arg1: u64)
10Call bucket::handle_flash_borrow<Ty0>(&mut Bucket<Ty0>, u64): Balance<Ty0> * FlashReceipt<Ty0>
11Ret
}
public flash_repay<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<Ty0>, Arg2: FlashReceipt<Ty0>) {
L3: loc0: Balance<Ty0>
L4: loc1: &mut Well<Ty0>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
5MoveLoc[1](Arg1: Balance<Ty0>)
6MoveLoc[2](Arg2: FlashReceipt<Ty0>)
7Call bucket::handle_flash_repay<Ty0>(&mut Bucket<Ty0>, Balance<Ty0>, FlashReceipt<Ty0>): Balance<Ty0>
8StLoc[3](loc0: Balance<Ty0>)
9MoveLoc[0](Arg0: &mut BucketProtocol)
10Call borrow_well_mut<Ty0>(&mut BucketProtocol): &mut Well<Ty0>
11StLoc[4](loc1: &mut Well<Ty0>)
12ImmBorrowLoc[3](loc0: Balance<Ty0>)
13LdConst[26](vector<u8>: "fla..)
14Call well_events::emit_collect_fee_from<Ty0>(&Balance<Ty0>, vector<u8>)
15MoveLoc[4](loc1: &mut Well<Ty0>)
16MoveLoc[3](loc0: Balance<Ty0>)
17Call well::collect_fee<Ty0>(&mut Well<Ty0>, Balance<Ty0>)
18Ret
}
public flash_borrow_buck<Ty0>(Arg0: &mut BucketProtocol, Arg1: u64): Balance<BUCK> * FlashReceipt<BUCK, Ty0> {
L2: loc0: &mut Tank<BUCK, Ty0>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_tank_mut<Ty0>(&mut BucketProtocol): &mut Tank<BUCK, Ty0>
5StLoc[2](loc0: &mut Tank<BUCK, Ty0>)
6CopyLoc[1](Arg1: u64)
7Call buck_events::emit_flash_loan<BUCK>(u64)
8MoveLoc[2](loc0: &mut Tank<BUCK, Ty0>)
9MoveLoc[1](Arg1: u64)
10Call tank::handle_flash_borrow<BUCK, Ty0>(&mut Tank<BUCK, Ty0>, u64): Balance<BUCK> * FlashReceipt<BUCK, Ty0>
11Ret
}
public flash_repay_buck<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<BUCK>, Arg2: FlashReceipt<BUCK, Ty0>) {
L3: loc0: Balance<BUCK>
L4: loc1: &mut Well<BUCK>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_tank_mut<Ty0>(&mut BucketProtocol): &mut Tank<BUCK, Ty0>
5MoveLoc[1](Arg1: Balance<BUCK>)
6MoveLoc[2](Arg2: FlashReceipt<BUCK, Ty0>)
7Call tank::handle_flash_repay<BUCK, Ty0>(&mut Tank<BUCK, Ty0>, Balance<BUCK>, FlashReceipt<BUCK, Ty0>): Balance<BUCK>
8StLoc[3](loc0: Balance<BUCK>)
9MoveLoc[0](Arg0: &mut BucketProtocol)
10Call borrow_well_mut<BUCK>(&mut BucketProtocol): &mut Well<BUCK>
11StLoc[4](loc1: &mut Well<BUCK>)
12ImmBorrowLoc[3](loc0: Balance<BUCK>)
13LdConst[26](vector<u8>: "fla..)
14Call well_events::emit_collect_fee_from<BUCK>(&Balance<BUCK>, vector<u8>)
15MoveLoc[4](loc1: &mut Well<BUCK>)
16MoveLoc[3](loc0: Balance<BUCK>)
17Call well::collect_fee<BUCK>(&mut Well<BUCK>, Balance<BUCK>)
18Ret
}
public tank_withdraw<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &Clock, Arg3: &mut BktTreasury, Arg4: ContributorToken<BUCK, Ty0>, Arg5: &TxContext): Balance<BUCK> * Balance<Ty0> * Balance<BKT> {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4FreezeRef
5Call borrow_bucket<Ty0>(&BucketProtocol): &Bucket<Ty0>
6MoveLoc[1](Arg1: &BucketOracle)
7MoveLoc[2](Arg2: &Clock)
8Call bucket::has_liquidatable_bottle<Ty0>(&Bucket<Ty0>, &BucketOracle, &Clock): bool
9Not
10BrFalse(12)
B1:
11Branch(20)
B2:
12MoveLoc[0](Arg0: &mut BucketProtocol)
13Pop
14MoveLoc[5](Arg5: &TxContext)
15Pop
16MoveLoc[3](Arg3: &mut BktTreasury)
17Pop
18LdConst[6](u64: 8)
19Abort
B3:
20MoveLoc[0](Arg0: &mut BucketProtocol)
21Call borrow_tank_mut<Ty0>(&mut BucketProtocol): &mut Tank<BUCK, Ty0>
22MoveLoc[3](Arg3: &mut BktTreasury)
23MoveLoc[4](Arg4: ContributorToken<BUCK, Ty0>)
24MoveLoc[5](Arg5: &TxContext)
25Call tank::withdraw<BUCK, Ty0>(&mut Tank<BUCK, Ty0>, &mut BktTreasury, ContributorToken<BUCK, Ty0>, &TxContext): Balance<BUCK> * Balance<Ty0> * Balance<BKT>
26Ret
}
public get_bottle_info_by_debtor<Ty0>(Arg0: &BucketProtocol, Arg1: address): u64 * u64 {
B0:
0MoveLoc[0](Arg0: &BucketProtocol)
1Call borrow_bucket<Ty0>(&BucketProtocol): &Bucket<Ty0>
2MoveLoc[1](Arg1: address)
3Call bucket::get_bottle_info_by_debtor<Ty0>(&Bucket<Ty0>, address): u64 * u64
4Ret
}
public get_bottle_info_with_interest_by_debtor<Ty0>(Arg0: &BucketProtocol, Arg1: address, Arg2: &Clock): u64 * u64 {
B0:
0MoveLoc[0](Arg0: &BucketProtocol)
1Call borrow_bucket<Ty0>(&BucketProtocol): &Bucket<Ty0>
2MoveLoc[1](Arg1: address)
3MoveLoc[2](Arg2: &Clock)
4Call bucket::get_bottle_info_with_interest_by_debtor<Ty0>(&Bucket<Ty0>, address, &Clock): u64 * u64
5Ret
}
entry public create_bucket<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64, Arg3: u64, Arg4: u8, Arg5: Option<u64>, Arg6: &mut TxContext) {
L7: loc0: BucketType<Ty0>
B0:
0LdFalse
1PackGeneric[1](BucketType<Ty0>)
2StLoc[7](loc0: BucketType<Ty0>)
3CopyLoc[1](Arg1: &mut BucketProtocol)
4ImmBorrowField[1](BucketProtocol.id: UID)
5CopyLoc[7](loc0: BucketType<Ty0>)
6Call dynamic_object_field::exists_with_type<BucketType<Ty0>, Bucket<Ty0>>(&UID, BucketType<Ty0>): bool
7Not
8BrFalse(10)
B1:
9Branch(16)
B2:
10MoveLoc[1](Arg1: &mut BucketProtocol)
11Pop
12MoveLoc[6](Arg6: &mut TxContext)
13Pop
14LdConst[2](u64: 2)
15Abort
B3:
16CopyLoc[1](Arg1: &mut BucketProtocol)
17MutBorrowField[1](BucketProtocol.id: UID)
18MoveLoc[7](loc0: BucketType<Ty0>)
19MoveLoc[2](Arg2: u64)
20MoveLoc[3](Arg3: u64)
21MoveLoc[4](Arg4: u8)
22MoveLoc[5](Arg5: Option<u64>)
23CopyLoc[6](Arg6: &mut TxContext)
24Call bucket::new<Ty0>(u64, u64, u8, Option<u64>, &mut TxContext): Bucket<Ty0>
25Call dynamic_object_field::add<BucketType<Ty0>, Bucket<Ty0>>(&mut UID, BucketType<Ty0>, Bucket<Ty0>)
26CopyLoc[1](Arg1: &mut BucketProtocol)
27MutBorrowField[1](BucketProtocol.id: UID)
28LdFalse
29PackGeneric[2](WellType<Ty0>)
30CopyLoc[6](Arg6: &mut TxContext)
31Call well::new<Ty0>(&mut TxContext): Well<Ty0>
32Call dynamic_object_field::add<WellType<Ty0>, Well<Ty0>>(&mut UID, WellType<Ty0>, Well<Ty0>)
33MoveLoc[1](Arg1: &mut BucketProtocol)
34MutBorrowField[1](BucketProtocol.id: UID)
35LdFalse
36PackGeneric[3](TankType<Ty0>)
37MoveLoc[6](Arg6: &mut TxContext)
38Call tank::new<BUCK, Ty0>(&mut TxContext): Tank<BUCK, Ty0>
39Call dynamic_object_field::add<TankType<Ty0>, Tank<BUCK, Ty0>>(&mut UID, TankType<Ty0>, Tank<BUCK, Ty0>)
40Ret
}
entry public release_bkt<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: &mut BktTreasury, Arg3: u64) {
L4: loc0: Balance<BKT>
B0:
0MoveLoc[2](Arg2: &mut BktTreasury)
1MoveLoc[3](Arg3: u64)
2Call bkt::release_bkt(&mut BktTreasury, u64): Balance<BKT>
3StLoc[4](loc0: Balance<BKT>)
4MoveLoc[1](Arg1: &mut BucketProtocol)
5Call borrow_tank_mut<Ty0>(&mut BucketProtocol): &mut Tank<BUCK, Ty0>
6MoveLoc[4](loc0: Balance<BKT>)
7Call tank::collect_bkt<BUCK, Ty0>(&mut Tank<BUCK, Ty0>, Balance<BKT>)
8Ret
}
entry public update_max_mint_amount<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: Option<u64>) {
L3: loc0: u64
L4: loc1: u64
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2CopyLoc[2](Arg2: Option<u64>)
3Call bucket::update_max_mint_amount<Ty0>(&mut Bucket<Ty0>, Option<u64>)
4ImmBorrowLoc[2](Arg2: Option<u64>)
5Call option::is_some<u64>(&Option<u64>): bool
6BrFalse(11)
B1:
7MoveLoc[2](Arg2: Option<u64>)
8Call option::destroy_some<u64>(Option<u64>): u64
9StLoc[3](loc0: u64)
10Branch(13)
B2:
11LdU64(0)
12StLoc[3](loc0: u64)
B3:
13MoveLoc[3](loc0: u64)
14StLoc[4](loc1: u64)
15LdConst[27](vector<u8>: "max..)
16MoveLoc[4](loc1: u64)
17Call buck_events::emit_param_updated<BucketProtocol>(vector<u8>, u64)
18Ret
}
entry public update_min_bottle_size(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64) {
B0:
0CopyLoc[2](Arg2: u64)
1MoveLoc[1](Arg1: &mut BucketProtocol)
2MutBorrowField[0](BucketProtocol.min_bottle_size: u64)
3WriteRef
4LdConst[28](vector<u8>: "min..)
5MoveLoc[2](Arg2: u64)
6Call buck_events::emit_param_updated<BucketProtocol>(vector<u8>, u64)
7Ret
}
entry public update_protocol_version(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64) {
B0:
0CopyLoc[2](Arg2: u64)
1MoveLoc[1](Arg1: &mut BucketProtocol)
2MutBorrowField[2](BucketProtocol.version: u64)
3WriteRef
4LdConst[29](vector<u8>: "ver..)
5MoveLoc[2](Arg2: u64)
6Call buck_events::emit_param_updated<BucketProtocol>(vector<u8>, u64)
7Ret
}
public borrow_bucket<Ty0>(Arg0: &BucketProtocol): &Bucket<Ty0> {
L1: loc0: BucketType<Ty0>
B0:
0CopyLoc[0](Arg0: &BucketProtocol)
1Call assert_valid_package_version(&BucketProtocol)
2LdFalse
3PackGeneric[1](BucketType<Ty0>)
4StLoc[1](loc0: BucketType<Ty0>)
5CopyLoc[0](Arg0: &BucketProtocol)
6ImmBorrowField[1](BucketProtocol.id: UID)
7CopyLoc[1](loc0: BucketType<Ty0>)
8Call dynamic_object_field::exists_with_type<BucketType<Ty0>, Bucket<Ty0>>(&UID, BucketType<Ty0>): bool
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[0](Arg0: &BucketProtocol)
12Pop
13LdConst[4](u64: 5)
14Abort
B3:
15MoveLoc[0](Arg0: &BucketProtocol)
16ImmBorrowField[1](BucketProtocol.id: UID)
17MoveLoc[1](loc0: BucketType<Ty0>)
18Call dynamic_object_field::borrow<BucketType<Ty0>, Bucket<Ty0>>(&UID, BucketType<Ty0>): &Bucket<Ty0>
19Ret
}
borrow_bucket_mut<Ty0>(Arg0: &mut BucketProtocol): &mut Bucket<Ty0> {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[1](BucketProtocol.id: UID)
5LdFalse
6PackGeneric[1](BucketType<Ty0>)
7Call dynamic_object_field::exists_with_type<BucketType<Ty0>, Bucket<Ty0>>(&UID, BucketType<Ty0>): bool
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[0](Arg0: &mut BucketProtocol)
11Pop
12LdConst[4](u64: 5)
13Abort
B3:
14MoveLoc[0](Arg0: &mut BucketProtocol)
15MutBorrowField[1](BucketProtocol.id: UID)
16LdFalse
17PackGeneric[1](BucketType<Ty0>)
18Call dynamic_object_field::borrow_mut<BucketType<Ty0>, Bucket<Ty0>>(&mut UID, BucketType<Ty0>): &mut Bucket<Ty0>
19Ret
}
public borrow_well<Ty0>(Arg0: &BucketProtocol): &Well<Ty0> {
B0:
0CopyLoc[0](Arg0: &BucketProtocol)
1Call assert_valid_package_version(&BucketProtocol)
2CopyLoc[0](Arg0: &BucketProtocol)
3ImmBorrowField[1](BucketProtocol.id: UID)
4LdFalse
5PackGeneric[2](WellType<Ty0>)
6Call dynamic_object_field::exists_with_type<WellType<Ty0>, Well<Ty0>>(&UID, WellType<Ty0>): bool
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &BucketProtocol)
10Pop
11LdConst[4](u64: 5)
12Abort
B3:
13MoveLoc[0](Arg0: &BucketProtocol)
14ImmBorrowField[1](BucketProtocol.id: UID)
15LdFalse
16PackGeneric[2](WellType<Ty0>)
17Call dynamic_object_field::borrow<WellType<Ty0>, Well<Ty0>>(&UID, WellType<Ty0>): &Well<Ty0>
18Ret
}
public borrow_well_mut<Ty0>(Arg0: &mut BucketProtocol): &mut Well<Ty0> {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[1](BucketProtocol.id: UID)
5LdFalse
6PackGeneric[2](WellType<Ty0>)
7Call dynamic_object_field::exists_with_type<WellType<Ty0>, Well<Ty0>>(&UID, WellType<Ty0>): bool
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[0](Arg0: &mut BucketProtocol)
11Pop
12LdConst[4](u64: 5)
13Abort
B3:
14MoveLoc[0](Arg0: &mut BucketProtocol)
15MutBorrowField[1](BucketProtocol.id: UID)
16LdFalse
17PackGeneric[2](WellType<Ty0>)
18Call dynamic_object_field::borrow_mut<WellType<Ty0>, Well<Ty0>>(&mut UID, WellType<Ty0>): &mut Well<Ty0>
19Ret
}
public borrow_tank<Ty0>(Arg0: &BucketProtocol): &Tank<BUCK, Ty0> {
B0:
0CopyLoc[0](Arg0: &BucketProtocol)
1Call assert_valid_package_version(&BucketProtocol)
2CopyLoc[0](Arg0: &BucketProtocol)
3ImmBorrowField[1](BucketProtocol.id: UID)
4LdFalse
5PackGeneric[3](TankType<Ty0>)
6Call dynamic_object_field::exists_with_type<TankType<Ty0>, Tank<BUCK, Ty0>>(&UID, TankType<Ty0>): bool
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &BucketProtocol)
10Pop
11LdConst[4](u64: 5)
12Abort
B3:
13MoveLoc[0](Arg0: &BucketProtocol)
14ImmBorrowField[1](BucketProtocol.id: UID)
15LdFalse
16PackGeneric[3](TankType<Ty0>)
17Call dynamic_object_field::borrow<TankType<Ty0>, Tank<BUCK, Ty0>>(&UID, TankType<Ty0>): &Tank<BUCK, Ty0>
18Ret
}
public borrow_tank_mut<Ty0>(Arg0: &mut BucketProtocol): &mut Tank<BUCK, Ty0> {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[1](BucketProtocol.id: UID)
5LdFalse
6PackGeneric[3](TankType<Ty0>)
7Call dynamic_object_field::exists_with_type<TankType<Ty0>, Tank<BUCK, Ty0>>(&UID, TankType<Ty0>): bool
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[0](Arg0: &mut BucketProtocol)
11Pop
12LdConst[4](u64: 5)
13Abort
B3:
14MoveLoc[0](Arg0: &mut BucketProtocol)
15MutBorrowField[1](BucketProtocol.id: UID)
16LdFalse
17PackGeneric[3](TankType<Ty0>)
18Call dynamic_object_field::borrow_mut<TankType<Ty0>, Tank<BUCK, Ty0>>(&mut UID, TankType<Ty0>): &mut Tank<BUCK, Ty0>
19Ret
}
public get_min_bottle_size(Arg0: &BucketProtocol): u64 {
B0:
0CopyLoc[0](Arg0: &BucketProtocol)
1Call assert_valid_package_version(&BucketProtocol)
2MoveLoc[0](Arg0: &BucketProtocol)
3ImmBorrowField[0](BucketProtocol.min_bottle_size: u64)
4ReadRef
5Ret
}
public compute_base_rate_fee<Ty0>(Arg0: &Bucket<Ty0>, Arg1: &Clock): u64 {
L2: loc0: u64
B0:
0MoveLoc[0](Arg0: &Bucket<Ty0>)
1MoveLoc[1](Arg1: &Clock)
2Call clock::timestamp_ms(&Clock): u64
3Call bucket::compute_base_rate<Ty0>(&Bucket<Ty0>, u64): u64
4StLoc[2](loc0: u64)
5CopyLoc[2](loc0: u64)
6Call constants::max_fee(): u64
7Gt
8BrFalse(11)
B1:
9Call constants::max_fee(): u64
10StLoc[2](loc0: u64)
B2:
11CopyLoc[2](loc0: u64)
12Call constants::min_fee(): u64
13Lt
14BrFalse(17)
B3:
15Call constants::min_fee(): u64
16StLoc[2](loc0: u64)
B4:
17MoveLoc[2](loc0: u64)
18Ret
}
public withdraw_surplus_collateral<Ty0>(Arg0: &mut BucketProtocol, Arg1: &TxContext): Balance<Ty0> {
L2: loc0: &mut Bucket<Ty0>
L3: loc1: address
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
5StLoc[2](loc0: &mut Bucket<Ty0>)
6MoveLoc[1](Arg1: &TxContext)
7Call tx_context::sender(&TxContext): address
8StLoc[3](loc1: address)
9MoveLoc[2](loc0: &mut Bucket<Ty0>)
10MoveLoc[3](loc1: address)
11Call bucket::withdraw_surplus_collateral<Ty0>(&mut Bucket<Ty0>, address): Balance<Ty0>
12Ret
}
mint_buck<Ty0>(Arg0: &mut BucketProtocol, Arg1: u64): Balance<BUCK> {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[1](Arg1: u64)
4Call buck_events::emit_buck_minted<Ty0>(u64)
5MoveLoc[0](Arg0: &mut BucketProtocol)
6MutBorrowField[3](BucketProtocol.buck_treasury_cap: TreasuryCap<BUCK>)
7MoveLoc[1](Arg1: u64)
8Call coin::mint_balance<BUCK>(&mut TreasuryCap<BUCK>, u64): Balance<BUCK>
9Ret
}
burn_buck<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<BUCK>) {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3ImmBorrowLoc[1](Arg1: Balance<BUCK>)
4Call balance::value<BUCK>(&Balance<BUCK>): u64
5Call buck_events::emit_buck_burnt<Ty0>(u64)
6MoveLoc[0](Arg0: &mut BucketProtocol)
7MutBorrowField[3](BucketProtocol.buck_treasury_cap: TreasuryCap<BUCK>)
8Call coin::supply_mut<BUCK>(&mut TreasuryCap<BUCK>): &mut Supply<BUCK>
9MoveLoc[1](Arg1: Balance<BUCK>)
10Call balance::decrease_supply<BUCK>(&mut Supply<BUCK>, Balance<BUCK>): u64
11Pop
12Ret
}
public create_flash_mint_config_to(Arg0: &AdminCap, Arg1: u64, Arg2: u64, Arg3: address, Arg4: &mut TxContext) {
B0:
0MoveLoc[4](Arg4: &mut TxContext)
1Call object::new(&mut TxContext): UID
2MoveLoc[1](Arg1: u64)
3MoveLoc[2](Arg2: u64)
4LdU64(0)
5Pack[6](FlashMintConfig)
6MoveLoc[3](Arg3: address)
7Call transfer::transfer<FlashMintConfig>(FlashMintConfig, address)
8Ret
}
B0:
0MoveLoc[3](Arg3: &mut TxContext)
1Call object::new(&mut TxContext): UID
2MoveLoc[1](Arg1: u64)
3MoveLoc[2](Arg2: u64)
4LdU64(0)
5Pack[6](FlashMintConfig)
6Call transfer::share_object<FlashMintConfig>(FlashMintConfig)
7Ret
}
public update_flash_mint_config(Arg0: &AdminCap, Arg1: &mut FlashMintConfig, Arg2: u64, Arg3: u64) {
B0:
0CopyLoc[2](Arg2: u64)
1CopyLoc[1](Arg1: &mut FlashMintConfig)
2MutBorrowField[4](FlashMintConfig.fee_rate: u64)
3WriteRef
4LdConst[30](vector<u8>: "fee..)
5MoveLoc[2](Arg2: u64)
6Call buck_events::emit_param_updated<FlashMintConfig>(vector<u8>, u64)
7CopyLoc[3](Arg3: u64)
8MoveLoc[1](Arg1: &mut FlashMintConfig)
9MutBorrowField[5](FlashMintConfig.max_amount: u64)
10WriteRef
11LdConst[31](vector<u8>: "max..)
12MoveLoc[3](Arg3: u64)
13Call buck_events::emit_param_updated<FlashMintConfig>(vector<u8>, u64)
14Ret
}
public flash_mint(Arg0: &mut BucketProtocol, Arg1: &mut FlashMintConfig, Arg2: u64): Balance<BUCK> * FlashMintReceipt {
L3: loc0: ID
L4: loc1: u64
L5: loc2: Balance<BUCK>
L6: loc3: FlashMintReceipt
B0:
0CopyLoc[1](Arg1: &mut FlashMintConfig)
1ImmBorrowField[6](FlashMintConfig.total_amount: u64)
2ReadRef
3CopyLoc[2](Arg2: u64)
4Add
5CopyLoc[1](Arg1: &mut FlashMintConfig)
6MutBorrowField[6](FlashMintConfig.total_amount: u64)
7WriteRef
8CopyLoc[1](Arg1: &mut FlashMintConfig)
9ImmBorrowField[6](FlashMintConfig.total_amount: u64)
10ReadRef
11CopyLoc[1](Arg1: &mut FlashMintConfig)
12ImmBorrowField[5](FlashMintConfig.max_amount: u64)
13ReadRef
14Le
15BrFalse(17)
B1:
16Branch(23)
B2:
17MoveLoc[0](Arg0: &mut BucketProtocol)
18Pop
19MoveLoc[1](Arg1: &mut FlashMintConfig)
20Pop
21LdConst[9](u64: 11)
22Abort
B3:
23CopyLoc[1](Arg1: &mut FlashMintConfig)
24FreezeRef
25Call object::id<FlashMintConfig>(&FlashMintConfig): ID
26StLoc[3](loc0: ID)
27MoveLoc[0](Arg0: &mut BucketProtocol)
28CopyLoc[2](Arg2: u64)
29Call mint_buck<BUCK>(&mut BucketProtocol, u64): Balance<BUCK>
30StLoc[5](loc2: Balance<BUCK>)
31CopyLoc[2](Arg2: u64)
32MoveLoc[1](Arg1: &mut FlashMintConfig)
33ImmBorrowField[4](FlashMintConfig.fee_rate: u64)
34ReadRef
35Call constants::fee_precision(): u64
36Call math::mul_factor(u64, u64, u64): u64
37StLoc[4](loc1: u64)
38CopyLoc[3](loc0: ID)
39CopyLoc[2](Arg2: u64)
40CopyLoc[4](loc1: u64)
41Pack[7](FlashMintReceipt)
42StLoc[6](loc3: FlashMintReceipt)
43MoveLoc[3](loc0: ID)
44MoveLoc[2](Arg2: u64)
45MoveLoc[4](loc1: u64)
46Call buck_events::emit_flash_mint(ID, u64, u64)
47MoveLoc[5](loc2: Balance<BUCK>)
48MoveLoc[6](loc3: FlashMintReceipt)
49Ret
}
public flash_burn(Arg0: &mut BucketProtocol, Arg1: &mut FlashMintConfig, Arg2: Balance<BUCK>, Arg3: FlashMintReceipt) {
L4: loc0: &mut Well<BUCK>
L5: loc1: ID
L6: loc2: Balance<BUCK>
L7: loc3: u64
L8: loc4: u64
B0:
0MoveLoc[3](Arg3: FlashMintReceipt)
1Unpack[7](FlashMintReceipt)
2StLoc[7](loc3: u64)
3StLoc[8](loc4: u64)
4StLoc[5](loc1: ID)
5ImmBorrowLoc[2](Arg2: Balance<BUCK>)
6Call balance::value<BUCK>(&Balance<BUCK>): u64
7CopyLoc[8](loc4: u64)
8CopyLoc[7](loc3: u64)
9Add
10Ge
11BrFalse(13)
B1:
12Branch(19)
B2:
13MoveLoc[0](Arg0: &mut BucketProtocol)
14Pop
15MoveLoc[1](Arg1: &mut FlashMintConfig)
16Pop
17LdConst[10](u64: 12)
18Abort
B3:
19MoveLoc[5](loc1: ID)
20CopyLoc[1](Arg1: &mut FlashMintConfig)
21FreezeRef
22Call object::id<FlashMintConfig>(&FlashMintConfig): ID
23Eq
24BrFalse(26)
B4:
25Branch(32)
B5:
26MoveLoc[0](Arg0: &mut BucketProtocol)
27Pop
28MoveLoc[1](Arg1: &mut FlashMintConfig)
29Pop
30LdConst[11](u64: 13)
31Abort
B6:
32CopyLoc[1](Arg1: &mut FlashMintConfig)
33ImmBorrowField[6](FlashMintConfig.total_amount: u64)
34ReadRef
35MoveLoc[8](loc4: u64)
36Sub
37MoveLoc[1](Arg1: &mut FlashMintConfig)
38MutBorrowField[6](FlashMintConfig.total_amount: u64)
39WriteRef
40MutBorrowLoc[2](Arg2: Balance<BUCK>)
41MoveLoc[7](loc3: u64)
42Call balance::split<BUCK>(&mut Balance<BUCK>, u64): Balance<BUCK>
43StLoc[6](loc2: Balance<BUCK>)
44CopyLoc[0](Arg0: &mut BucketProtocol)
45MoveLoc[2](Arg2: Balance<BUCK>)
46Call burn_buck<BUCK>(&mut BucketProtocol, Balance<BUCK>)
47MoveLoc[0](Arg0: &mut BucketProtocol)
48Call borrow_well_mut<BUCK>(&mut BucketProtocol): &mut Well<BUCK>
49StLoc[4](loc0: &mut Well<BUCK>)
50ImmBorrowLoc[6](loc2: Balance<BUCK>)
51LdConst[32](vector<u8>: "fla..)
52Call well_events::emit_collect_fee_from<BUCK>(&Balance<BUCK>, vector<u8>)
53MoveLoc[4](loc0: &mut Well<BUCK>)
54MoveLoc[6](loc2: Balance<BUCK>)
55Call well::collect_fee<BUCK>(&mut Well<BUCK>, Balance<BUCK>)
56Ret
}
public create_reservoir<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: &mut TxContext) {
L6: loc0: Reservoir<Ty0>
L7: loc1: WellType<Ty0>
B0:
0CopyLoc[1](Arg1: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[2](Arg2: u64)
4MoveLoc[3](Arg3: u64)
5MoveLoc[4](Arg4: u64)
6CopyLoc[5](Arg5: &mut TxContext)
7Call reservoir::new<Ty0>(u64, u64, u64, &mut TxContext): Reservoir<Ty0>
8StLoc[6](loc0: Reservoir<Ty0>)
9CopyLoc[1](Arg1: &mut BucketProtocol)
10MutBorrowField[1](BucketProtocol.id: UID)
11LdFalse
12PackGeneric[4](ReservoirType<Ty0>)
13MoveLoc[6](loc0: Reservoir<Ty0>)
14Call dynamic_object_field::add<ReservoirType<Ty0>, Reservoir<Ty0>>(&mut UID, ReservoirType<Ty0>, Reservoir<Ty0>)
15LdFalse
16PackGeneric[2](WellType<Ty0>)
17StLoc[7](loc1: WellType<Ty0>)
18CopyLoc[1](Arg1: &mut BucketProtocol)
19ImmBorrowField[1](BucketProtocol.id: UID)
20CopyLoc[7](loc1: WellType<Ty0>)
21Call dynamic_object_field::exists_with_type<WellType<Ty0>, Well<Ty0>>(&UID, WellType<Ty0>): bool
22Not
23BrFalse(31)
B1:
24MoveLoc[1](Arg1: &mut BucketProtocol)
25MutBorrowField[1](BucketProtocol.id: UID)
26MoveLoc[7](loc1: WellType<Ty0>)
27MoveLoc[5](Arg5: &mut TxContext)
28Call well::new<Ty0>(&mut TxContext): Well<Ty0>
29Call dynamic_object_field::add<WellType<Ty0>, Well<Ty0>>(&mut UID, WellType<Ty0>, Well<Ty0>)
30Branch(35)
B2:
31MoveLoc[1](Arg1: &mut BucketProtocol)
32Pop
33MoveLoc[5](Arg5: &mut TxContext)
34Pop
B3:
35Ret
}
public borrow_reservoir<Ty0>(Arg0: &BucketProtocol): &Reservoir<Ty0> {
L1: loc0: ReservoirType<Ty0>
B0:
0CopyLoc[0](Arg0: &BucketProtocol)
1Call assert_valid_package_version(&BucketProtocol)
2LdFalse
3PackGeneric[4](ReservoirType<Ty0>)
4StLoc[1](loc0: ReservoirType<Ty0>)
5CopyLoc[0](Arg0: &BucketProtocol)
6ImmBorrowField[1](BucketProtocol.id: UID)
7CopyLoc[1](loc0: ReservoirType<Ty0>)
8Call dynamic_object_field::exists_with_type<ReservoirType<Ty0>, Reservoir<Ty0>>(&UID, ReservoirType<Ty0>): bool
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[0](Arg0: &BucketProtocol)
12Pop
13LdConst[4](u64: 5)
14Abort
B3:
15MoveLoc[0](Arg0: &BucketProtocol)
16ImmBorrowField[1](BucketProtocol.id: UID)
17MoveLoc[1](loc0: ReservoirType<Ty0>)
18Call dynamic_object_field::borrow<ReservoirType<Ty0>, Reservoir<Ty0>>(&UID, ReservoirType<Ty0>): &Reservoir<Ty0>
19Ret
}
borrow_reservoir_mut<Ty0>(Arg0: &mut BucketProtocol): &mut Reservoir<Ty0> {
L1: loc0: ReservoirType<Ty0>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3LdFalse
4PackGeneric[4](ReservoirType<Ty0>)
5StLoc[1](loc0: ReservoirType<Ty0>)
6CopyLoc[0](Arg0: &mut BucketProtocol)
7ImmBorrowField[1](BucketProtocol.id: UID)
8CopyLoc[1](loc0: ReservoirType<Ty0>)
9Call dynamic_object_field::exists_with_type<ReservoirType<Ty0>, Reservoir<Ty0>>(&UID, ReservoirType<Ty0>): bool
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut BucketProtocol)
13Pop
14LdConst[4](u64: 5)
15Abort
B3:
16MoveLoc[0](Arg0: &mut BucketProtocol)
17MutBorrowField[1](BucketProtocol.id: UID)
18MoveLoc[1](loc0: ReservoirType<Ty0>)
19Call dynamic_object_field::borrow_mut<ReservoirType<Ty0>, Reservoir<Ty0>>(&mut UID, ReservoirType<Ty0>): &mut Reservoir<Ty0>
20Ret
}
public update_reservoir_fee_rate<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64, Arg3: u64) {
B0:
0CopyLoc[1](Arg1: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[1](Arg1: &mut BucketProtocol)
4Call borrow_reservoir_mut<Ty0>(&mut BucketProtocol): &mut Reservoir<Ty0>
5CopyLoc[2](Arg2: u64)
6CopyLoc[3](Arg3: u64)
7Call reservoir::update_fee_rate<Ty0>(&mut Reservoir<Ty0>, u64, u64)
8LdConst[33](vector<u8>: "cha..)
9MoveLoc[2](Arg2: u64)
10Call buck_events::emit_param_updated<Reservoir<Ty0>>(vector<u8>, u64)
11LdConst[34](vector<u8>: "dis..)
12MoveLoc[3](Arg3: u64)
13Call buck_events::emit_param_updated<Reservoir<Ty0>>(vector<u8>, u64)
14Ret
}
public charge_reservoir<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<Ty0>): Balance<BUCK> {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call borrow_reservoir<Ty0>(&BucketProtocol): &Reservoir<Ty0>
3Call reservoir::charge_fee_rate<Ty0>(&Reservoir<Ty0>): u64
4StLoc[2](loc0: u64)
5MoveLoc[0](Arg0: &mut BucketProtocol)
6MoveLoc[1](Arg1: Balance<Ty0>)
7MoveLoc[2](loc0: u64)
8Call charge_reservoir_internal<Ty0>(&mut BucketProtocol, Balance<Ty0>, u64): Balance<BUCK>
9Ret
}
public discharge_reservoir<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<BUCK>): Balance<Ty0> {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call borrow_reservoir<Ty0>(&BucketProtocol): &Reservoir<Ty0>
3Call reservoir::discharge_fee_rate<Ty0>(&Reservoir<Ty0>): u64
4StLoc[2](loc0: u64)
5MoveLoc[0](Arg0: &mut BucketProtocol)
6MoveLoc[1](Arg1: Balance<BUCK>)
7MoveLoc[2](loc0: u64)
8Call discharge_reservoir_internal<Ty0>(&mut BucketProtocol, Balance<BUCK>, u64): Balance<Ty0>
9Ret
}
public charge_reservoir_without_fee<Ty0>(Arg0: &NoFeePermission, Arg1: &mut BucketProtocol, Arg2: Balance<Ty0>): Balance<BUCK> {
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1MoveLoc[2](Arg2: Balance<Ty0>)
2LdU64(0)
3Call charge_reservoir_internal<Ty0>(&mut BucketProtocol, Balance<Ty0>, u64): Balance<BUCK>
4Ret
}
public discharge_reservoir_without_fee<Ty0>(Arg0: &NoFeePermission, Arg1: &mut BucketProtocol, Arg2: Balance<BUCK>): Balance<Ty0> {
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1MoveLoc[2](Arg2: Balance<BUCK>)
2LdU64(0)
3Call discharge_reservoir_internal<Ty0>(&mut BucketProtocol, Balance<BUCK>, u64): Balance<Ty0>
4Ret
}
public create_no_fee_permission_to(Arg0: &AdminCap, Arg1: address, Arg2: &mut TxContext) {
B0:
0MoveLoc[2](Arg2: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Pack[8](NoFeePermission)
3MoveLoc[1](Arg1: address)
4Call transfer::transfer<NoFeePermission>(NoFeePermission, address)
5Ret
}
public set_reservoir_partner<Ty0, Ty1: drop>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64, Arg3: u64) {
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1Call borrow_reservoir_mut<Ty0>(&mut BucketProtocol): &mut Reservoir<Ty0>
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: u64)
4Call reservoir::set_fee_config<Ty0, Ty1>(&mut Reservoir<Ty0>, u64, u64)
5Ret
}
public charge_reservoir_by_partner<Ty0, Ty1: drop>(Arg0: &mut BucketProtocol, Arg1: Balance<Ty0>, Arg2: Ty1): Balance<BUCK> {
L3: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call borrow_reservoir<Ty0>(&BucketProtocol): &Reservoir<Ty0>
3Call reservoir::charge_fee_rate_for_partner<Ty0, Ty1>(&Reservoir<Ty0>): u64
4StLoc[3](loc0: u64)
5MoveLoc[0](Arg0: &mut BucketProtocol)
6MoveLoc[1](Arg1: Balance<Ty0>)
7MoveLoc[3](loc0: u64)
8Call charge_reservoir_internal<Ty0>(&mut BucketProtocol, Balance<Ty0>, u64): Balance<BUCK>
9Ret
}
public discharge_reservoir_by_partner<Ty0, Ty1: drop>(Arg0: &mut BucketProtocol, Arg1: Balance<BUCK>, Arg2: Ty1): Balance<Ty0> {
L3: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call borrow_reservoir<Ty0>(&BucketProtocol): &Reservoir<Ty0>
3Call reservoir::discharge_fee_rate_for_partner<Ty0, Ty1>(&Reservoir<Ty0>): u64
4StLoc[3](loc0: u64)
5MoveLoc[0](Arg0: &mut BucketProtocol)
6MoveLoc[1](Arg1: Balance<BUCK>)
7MoveLoc[3](loc0: u64)
8Call discharge_reservoir_internal<Ty0>(&mut BucketProtocol, Balance<BUCK>, u64): Balance<Ty0>
9Ret
}
charge_reservoir_internal<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<Ty0>, Arg2: u64): Balance<BUCK> {
L3: loc0: u64
L4: loc1: Balance<BUCK>
L5: loc2: u64
L6: loc3: Balance<BUCK>
L7: loc4: &mut Well<BUCK>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1Call borrow_reservoir_mut<Ty0>(&mut BucketProtocol): &mut Reservoir<Ty0>
2MoveLoc[1](Arg1: Balance<Ty0>)
3Call reservoir::handle_charge<Ty0>(&mut Reservoir<Ty0>, Balance<Ty0>): u64
4StLoc[3](loc0: u64)
5CopyLoc[3](loc0: u64)
6MoveLoc[2](Arg2: u64)
7Call constants::fee_precision(): u64
8Call math::mul_factor(u64, u64, u64): u64
9StLoc[5](loc2: u64)
10CopyLoc[0](Arg0: &mut BucketProtocol)
11MoveLoc[3](loc0: u64)
12Call mint_buck<Ty0>(&mut BucketProtocol, u64): Balance<BUCK>
13StLoc[6](loc3: Balance<BUCK>)
14MutBorrowLoc[6](loc3: Balance<BUCK>)
15MoveLoc[5](loc2: u64)
16Call balance::split<BUCK>(&mut Balance<BUCK>, u64): Balance<BUCK>
17StLoc[4](loc1: Balance<BUCK>)
18MoveLoc[0](Arg0: &mut BucketProtocol)
19Call borrow_well_mut<BUCK>(&mut BucketProtocol): &mut Well<BUCK>
20StLoc[7](loc4: &mut Well<BUCK>)
21ImmBorrowLoc[4](loc1: Balance<BUCK>)
22LdConst[35](vector<u8>: "cha..)
23Call well_events::emit_collect_fee_from<BUCK>(&Balance<BUCK>, vector<u8>)
24MoveLoc[7](loc4: &mut Well<BUCK>)
25MoveLoc[4](loc1: Balance<BUCK>)
26Call well::collect_fee<BUCK>(&mut Well<BUCK>, Balance<BUCK>)
27MoveLoc[6](loc3: Balance<BUCK>)
28Ret
}
discharge_reservoir_internal<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<BUCK>, Arg2: u64): Balance<Ty0> {
L3: loc0: u64
L4: loc1: Balance<Ty0>
L5: loc2: Balance<Ty0>
L6: loc3: u64
L7: loc4: &mut Well<Ty0>
B0:
0ImmBorrowLoc[1](Arg1: Balance<BUCK>)
1Call balance::value<BUCK>(&Balance<BUCK>): u64
2StLoc[3](loc0: u64)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4MoveLoc[1](Arg1: Balance<BUCK>)
5Call burn_buck<Ty0>(&mut BucketProtocol, Balance<BUCK>)
6CopyLoc[0](Arg0: &mut BucketProtocol)
7Call borrow_reservoir_mut<Ty0>(&mut BucketProtocol): &mut Reservoir<Ty0>
8MoveLoc[3](loc0: u64)
9Call reservoir::handle_discharge<Ty0>(&mut Reservoir<Ty0>, u64): Balance<Ty0>
10StLoc[4](loc1: Balance<Ty0>)
11ImmBorrowLoc[4](loc1: Balance<Ty0>)
12Call balance::value<Ty0>(&Balance<Ty0>): u64
13MoveLoc[2](Arg2: u64)
14Call constants::fee_precision(): u64
15Call math::mul_factor(u64, u64, u64): u64
16StLoc[6](loc3: u64)
17MutBorrowLoc[4](loc1: Balance<Ty0>)
18MoveLoc[6](loc3: u64)
19Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
20StLoc[5](loc2: Balance<Ty0>)
21MoveLoc[0](Arg0: &mut BucketProtocol)
22Call borrow_well_mut<Ty0>(&mut BucketProtocol): &mut Well<Ty0>
23StLoc[7](loc4: &mut Well<Ty0>)
24ImmBorrowLoc[5](loc2: Balance<Ty0>)
25LdConst[36](vector<u8>: "dis..)
26Call well_events::emit_collect_fee_from<Ty0>(&Balance<Ty0>, vector<u8>)
27MoveLoc[7](loc4: &mut Well<Ty0>)
28MoveLoc[5](loc2: Balance<Ty0>)
29Call well::collect_fee<Ty0>(&mut Well<Ty0>, Balance<Ty0>)
30MoveLoc[4](loc1: Balance<Ty0>)
31Ret
}
public collect_interests<Ty0>(Arg0: &mut BucketProtocol) {
L1: loc0: Balance<BUCK>
L2: loc1: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
5Call bucket::borrow_interest_table_mut<Ty0>(&mut Bucket<Ty0>): &mut InterestTable
6Call interest::collect_interests(&mut InterestTable): u64
7StLoc[2](loc1: u64)
8CopyLoc[0](Arg0: &mut BucketProtocol)
9MoveLoc[2](loc1: u64)
10Call mint_buck<Ty0>(&mut BucketProtocol, u64): Balance<BUCK>
11StLoc[1](loc0: Balance<BUCK>)
12ImmBorrowLoc[1](loc0: Balance<BUCK>)
13LdConst[37](vector<u8>: "int..)
14Call well_events::emit_collect_fee_from<BUCK>(&Balance<BUCK>, vector<u8>)
15MoveLoc[0](Arg0: &mut BucketProtocol)
16Call borrow_well_mut<BUCK>(&mut BucketProtocol): &mut Well<BUCK>
17MoveLoc[1](loc0: Balance<BUCK>)
18Call well::collect_fee<BUCK>(&mut Well<BUCK>, Balance<BUCK>)
19Ret
}
public collect_interests_to_flask<Ty0>(Arg0: &mut BucketProtocol, Arg1: &mut Flask<BUCK>) {
B0:
0LdConst[18](u64: 404)
1Abort
}
public mint_sbuck(Arg0: &mut BucketProtocol, Arg1: &mut Flask<BUCK>, Arg2: Coin<BUCK>): Balance<SBUCK> {
B0:
0LdConst[18](u64: 404)
1Abort
}
public burn_sbuck(Arg0: &mut BucketProtocol, Arg1: &mut Flask<BUCK>, Arg2: Coin<SBUCK>): Balance<BUCK> {
B0:
0LdConst[18](u64: 404)
1Abort
}
public set_sbuck_rate(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: &mut Flask<BUCK>, Arg3: &Clock, Arg4: u64, Arg5: &mut TxContext) {
L6: loc0: u64
L7: loc1: &mut SBuckEmission
B0:
0CopyLoc[1](Arg1: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[3](Arg3: &Clock)
4Call clock::timestamp_ms(&Clock): u64
5StLoc[6](loc0: u64)
6CopyLoc[1](Arg1: &mut BucketProtocol)
7FreezeRef
8Call has_emission(&BucketProtocol): bool
9BrFalse(29)
B1:
10MoveLoc[5](Arg5: &mut TxContext)
11Pop
12CopyLoc[1](Arg1: &mut BucketProtocol)
13MoveLoc[2](Arg2: &mut Flask<BUCK>)
14MoveLoc[3](Arg3: &Clock)
15Call collect_interest(&mut BucketProtocol, &mut Flask<BUCK>, &Clock)
16MoveLoc[1](Arg1: &mut BucketProtocol)
17Call emission_mut(&mut BucketProtocol): &mut SBuckEmission
18StLoc[7](loc1: &mut SBuckEmission)
19MoveLoc[6](loc0: u64)
20CopyLoc[7](loc1: &mut SBuckEmission)
21MutBorrowField[7](SBuckEmission.latest_time: u64)
22WriteRef
23MoveLoc[4](Arg4: u64)
24Call float::from_bps(u64): Float
25MoveLoc[7](loc1: &mut SBuckEmission)
26MutBorrowField[8](SBuckEmission.rate: Float)
27WriteRef
28Branch(44)
B2:
29MoveLoc[2](Arg2: &mut Flask<BUCK>)
30Pop
31MoveLoc[3](Arg3: &Clock)
32Pop
33MoveLoc[1](Arg1: &mut BucketProtocol)
34MutBorrowField[1](BucketProtocol.id: UID)
35LdFalse
36Pack[10](SBuckRateKey)
37MoveLoc[5](Arg5: &mut TxContext)
38Call object::new(&mut TxContext): UID
39MoveLoc[6](loc0: u64)
40MoveLoc[4](Arg4: u64)
41Call float::from_bps(u64): Float
42Pack[11](SBuckEmission)
43Call dynamic_object_field::add<SBuckRateKey, SBuckEmission>(&mut UID, SBuckRateKey, SBuckEmission)
B3:
44Ret
}
public interest_amount(Arg0: &BucketProtocol, Arg1: &Flask<BUCK>, Arg2: &Clock): u64 {
L3: loc0: u64
L4: loc1: &SBuckEmission
L5: loc2: Float
L6: loc3: u64
L7: loc4: Float
L8: loc5: Float
B0:
0CopyLoc[0](Arg0: &BucketProtocol)
1Call has_emission(&BucketProtocol): bool
2BrFalse(34)
B1:
3MoveLoc[0](Arg0: &BucketProtocol)
4Call emission(&BucketProtocol): &SBuckEmission
5StLoc[4](loc1: &SBuckEmission)
6MoveLoc[2](Arg2: &Clock)
7Call clock::timestamp_ms(&Clock): u64
8CopyLoc[4](loc1: &SBuckEmission)
9ImmBorrowField[7](SBuckEmission.latest_time: u64)
10ReadRef
11Sub
12StLoc[6](loc3: u64)
13MoveLoc[1](Arg1: &Flask<BUCK>)
14Call sbuck::reserves<BUCK>(&Flask<BUCK>): u64
15Call float::from(u64): Float
16StLoc[5](loc2: Float)
17MoveLoc[6](loc3: u64)
18Call constants::ms_in_year(): u256
19CastU64
20Call float::from_fraction(u64, u64): Float
21StLoc[7](loc4: Float)
22MoveLoc[4](loc1: &SBuckEmission)
23ImmBorrowField[8](SBuckEmission.rate: Float)
24ReadRef
25MoveLoc[7](loc4: Float)
26Call float::mul(Float, Float): Float
27StLoc[8](loc5: Float)
28MoveLoc[5](loc2: Float)
29MoveLoc[8](loc5: Float)
30Call float::mul(Float, Float): Float
31Call float::floor(Float): u64
32StLoc[3](loc0: u64)
33Branch(42)
B2:
34MoveLoc[0](Arg0: &BucketProtocol)
35Pop
36MoveLoc[1](Arg1: &Flask<BUCK>)
37Pop
38MoveLoc[2](Arg2: &Clock)
39Pop
40LdU64(0)
41StLoc[3](loc0: u64)
B3:
42MoveLoc[3](loc0: u64)
43Ret
}
public buck_to_sbuck(Arg0: &mut BucketProtocol, Arg1: &mut Flask<BUCK>, Arg2: &Clock, Arg3: Balance<BUCK>): Balance<SBUCK> {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[0](Arg0: &mut BucketProtocol)
4CopyLoc[1](Arg1: &mut Flask<BUCK>)
5MoveLoc[2](Arg2: &Clock)
6Call collect_interest(&mut BucketProtocol, &mut Flask<BUCK>, &Clock)
7MoveLoc[1](Arg1: &mut Flask<BUCK>)
8LdFalse
9Pack[12](BUCKET_PROTOCOL)
10MoveLoc[3](Arg3: Balance<BUCK>)
11Call sbuck::deposit_by_protocol<BUCK, BUCKET_PROTOCOL>(&mut Flask<BUCK>, BUCKET_PROTOCOL, Balance<BUCK>): Balance<SBUCK>
12Ret
}
public sbuck_to_buck(Arg0: &mut BucketProtocol, Arg1: &mut Flask<BUCK>, Arg2: &Clock, Arg3: Balance<SBUCK>): Balance<BUCK> {
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[0](Arg0: &mut BucketProtocol)
4CopyLoc[1](Arg1: &mut Flask<BUCK>)
5MoveLoc[2](Arg2: &Clock)
6Call collect_interest(&mut BucketProtocol, &mut Flask<BUCK>, &Clock)
7MoveLoc[1](Arg1: &mut Flask<BUCK>)
8LdFalse
9Pack[12](BUCKET_PROTOCOL)
10MoveLoc[3](Arg3: Balance<SBUCK>)
11Call sbuck::withdraw_by_protocol<BUCK, BUCKET_PROTOCOL>(&mut Flask<BUCK>, BUCKET_PROTOCOL, Balance<SBUCK>): Balance<BUCK>
12Ret
}
collect_interest(Arg0: &mut BucketProtocol, Arg1: &mut Flask<BUCK>, Arg2: &Clock) {
L3: loc0: &mut Flask<BUCK>
L4: loc1: &Clock
L5: loc2: &mut SBuckEmission
L6: loc3: Balance<BUCK>
L7: loc4: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1CopyLoc[1](Arg1: &mut Flask<BUCK>)
2CopyLoc[2](Arg2: &Clock)
3StLoc[4](loc1: &Clock)
4StLoc[3](loc0: &mut Flask<BUCK>)
5FreezeRef
6MoveLoc[3](loc0: &mut Flask<BUCK>)
7FreezeRef
8MoveLoc[4](loc1: &Clock)
9Call interest_amount(&BucketProtocol, &Flask<BUCK>, &Clock): u64
10StLoc[7](loc4: u64)
11CopyLoc[0](Arg0: &mut BucketProtocol)
12MoveLoc[7](loc4: u64)
13Call mint_buck<SBUCK>(&mut BucketProtocol, u64): Balance<BUCK>
14StLoc[6](loc3: Balance<BUCK>)
15MoveLoc[0](Arg0: &mut BucketProtocol)
16Call emission_mut(&mut BucketProtocol): &mut SBuckEmission
17StLoc[5](loc2: &mut SBuckEmission)
18MoveLoc[2](Arg2: &Clock)
19Call clock::timestamp_ms(&Clock): u64
20MoveLoc[5](loc2: &mut SBuckEmission)
21MutBorrowField[7](SBuckEmission.latest_time: u64)
22WriteRef
23MoveLoc[1](Arg1: &mut Flask<BUCK>)
24MoveLoc[6](loc3: Balance<BUCK>)
25Call sbuck::collect_rewards<BUCK>(&mut Flask<BUCK>, Balance<BUCK>)
26Ret
}
has_emission(Arg0: &BucketProtocol): bool {
B0:
0MoveLoc[0](Arg0: &BucketProtocol)
1ImmBorrowField[1](BucketProtocol.id: UID)
2LdFalse
3Pack[10](SBuckRateKey)
4Call dynamic_object_field::exists_with_type<SBuckRateKey, SBuckEmission>(&UID, SBuckRateKey): bool
5Ret
}
emission(Arg0: &BucketProtocol): &SBuckEmission {
B0:
0MoveLoc[0](Arg0: &BucketProtocol)
1ImmBorrowField[1](BucketProtocol.id: UID)
2LdFalse
3Pack[10](SBuckRateKey)
4Call dynamic_object_field::borrow<SBuckRateKey, SBuckEmission>(&UID, SBuckRateKey): &SBuckEmission
5Ret
}
emission_mut(Arg0: &mut BucketProtocol): &mut SBuckEmission {
B0:
0MoveLoc[0](Arg0: &mut BucketProtocol)
1MutBorrowField[1](BucketProtocol.id: UID)
2LdFalse
3Pack[10](SBuckRateKey)
4Call dynamic_object_field::borrow_mut<SBuckRateKey, SBuckEmission>(&mut UID, SBuckRateKey): &mut SBuckEmission
5Ret
}
public create_bucket_with_interest_table<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64, Arg3: u64, Arg4: u8, Arg5: Option<u64>, Arg6: &Clock, Arg7: u256, Arg8: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut BucketProtocol)
2MoveLoc[2](Arg2: u64)
3MoveLoc[3](Arg3: u64)
4MoveLoc[4](Arg4: u8)
5MoveLoc[5](Arg5: Option<u64>)
6CopyLoc[8](Arg8: &mut TxContext)
7Call create_bucket<Ty0>(&AdminCap, &mut BucketProtocol, u64, u64, u8, Option<u64>, &mut TxContext)
8CopyLoc[0](Arg0: &AdminCap)
9CopyLoc[1](Arg1: &mut BucketProtocol)
10CopyLoc[8](Arg8: &mut TxContext)
11Call add_pending_record_to_bucket<Ty0>(&AdminCap, &mut BucketProtocol, &mut TxContext)
12CopyLoc[0](Arg0: &AdminCap)
13CopyLoc[1](Arg1: &mut BucketProtocol)
14CopyLoc[6](Arg6: &Clock)
15MoveLoc[8](Arg8: &mut TxContext)
16Call add_interest_table_to_bucket<Ty0>(&AdminCap, &mut BucketProtocol, &Clock, &mut TxContext)
17MoveLoc[0](Arg0: &AdminCap)
18MoveLoc[1](Arg1: &mut BucketProtocol)
19MoveLoc[7](Arg7: u256)
20MoveLoc[6](Arg6: &Clock)
21Call set_interest_rate<Ty0>(&AdminCap, &mut BucketProtocol, u256, &Clock)
22Ret
}
public add_interest_table_to_bucket<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: &Clock, Arg3: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2MoveLoc[2](Arg2: &Clock)
3MoveLoc[3](Arg3: &mut TxContext)
4Call bucket::add_interest_table_to_bucket<Ty0>(&mut Bucket<Ty0>, &Clock, &mut TxContext)
5Ret
}
public set_interest_rate<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u256, Arg3: &Clock) {
L4: loc0: &mut Bucket<Ty0>
L5: loc1: u64
L6: loc2: u64
L7: loc3: &mut InterestTable
L8: loc4: u256
B0:
0CopyLoc[2](Arg2: u256)
1LdU256(10000)
2Le
3BrFalse(5)
B1:
4Branch(11)
B2:
5MoveLoc[1](Arg1: &mut BucketProtocol)
6Pop
7MoveLoc[3](Arg3: &Clock)
8Pop
9LdConst[14](u64: 16)
10Abort
B3:
11MoveLoc[1](Arg1: &mut BucketProtocol)
12Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
13StLoc[4](loc0: &mut Bucket<Ty0>)
14CopyLoc[4](loc0: &mut Bucket<Ty0>)
15FreezeRef
16Call bucket::get_minted_buck_amount<Ty0>(&Bucket<Ty0>): u64
17StLoc[5](loc1: u64)
18CopyLoc[4](loc0: &mut Bucket<Ty0>)
19FreezeRef
20Call bucket::get_bucket_pending_debt<Ty0>(&Bucket<Ty0>): u64
21StLoc[6](loc2: u64)
22MoveLoc[4](loc0: &mut Bucket<Ty0>)
23Call bucket::borrow_interest_table_mut<Ty0>(&mut Bucket<Ty0>): &mut InterestTable
24StLoc[7](loc3: &mut InterestTable)
25CopyLoc[2](Arg2: u256)
26Call constants::interest_precision(): u256
27LdU256(10000)
28Call constants::ms_in_year(): u256
29Mul
30Call 0math::mul_factor_u256(u256, u256, u256): u256
31StLoc[8](loc4: u256)
32MoveLoc[7](loc3: &mut InterestTable)
33MoveLoc[8](loc4: u256)
34MoveLoc[5](loc1: u64)
35MoveLoc[6](loc2: u64)
36Sub
37MoveLoc[3](Arg3: &Clock)
38Call interest::set_interest_rate(&mut InterestTable, u256, u64, &Clock)
39LdConst[38](vector<u8>: "int..)
40MoveLoc[2](Arg2: u256)
41CastU64
42Call buck_events::emit_param_updated<Bucket<Ty0>>(vector<u8>, u64)
43Ret
}
public init_bottle_current_interest_index<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: address, Arg3: &mut TxContext) {
L4: loc0: u256
L5: loc1: &mut Bucket<Ty0>
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2StLoc[5](loc1: &mut Bucket<Ty0>)
3CopyLoc[5](loc1: &mut Bucket<Ty0>)
4FreezeRef
5Call bucket::borrow_interest_table<Ty0>(&Bucket<Ty0>): &InterestTable
6Call interest::get_active_interest_index(&InterestTable): u256
7StLoc[4](loc0: u256)
8MoveLoc[5](loc1: &mut Bucket<Ty0>)
9MoveLoc[2](Arg2: address)
10MoveLoc[4](loc0: u256)
11MoveLoc[3](Arg3: &mut TxContext)
12Call bucket::add_interest_index_to_bottle_by_debtor<Ty0>(&mut Bucket<Ty0>, address, u256, &mut TxContext)
13Ret
}
public init_bottle_interest_index<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: address, Arg3: u256, Arg4: &mut TxContext) {
L5: loc0: &mut Bucket<Ty0>
L6: loc1: &mut InterestTable
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2StLoc[5](loc0: &mut Bucket<Ty0>)
3CopyLoc[5](loc0: &mut Bucket<Ty0>)
4Call bucket::borrow_interest_table_mut<Ty0>(&mut Bucket<Ty0>): &mut InterestTable
5StLoc[6](loc1: &mut InterestTable)
6CopyLoc[3](Arg3: u256)
7MoveLoc[6](loc1: &mut InterestTable)
8FreezeRef
9Call interest::get_active_interest_index(&InterestTable): u256
10Ge
11BrFalse(13)
B1:
12Branch(19)
B2:
13MoveLoc[4](Arg4: &mut TxContext)
14Pop
15MoveLoc[5](loc0: &mut Bucket<Ty0>)
16Pop
17LdConst[13](u64: 15)
18Abort
B3:
19MoveLoc[5](loc0: &mut Bucket<Ty0>)
20MoveLoc[2](Arg2: address)
21MoveLoc[3](Arg3: u256)
22MoveLoc[4](Arg4: &mut TxContext)
23Call bucket::add_interest_index_to_bottle_by_debtor<Ty0>(&mut Bucket<Ty0>, address, u256, &mut TxContext)
24Ret
}
public add_pending_record_to_bucket<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2MoveLoc[2](Arg2: &mut TxContext)
3Call bucket::add_pending_record_to_bucket<Ty0>(&mut Bucket<Ty0>, &mut TxContext)
4Ret
}
public adjust_pending_record<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol) {
L2: loc0: &Bottle
L3: loc1: &BottleTable
L4: loc2: &mut Bucket<Ty0>
L5: loc3: Option<address>
L6: loc4: address
L7: loc5: u64
L8: loc6: u64
B0:
0LdU64(0)
1StLoc[7](loc5: u64)
2LdU64(0)
3StLoc[8](loc6: u64)
4MoveLoc[1](Arg1: &mut BucketProtocol)
5Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
6StLoc[4](loc2: &mut Bucket<Ty0>)
7CopyLoc[4](loc2: &mut Bucket<Ty0>)
8FreezeRef
9Call bucket::borrow_bottle_table<Ty0>(&Bucket<Ty0>): &BottleTable
10StLoc[3](loc1: &BottleTable)
11CopyLoc[3](loc1: &BottleTable)
12Call bottle::borrow_table(&BottleTable): &LinkedTable<address, Bottle>
13Call linked_table::front<address, Bottle>(&LinkedTable<address, Bottle>): &Option<address>
14ReadRef
15StLoc[5](loc3: Option<address>)
B1:
16ImmBorrowLoc[5](loc3: Option<address>)
17Call option::is_some<address>(&Option<address>): bool
18BrFalse(46)
B2:
19Branch(20)
B3:
20MoveLoc[5](loc3: Option<address>)
21Call option::destroy_some<address>(Option<address>): address
22StLoc[6](loc4: address)
23CopyLoc[3](loc1: &BottleTable)
24CopyLoc[6](loc4: address)
25Call bottle::borrow_bottle(&BottleTable, address): &Bottle
26StLoc[2](loc0: &Bottle)
27MoveLoc[7](loc5: u64)
28CopyLoc[2](loc0: &Bottle)
29CopyLoc[3](loc1: &BottleTable)
30Call bottle::get_pending_coll(&Bottle, &BottleTable): u64
31Add
32StLoc[7](loc5: u64)
33MoveLoc[8](loc6: u64)
34MoveLoc[2](loc0: &Bottle)
35CopyLoc[3](loc1: &BottleTable)
36Call bottle::get_pending_debt(&Bottle, &BottleTable): u64
37Add
38StLoc[8](loc6: u64)
39CopyLoc[3](loc1: &BottleTable)
40Call bottle::borrow_table(&BottleTable): &LinkedTable<address, Bottle>
41MoveLoc[6](loc4: address)
42Call linked_table::next<address, Bottle>(&LinkedTable<address, Bottle>, address): &Option<address>
43ReadRef
44StLoc[5](loc3: Option<address>)
45Branch(16)
B4:
46MoveLoc[3](loc1: &BottleTable)
47Pop
48MoveLoc[4](loc2: &mut Bucket<Ty0>)
49MoveLoc[7](loc5: u64)
50MoveLoc[8](loc6: u64)
51Call bucket::adjust_pending_record<Ty0>(&mut Bucket<Ty0>, u64, u64)
52Ret
}
public borrow_with_strap<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &BottleStrap<Ty0>, Arg3: &Clock, Arg4: Balance<Ty0>, Arg5: u64, Arg6: Option<address>, Arg7: &mut TxContext): Balance<BUCK> {
L8: loc0: &Clock
L9: loc1: u64
L10: loc2: address
L11: loc3: &mut Bucket<Ty0>
L12: loc4: Balance<BUCK>
L13: loc5: u64
L14: loc6: u64
L15: loc7: u64
L16: loc8: Option<u64>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[0](BucketProtocol.min_bottle_size: u64)
5ReadRef
6StLoc[15](loc7: u64)
7CopyLoc[0](Arg0: &mut BucketProtocol)
8Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
9StLoc[11](loc3: &mut Bucket<Ty0>)
10CopyLoc[2](Arg2: &BottleStrap<Ty0>)
11Call strap::fee_rate<Ty0>(&BottleStrap<Ty0>): Option<u64>
12StLoc[16](loc8: Option<u64>)
13ImmBorrowLoc[16](loc8: Option<u64>)
14Call option::is_none<u64>(&Option<u64>): bool
15BrFalse(24)
B1:
16CopyLoc[11](loc3: &mut Bucket<Ty0>)
17CopyLoc[3](Arg3: &Clock)
18StLoc[8](loc0: &Clock)
19FreezeRef
20MoveLoc[8](loc0: &Clock)
21Call compute_base_rate_fee<Ty0>(&Bucket<Ty0>, &Clock): u64
22StLoc[9](loc1: u64)
23Branch(27)
B2:
24MoveLoc[16](loc8: Option<u64>)
25Call option::destroy_some<u64>(Option<u64>): u64
26StLoc[9](loc1: u64)
B3:
27MoveLoc[9](loc1: u64)
28StLoc[14](loc6: u64)
29CopyLoc[5](Arg5: u64)
30MoveLoc[14](loc6: u64)
31Call constants::fee_precision(): u64
32Call math::mul_factor(u64, u64, u64): u64
33StLoc[13](loc5: u64)
34ImmBorrowLoc[4](Arg4: Balance<Ty0>)
35Call balance::value<Ty0>(&Balance<Ty0>): u64
36Call buck_events::emit_collateral_increased<Ty0>(u64)
37MoveLoc[2](Arg2: &BottleStrap<Ty0>)
38Call strap::get_address<Ty0>(&BottleStrap<Ty0>): address
39StLoc[10](loc2: address)
40MoveLoc[11](loc3: &mut Bucket<Ty0>)
41MoveLoc[1](Arg1: &BucketOracle)
42MoveLoc[10](loc2: address)
43MoveLoc[3](Arg3: &Clock)
44MoveLoc[4](Arg4: Balance<Ty0>)
45CopyLoc[5](Arg5: u64)
46CopyLoc[13](loc5: u64)
47Add
48MoveLoc[6](Arg6: Option<address>)
49MoveLoc[15](loc7: u64)
50MoveLoc[7](Arg7: &mut TxContext)
51Call bucket::handle_borrow<Ty0>(&mut Bucket<Ty0>, &BucketOracle, address, &Clock, Balance<Ty0>, u64, Option<address>, u64, &mut TxContext)
52CopyLoc[13](loc5: u64)
53LdU64(0)
54Gt
55BrFalse(67)
B4:
56CopyLoc[0](Arg0: &mut BucketProtocol)
57MoveLoc[13](loc5: u64)
58Call mint_buck<Ty0>(&mut BucketProtocol, u64): Balance<BUCK>
59StLoc[12](loc4: Balance<BUCK>)
60ImmBorrowLoc[12](loc4: Balance<BUCK>)
61LdConst[23](vector<u8>: "bor..)
62Call well_events::emit_collect_fee_from<BUCK>(&Balance<BUCK>, vector<u8>)
63CopyLoc[0](Arg0: &mut BucketProtocol)
64Call borrow_well_mut<BUCK>(&mut BucketProtocol): &mut Well<BUCK>
65MoveLoc[12](loc4: Balance<BUCK>)
66Call well::collect_fee<BUCK>(&mut Well<BUCK>, Balance<BUCK>)
B5:
67MoveLoc[0](Arg0: &mut BucketProtocol)
68MoveLoc[5](Arg5: u64)
69Call mint_buck<Ty0>(&mut BucketProtocol, u64): Balance<BUCK>
70Ret
}
public withdraw_with_strap<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BucketOracle, Arg2: &BottleStrap<Ty0>, Arg3: &Clock, Arg4: u64, Arg5: Option<address>): Balance<Ty0> {
L6: loc0: &mut Bucket<Ty0>
L7: loc1: address
B0:
0MoveLoc[0](Arg0: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2StLoc[6](loc0: &mut Bucket<Ty0>)
3CopyLoc[6](loc0: &mut Bucket<Ty0>)
4FreezeRef
5Call bucket::is_not_locked<Ty0>(&Bucket<Ty0>): bool
6BrFalse(8)
B1:
7Branch(18)
B2:
8MoveLoc[2](Arg2: &BottleStrap<Ty0>)
9Pop
10MoveLoc[1](Arg1: &BucketOracle)
11Pop
12MoveLoc[3](Arg3: &Clock)
13Pop
14MoveLoc[6](loc0: &mut Bucket<Ty0>)
15Pop
16LdConst[12](u64: 14)
17Abort
B3:
18CopyLoc[4](Arg4: u64)
19Call buck_events::emit_collateral_decreased<Ty0>(u64)
20MoveLoc[2](Arg2: &BottleStrap<Ty0>)
21Call strap::get_address<Ty0>(&BottleStrap<Ty0>): address
22StLoc[7](loc1: address)
23MoveLoc[6](loc0: &mut Bucket<Ty0>)
24MoveLoc[1](Arg1: &BucketOracle)
25MoveLoc[7](loc1: address)
26MoveLoc[3](Arg3: &Clock)
27MoveLoc[4](Arg4: u64)
28MoveLoc[5](Arg5: Option<address>)
29Call bucket::handle_withdraw<Ty0>(&mut Bucket<Ty0>, &BucketOracle, address, &Clock, u64, Option<address>): Balance<Ty0>
30Ret
}
public repay_with_strap<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BottleStrap<Ty0>, Arg2: Balance<BUCK>, Arg3: &Clock): Balance<Ty0> {
L4: loc0: u64
L5: loc1: &mut Bucket<Ty0>
L6: loc2: Balance<Ty0>
L7: loc3: address
L8: loc4: u64
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3CopyLoc[0](Arg0: &mut BucketProtocol)
4ImmBorrowField[0](BucketProtocol.min_bottle_size: u64)
5ReadRef
6StLoc[8](loc4: u64)
7MoveLoc[1](Arg1: &BottleStrap<Ty0>)
8Call strap::get_address<Ty0>(&BottleStrap<Ty0>): address
9StLoc[7](loc3: address)
10ImmBorrowLoc[2](Arg2: Balance<BUCK>)
11Call balance::value<BUCK>(&Balance<BUCK>): u64
12StLoc[4](loc0: u64)
13CopyLoc[0](Arg0: &mut BucketProtocol)
14MoveLoc[2](Arg2: Balance<BUCK>)
15Call burn_buck<Ty0>(&mut BucketProtocol, Balance<BUCK>)
16MoveLoc[0](Arg0: &mut BucketProtocol)
17Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
18StLoc[5](loc1: &mut Bucket<Ty0>)
19CopyLoc[5](loc1: &mut Bucket<Ty0>)
20FreezeRef
21Call bucket::is_not_locked<Ty0>(&Bucket<Ty0>): bool
22BrFalse(24)
B1:
23Branch(30)
B2:
24MoveLoc[3](Arg3: &Clock)
25Pop
26MoveLoc[5](loc1: &mut Bucket<Ty0>)
27Pop
28LdConst[12](u64: 14)
29Abort
B3:
30MoveLoc[5](loc1: &mut Bucket<Ty0>)
31MoveLoc[7](loc3: address)
32MoveLoc[4](loc0: u64)
33MoveLoc[8](loc4: u64)
34LdTrue
35MoveLoc[3](Arg3: &Clock)
36Call bucket::handle_repay<Ty0>(&mut Bucket<Ty0>, address, u64, u64, bool, &Clock): Balance<Ty0>
37StLoc[6](loc2: Balance<Ty0>)
38ImmBorrowLoc[6](loc2: Balance<Ty0>)
39Call balance::value<Ty0>(&Balance<Ty0>): u64
40Call buck_events::emit_collateral_decreased<Ty0>(u64)
41MoveLoc[6](loc2: Balance<Ty0>)
42Ret
}
public withdraw_surplus_with_strap<Ty0>(Arg0: &mut BucketProtocol, Arg1: &BottleStrap<Ty0>): Balance<Ty0> {
L2: loc0: &mut Bucket<Ty0>
L3: loc1: address
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3MoveLoc[0](Arg0: &mut BucketProtocol)
4Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
5StLoc[2](loc0: &mut Bucket<Ty0>)
6MoveLoc[1](Arg1: &BottleStrap<Ty0>)
7Call strap::get_address<Ty0>(&BottleStrap<Ty0>): address
8StLoc[3](loc1: address)
9MoveLoc[2](loc0: &mut Bucket<Ty0>)
10MoveLoc[3](loc1: address)
11Call bucket::withdraw_surplus_collateral<Ty0>(&mut Bucket<Ty0>, address): Balance<Ty0>
12Ret
}
public new_strap_with_fee_rate_to<Ty0>(Arg0: &AdminCap, Arg1: u64, Arg2: address, Arg3: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: u64)
1MoveLoc[3](Arg3: &mut TxContext)
2Call strap::new_with_fee_rate<Ty0>(u64, &mut TxContext): BottleStrap<Ty0>
3MoveLoc[2](Arg2: address)
4Call transfer::public_transfer<BottleStrap<Ty0>>(BottleStrap<Ty0>, address)
5Ret
}
public update_liquidation_config<Ty0>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: &BucketOracle, Arg3: &Clock, Arg4: u64, Arg5: u64) {
L6: loc0: &BucketOracle
L7: loc1: &Clock
L8: loc2: &mut Bucket<Ty0>
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2StLoc[8](loc2: &mut Bucket<Ty0>)
3CopyLoc[8](loc2: &mut Bucket<Ty0>)
4CopyLoc[4](Arg4: u64)
5CopyLoc[5](Arg5: u64)
6Call bucket::update_liquidation_config<Ty0>(&mut Bucket<Ty0>, u64, u64)
7MoveLoc[8](loc2: &mut Bucket<Ty0>)
8MoveLoc[2](Arg2: &BucketOracle)
9MoveLoc[3](Arg3: &Clock)
10StLoc[7](loc1: &Clock)
11StLoc[6](loc0: &BucketOracle)
12FreezeRef
13MoveLoc[6](loc0: &BucketOracle)
14MoveLoc[7](loc1: &Clock)
15Call bucket::has_liquidatable_bottle<Ty0>(&Bucket<Ty0>, &BucketOracle, &Clock): bool
16Not
17BrFalse(19)
B1:
18Branch(21)
B2:
19LdConst[16](u64: 18)
20Abort
B3:
21LdConst[39](vector<u8>: "min..)
22MoveLoc[4](Arg4: u64)
23Call buck_events::emit_param_updated<Ty0>(vector<u8>, u64)
24LdConst[40](vector<u8>: "rec..)
25MoveLoc[5](Arg5: u64)
26Call buck_events::emit_param_updated<Ty0>(vector<u8>, u64)
27Ret
}
public package_version(): u64 {
B0:
0LdConst[0](u64: 7)
1Ret
}
public add_test_version(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: u64, Arg3: &mut TxContext) {
B0:
0MoveLoc[1](Arg1: &mut BucketProtocol)
1MutBorrowField[1](BucketProtocol.id: UID)
2LdConst[41](vector<u8>: "tes..)
3MoveLoc[3](Arg3: &mut TxContext)
4Call object::new(&mut TxContext): UID
5MoveLoc[2](Arg2: u64)
6Pack[13](TestVersion)
7Call dynamic_object_field::add<vector<u8>, TestVersion>(&mut UID, vector<u8>, TestVersion)
8Ret
}
public remove_test_version(Arg0: &AdminCap, Arg1: &mut BucketProtocol) {
L2: loc0: u64
B0:
0CopyLoc[1](Arg1: &mut BucketProtocol)
1MutBorrowField[1](BucketProtocol.id: UID)
2LdConst[41](vector<u8>: "tes..)
3Call dynamic_object_field::remove<vector<u8>, TestVersion>(&mut UID, vector<u8>): TestVersion
4Unpack[13](TestVersion)
5StLoc[2](loc0: u64)
6Call object::delete(UID)
7MoveLoc[2](loc0: u64)
8MoveLoc[1](Arg1: &mut BucketProtocol)
9MutBorrowField[2](BucketProtocol.version: u64)
10WriteRef
11Ret
}
assert_valid_package_version(Arg0: &BucketProtocol) {
L1: loc0: bool
L2: loc1: vector<u8>
L3: loc2: u64
L4: loc3: &TestVersion
B0:
0Call package_version(): u64
1StLoc[3](loc2: u64)
2LdConst[41](vector<u8>: "tes..)
3StLoc[2](loc1: vector<u8>)
4CopyLoc[0](Arg0: &BucketProtocol)
5ImmBorrowField[1](BucketProtocol.id: UID)
6CopyLoc[2](loc1: vector<u8>)
7Call dynamic_object_field::exists_with_type<vector<u8>, TestVersion>(&UID, vector<u8>): bool
8BrFalse(37)
B1:
9CopyLoc[0](Arg0: &BucketProtocol)
10ImmBorrowField[1](BucketProtocol.id: UID)
11MoveLoc[2](loc1: vector<u8>)
12Call dynamic_object_field::borrow<vector<u8>, TestVersion>(&UID, vector<u8>): &TestVersion
13StLoc[4](loc3: &TestVersion)
14CopyLoc[3](loc2: u64)
15MoveLoc[0](Arg0: &BucketProtocol)
16ImmBorrowField[2](BucketProtocol.version: u64)
17ReadRef
18Eq
19BrFalse(25)
B2:
20MoveLoc[4](loc3: &TestVersion)
21Pop
22LdTrue
23StLoc[1](loc0: bool)
24Branch(31)
B3:
25MoveLoc[3](loc2: u64)
26MoveLoc[4](loc3: &TestVersion)
27ImmBorrowField[9](TestVersion.version: u64)
28ReadRef
29Eq
30StLoc[1](loc0: bool)
B4:
31MoveLoc[1](loc0: bool)
32BrFalse(34)
B5:
33Branch(36)
B6:
34LdConst[17](u64: 99)
35Abort
B7:
36Branch(46)
B8:
37MoveLoc[3](loc2: u64)
38MoveLoc[0](Arg0: &BucketProtocol)
39ImmBorrowField[2](BucketProtocol.version: u64)
40ReadRef
41Eq
42BrFalse(44)
B9:
43Branch(46)
B10:
44LdConst[17](u64: 99)
45Abort
B11:
46Ret
}
public create_pipe<Ty0, Ty1: drop>(Arg0: &AdminCap, Arg1: &mut BucketProtocol, Arg2: &mut TxContext) {
L3: loc0: Pipe<Ty0, Ty1>
L4: loc1: PipeType<Ty0, Ty1>
B0:
0Call pipe::new_type<Ty0, Ty1>(): PipeType<Ty0, Ty1>
1StLoc[4](loc1: PipeType<Ty0, Ty1>)
2MoveLoc[2](Arg2: &mut TxContext)
3Call pipe::new_pipe<Ty0, Ty1>(&mut TxContext): Pipe<Ty0, Ty1>
4StLoc[3](loc0: Pipe<Ty0, Ty1>)
5MoveLoc[1](Arg1: &mut BucketProtocol)
6MutBorrowField[1](BucketProtocol.id: UID)
7MoveLoc[4](loc1: PipeType<Ty0, Ty1>)
8MoveLoc[3](loc0: Pipe<Ty0, Ty1>)
9Call dynamic_object_field::add<PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>>(&mut UID, PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>)
10Ret
}
public destroy_pipe<Ty0, Ty1: drop>(Arg0: &AdminCap, Arg1: &mut BucketProtocol) {
L2: loc0: PipeType<Ty0, Ty1>
L3: loc1: PipeType<Ty0, Ty1>
B0:
0Call is_buck<Ty0>(): bool
1BrFalse(10)
B1:
2Call pipe::new_type<Ty0, Ty1>(): PipeType<Ty0, Ty1>
3StLoc[2](loc0: PipeType<Ty0, Ty1>)
4MoveLoc[1](Arg1: &mut BucketProtocol)
5MutBorrowField[1](BucketProtocol.id: UID)
6MoveLoc[2](loc0: PipeType<Ty0, Ty1>)
7Call dynamic_object_field::remove<PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>>(&mut UID, PipeType<Ty0, Ty1>): Pipe<Ty0, Ty1>
8Call pipe::destroy_buck_pipe<Ty0, Ty1>(Pipe<Ty0, Ty1>)
9Branch(17)
B2:
10Call pipe::new_type<Ty0, Ty1>(): PipeType<Ty0, Ty1>
11StLoc[3](loc1: PipeType<Ty0, Ty1>)
12MoveLoc[1](Arg1: &mut BucketProtocol)
13MutBorrowField[1](BucketProtocol.id: UID)
14MoveLoc[3](loc1: PipeType<Ty0, Ty1>)
15Call dynamic_object_field::remove<PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>>(&mut UID, PipeType<Ty0, Ty1>): Pipe<Ty0, Ty1>
16Call pipe::destroy_pipe<Ty0, Ty1>(Pipe<Ty0, Ty1>)
B3:
17Ret
}
public borrow_pipe<Ty0, Ty1: drop>(Arg0: &BucketProtocol): &Pipe<Ty0, Ty1> {
L1: loc0: PipeType<Ty0, Ty1>
B0:
0CopyLoc[0](Arg0: &BucketProtocol)
1Call assert_valid_package_version(&BucketProtocol)
2Call pipe::new_type<Ty0, Ty1>(): PipeType<Ty0, Ty1>
3StLoc[1](loc0: PipeType<Ty0, Ty1>)
4CopyLoc[0](Arg0: &BucketProtocol)
5ImmBorrowField[1](BucketProtocol.id: UID)
6CopyLoc[1](loc0: PipeType<Ty0, Ty1>)
7Call dynamic_object_field::exists_with_type<PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>>(&UID, PipeType<Ty0, Ty1>): bool
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[0](Arg0: &BucketProtocol)
11Pop
12LdConst[4](u64: 5)
13Abort
B3:
14MoveLoc[0](Arg0: &BucketProtocol)
15ImmBorrowField[1](BucketProtocol.id: UID)
16MoveLoc[1](loc0: PipeType<Ty0, Ty1>)
17Call dynamic_object_field::borrow<PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>>(&UID, PipeType<Ty0, Ty1>): &Pipe<Ty0, Ty1>
18Ret
}
borrow_pipe_mut<Ty0, Ty1: drop>(Arg0: &mut BucketProtocol): &mut Pipe<Ty0, Ty1> {
L1: loc0: PipeType<Ty0, Ty1>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1FreezeRef
2Call assert_valid_package_version(&BucketProtocol)
3Call pipe::new_type<Ty0, Ty1>(): PipeType<Ty0, Ty1>
4StLoc[1](loc0: PipeType<Ty0, Ty1>)
5CopyLoc[0](Arg0: &mut BucketProtocol)
6ImmBorrowField[1](BucketProtocol.id: UID)
7CopyLoc[1](loc0: PipeType<Ty0, Ty1>)
8Call dynamic_object_field::exists_with_type<PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>>(&UID, PipeType<Ty0, Ty1>): bool
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[0](Arg0: &mut BucketProtocol)
12Pop
13LdConst[4](u64: 5)
14Abort
B3:
15MoveLoc[0](Arg0: &mut BucketProtocol)
16MutBorrowField[1](BucketProtocol.id: UID)
17MoveLoc[1](loc0: PipeType<Ty0, Ty1>)
18Call dynamic_object_field::borrow_mut<PipeType<Ty0, Ty1>, Pipe<Ty0, Ty1>>(&mut UID, PipeType<Ty0, Ty1>): &mut Pipe<Ty0, Ty1>
19Ret
}
public output<Ty0, Ty1: drop>(Arg0: &mut BucketProtocol, Arg1: u64): OutputCarrier<Ty0, Ty1> {
L2: loc0: Balance<Ty0>
B0:
0Call is_buck<Ty0>(): bool
1Not
2BrFalse(4)
B1:
3Branch(8)
B2:
4MoveLoc[0](Arg0: &mut BucketProtocol)
5Pop
6LdConst[15](u64: 17)
7Abort
B3:
8CopyLoc[0](Arg0: &mut BucketProtocol)
9Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
10MoveLoc[1](Arg1: u64)
11Call bucket::output<Ty0>(&mut Bucket<Ty0>, u64): Balance<Ty0>
12StLoc[2](loc0: Balance<Ty0>)
13MoveLoc[0](Arg0: &mut BucketProtocol)
14Call borrow_pipe_mut<Ty0, Ty1>(&mut BucketProtocol): &mut Pipe<Ty0, Ty1>
15MoveLoc[2](loc0: Balance<Ty0>)
16Call pipe::output<Ty0, Ty1>(&mut Pipe<Ty0, Ty1>, Balance<Ty0>): OutputCarrier<Ty0, Ty1>
17Ret
}
public input<Ty0, Ty1: drop>(Arg0: &mut BucketProtocol, Arg1: InputCarrier<Ty0, Ty1>) {
L2: loc0: Balance<Ty0>
B0:
0Call is_buck<Ty0>(): bool
1Not
2BrFalse(4)
B1:
3Branch(8)
B2:
4MoveLoc[0](Arg0: &mut BucketProtocol)
5Pop
6LdConst[15](u64: 17)
7Abort
B3:
8CopyLoc[0](Arg0: &mut BucketProtocol)
9Call borrow_pipe_mut<Ty0, Ty1>(&mut BucketProtocol): &mut Pipe<Ty0, Ty1>
10MoveLoc[1](Arg1: InputCarrier<Ty0, Ty1>)
11Call pipe::destroy_input_carrier<Ty0, Ty1>(&mut Pipe<Ty0, Ty1>, InputCarrier<Ty0, Ty1>): Balance<Ty0>
12StLoc[2](loc0: Balance<Ty0>)
13MoveLoc[0](Arg0: &mut BucketProtocol)
14Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
15MoveLoc[2](loc0: Balance<Ty0>)
16Call bucket::input<Ty0>(&mut Bucket<Ty0>, Balance<Ty0>)
17Ret
}
public output_buck<Ty0: drop>(Arg0: &mut BucketProtocol, Arg1: u64): OutputCarrier<BUCK, Ty0> {
L2: loc0: Balance<BUCK>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1MoveLoc[1](Arg1: u64)
2Call mint_buck<Ty0>(&mut BucketProtocol, u64): Balance<BUCK>
3StLoc[2](loc0: Balance<BUCK>)
4MoveLoc[0](Arg0: &mut BucketProtocol)
5Call borrow_pipe_mut<BUCK, Ty0>(&mut BucketProtocol): &mut Pipe<BUCK, Ty0>
6MoveLoc[2](loc0: Balance<BUCK>)
7Call pipe::output<BUCK, Ty0>(&mut Pipe<BUCK, Ty0>, Balance<BUCK>): OutputCarrier<BUCK, Ty0>
8Ret
}
public input_buck<Ty0: drop>(Arg0: &mut BucketProtocol, Arg1: InputCarrier<BUCK, Ty0>) {
L2: loc0: Balance<BUCK>
B0:
0CopyLoc[0](Arg0: &mut BucketProtocol)
1Call borrow_pipe_mut<BUCK, Ty0>(&mut BucketProtocol): &mut Pipe<BUCK, Ty0>
2MoveLoc[1](Arg1: InputCarrier<BUCK, Ty0>)
3Call pipe::destroy_input_carrier<BUCK, Ty0>(&mut Pipe<BUCK, Ty0>, InputCarrier<BUCK, Ty0>): Balance<BUCK>
4StLoc[2](loc0: Balance<BUCK>)
5MoveLoc[0](Arg0: &mut BucketProtocol)
6MoveLoc[2](loc0: Balance<BUCK>)
7Call burn_buck<Ty0>(&mut BucketProtocol, Balance<BUCK>)
8Ret
}
public is_buck<Ty0>(): bool {
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1Call type_name::with_defining_ids<BUCK>(): TypeName
2Eq
3Ret
}
public deposit_surplus_with_strap<Ty0>(Arg0: &mut BucketProtocol, Arg1: Balance<Ty0>, Arg2: &BottleStrap<Ty0>, Arg3: &mut TxContext) {
L4: loc0: u64
L5: loc1: address
B0:
0ImmBorrowLoc[1](Arg1: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2StLoc[4](loc0: u64)
3MoveLoc[2](Arg2: &BottleStrap<Ty0>)
4Call strap::get_address<Ty0>(&BottleStrap<Ty0>): address
5StLoc[5](loc1: address)
6MoveLoc[0](Arg0: &mut BucketProtocol)
7Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
8MoveLoc[5](loc1: address)
9MoveLoc[1](Arg1: Balance<Ty0>)
10MoveLoc[3](Arg3: &mut TxContext)
11Call bucket::handle_deposit_surplus<Ty0>(&mut Bucket<Ty0>, address, Balance<Ty0>, &mut TxContext)
12MoveLoc[4](loc0: u64)
13Call buck_events::emit_collateral_increased<Ty0>(u64)
14Ret
}
public transfer_bottle<Ty0>(Arg0: &mut BucketProtocol, Arg1: &Clock, Arg2: address, Arg3: &TxContext) {
L4: loc0: &mut Bucket<Ty0>
L5: loc1: address
B0:
0MoveLoc[0](Arg0: &mut BucketProtocol)
1Call borrow_bucket_mut<Ty0>(&mut BucketProtocol): &mut Bucket<Ty0>
2StLoc[4](loc0: &mut Bucket<Ty0>)
3MoveLoc[3](Arg3: &TxContext)
4Call tx_context::sender(&TxContext): address
5StLoc[5](loc1: address)
6MoveLoc[4](loc0: &mut Bucket<Ty0>)
7MoveLoc[5](loc1: address)
8MoveLoc[2](Arg2: address)
9MoveLoc[1](Arg1: &Clock)
10Call bucket::handle_transfer<Ty0>(&mut Bucket<Ty0>, address, address, &Clock)
11Ret
}
Constants [
0 => u64: 7
1 => u64: 1
2 => u64: 2
3 => u64: 4
4 => u64: 5
5 => u64: 6
6 => u64: 8
7 => u64: 9
8 => u64: 10
9 => u64: 11
10 => u64: 12
11 => u64: 13
12 => u64: 14
13 => u64: 15
14 => u64: 16
15 => u64: 17
16 => u64: 18
17 => u64: 99
18 => u64: 404
19 => vector<u8>: "BUCK" // interpreted as UTF8 string
20 => vector<u8>: "Bucket USD" // interpreted as UTF8 string
21 => vector<u8>: "the stablecoin minted through bucketprotocol.io" // interpreted as UTF8 string
22 => vector<u8>: "https://ipfs.io/ipfs/QmYH4seo7K9CiFqHGDmhbZmzewHEapAhN9aqLRA7af2vMW" // interpreted as UTF8 string
23 => vector<u8>: "borrow" // interpreted as UTF8 string
24 => vector<u8>: "redeem" // interpreted as UTF8 string
25 => vector<u8>: "liquidate" // interpreted as UTF8 string
26 => vector<u8>: "flashloan" // interpreted as UTF8 string
27 => vector<u8>: "max_mint_amount" // interpreted as UTF8 string
28 => vector<u8>: "min_bottle_size" // interpreted as UTF8 string
29 => vector<u8>: "version" // interpreted as UTF8 string
30 => vector<u8>: "fee_rate" // interpreted as UTF8 string
31 => vector<u8>: "max_amount" // interpreted as UTF8 string
32 => vector<u8>: "flashmint" // interpreted as UTF8 string
33 => vector<u8>: "charge_fee_rate" // interpreted as UTF8 string
34 => vector<u8>: "discharge_fee_rate" // interpreted as UTF8 string
35 => vector<u8>: "charge" // interpreted as UTF8 string
36 => vector<u8>: "discharge" // interpreted as UTF8 string
37 => vector<u8>: "interest" // interpreted as UTF8 string
38 => vector<u8>: "interest_rate" // interpreted as UTF8 string
39 => vector<u8>: "min_collateral_ratio" // interpreted as UTF8 string
40 => vector<u8>: "recovery_mode_threshold" // interpreted as UTF8 string
41 => vector<u8>: "test_version" // interpreted as UTF8 string
]
}