balance_manager
Module0xcaf6…ec3a
- Move path
- 0x2c8d…4809::balance_manager
- Functions
- 2817 public, 0 entry
- Structs
- 8
balance_manager
Bytecode1068 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809.balance_manager {
use 2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::registry;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::bag;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct BalanceManager has store, key {
id: UID,
owner: address,
balances: Bag,
allow_listed: VecSet<ID>
}
struct BalanceManagerEvent has copy, drop {
balance_manager_id: ID,
owner: address
}
struct BalanceEvent has copy, drop {
balance_manager_id: ID,
asset: TypeName,
amount: u64,
deposit: bool
}
struct BalanceKey<phantom Ty0> has copy, drop, store {
dummy_field: bool
}
struct ReferralKey has copy, drop, store {
pos0: ID
}
struct TradeCap has store, key {
id: UID,
balance_manager_id: ID
}
struct DepositCap has store, key {
id: UID,
balance_manager_id: ID
}
struct WithdrawCap has store, key {
id: UID,
balance_manager_id: ID
}
struct DeepBookReferral has store, key {
id: UID,
owner: address
}
struct DeepBookPoolReferral has store, key {
id: UID,
owner: address,
pool_id: ID
}
struct DeepBookReferralCreatedEvent has copy, drop {
referral_id: ID,
owner: address
}
struct DeepBookReferralSetEvent has copy, drop {
referral_id: ID,
balance_manager_id: ID
}
struct TradeProof has drop {
balance_manager_id: ID,
trader: address
}
public new(Arg0: &mut TxContext): BalanceManager {
L1: loc0: UID
B0:
0CopyLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[1](loc0: UID)
3ImmBorrowLoc[1](loc0: UID)
4Call object::uid_to_inner(&UID): ID
5CopyLoc[0](Arg0: &mut TxContext)
6FreezeRef
7Call tx_context::sender(&TxContext): address
8Pack[1](BalanceManagerEvent)
9Call event::emit<BalanceManagerEvent>(BalanceManagerEvent)
10MoveLoc[1](loc0: UID)
11CopyLoc[0](Arg0: &mut TxContext)
12FreezeRef
13Call tx_context::sender(&TxContext): address
14MoveLoc[0](Arg0: &mut TxContext)
15Call bag::new(&mut TxContext): Bag
16Call vec_set::empty<ID>(): VecSet<ID>
17Pack[0](BalanceManager)
18Ret
}
public new_with_owner(Arg0: &mut TxContext, Arg1: address): BalanceManager {
B0:
0LdU64(1337)
1Abort
}
public new_with_custom_owner(Arg0: address, Arg1: &mut TxContext): BalanceManager {
L2: loc0: UID
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[2](loc0: UID)
3ImmBorrowLoc[2](loc0: UID)
4Call object::uid_to_inner(&UID): ID
5CopyLoc[0](Arg0: address)
6Pack[1](BalanceManagerEvent)
7Call event::emit<BalanceManagerEvent>(BalanceManagerEvent)
8MoveLoc[2](loc0: UID)
9MoveLoc[0](Arg0: address)
10MoveLoc[1](Arg1: &mut TxContext)
11Call bag::new(&mut TxContext): Bag
12Call vec_set::empty<ID>(): VecSet<ID>
13Pack[0](BalanceManager)
14Ret
}
public new_with_custom_owner_and_caps(Arg0: address, Arg1: &mut TxContext): BalanceManager * DepositCap * WithdrawCap * TradeCap {
B0:
0LdU64(1337)
1Abort
}
public new_with_custom_owner_caps<Ty0: drop>(Arg0: &Registry, Arg1: address, Arg2: &mut TxContext): BalanceManager * DepositCap * WithdrawCap * TradeCap {
B0:
0LdU64(1337)
1Abort
}
public new_with_custom_owner_caps_v2<Ty0: drop>(Arg0: Ty0, Arg1: &Registry, Arg2: address, Arg3: &mut TxContext): BalanceManager * DepositCap * WithdrawCap * TradeCap {
L4: loc0: BalanceManager
L5: loc1: DepositCap
L6: loc2: TradeCap
L7: loc3: WithdrawCap
B0:
0MoveLoc[1](Arg1: &Registry)
1Call registry::assert_app_is_authorized<Ty0>(&Registry)
2MoveLoc[2](Arg2: address)
3CopyLoc[3](Arg3: &mut TxContext)
4Call new_with_custom_owner(address, &mut TxContext): BalanceManager
5StLoc[4](loc0: BalanceManager)
6MutBorrowLoc[4](loc0: BalanceManager)
7CopyLoc[3](Arg3: &mut TxContext)
8Call mint_deposit_cap_internal(&mut BalanceManager, &mut TxContext): DepositCap
9StLoc[5](loc1: DepositCap)
10MutBorrowLoc[4](loc0: BalanceManager)
11CopyLoc[3](Arg3: &mut TxContext)
12Call mint_withdraw_cap_internal(&mut BalanceManager, &mut TxContext): WithdrawCap
13StLoc[7](loc3: WithdrawCap)
14MutBorrowLoc[4](loc0: BalanceManager)
15MoveLoc[3](Arg3: &mut TxContext)
16Call mint_trade_cap_internal(&mut BalanceManager, &mut TxContext): TradeCap
17StLoc[6](loc2: TradeCap)
18MoveLoc[4](loc0: BalanceManager)
19MoveLoc[5](loc1: DepositCap)
20MoveLoc[7](loc3: WithdrawCap)
21MoveLoc[6](loc2: TradeCap)
22Ret
}
public set_referral(Arg0: &mut BalanceManager, Arg1: &DeepBookReferral, Arg2: &TradeCap) {
B0:
0LdU64(13906835003272069119)
1Abort
}
public set_balance_manager_referral(Arg0: &mut BalanceManager, Arg1: &DeepBookPoolReferral, Arg2: &TradeCap) {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2MoveLoc[2](Arg2: &TradeCap)
3Call validate_trader(&BalanceManager, &TradeCap)
4CopyLoc[0](Arg0: &mut BalanceManager)
5MutBorrowField[0](BalanceManager.id: UID)
6CopyLoc[1](Arg1: &DeepBookPoolReferral)
7ImmBorrowField[1](DeepBookPoolReferral.pool_id: ID)
8ReadRef
9Pack[4](ReferralKey)
10Call dynamic_field::remove_opt<ReferralKey, ID>(&mut UID, ReferralKey): Option<ID>
11Pop
12CopyLoc[0](Arg0: &mut BalanceManager)
13MutBorrowField[0](BalanceManager.id: UID)
14CopyLoc[1](Arg1: &DeepBookPoolReferral)
15ImmBorrowField[1](DeepBookPoolReferral.pool_id: ID)
16ReadRef
17Pack[4](ReferralKey)
18CopyLoc[1](Arg1: &DeepBookPoolReferral)
19ImmBorrowField[2](DeepBookPoolReferral.id: UID)
20Call object::uid_to_inner(&UID): ID
21Call dynamic_field::add<ReferralKey, ID>(&mut UID, ReferralKey, ID)
22MoveLoc[1](Arg1: &DeepBookPoolReferral)
23ImmBorrowField[2](DeepBookPoolReferral.id: UID)
24Call object::uid_to_inner(&UID): ID
25MoveLoc[0](Arg0: &mut BalanceManager)
26ImmBorrowField[0](BalanceManager.id: UID)
27Call object::uid_to_inner(&UID): ID
28Pack[11](DeepBookReferralSetEvent)
29Call event::emit<DeepBookReferralSetEvent>(DeepBookReferralSetEvent)
30Ret
}
public unset_referral(Arg0: &mut BalanceManager, Arg1: &TradeCap) {
B0:
0LdU64(13906835089171415039)
1Abort
}
public unset_balance_manager_referral(Arg0: &mut BalanceManager, Arg1: ID, Arg2: &TradeCap) {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2MoveLoc[2](Arg2: &TradeCap)
3Call validate_trader(&BalanceManager, &TradeCap)
4CopyLoc[0](Arg0: &mut BalanceManager)
5MutBorrowField[0](BalanceManager.id: UID)
6MoveLoc[1](Arg1: ID)
7Pack[4](ReferralKey)
8Call dynamic_field::remove_opt<ReferralKey, ID>(&mut UID, ReferralKey): Option<ID>
9Pop
10LdConst[8](address: 0x00..)
11Call object::id_from_address(address): ID
12MoveLoc[0](Arg0: &mut BalanceManager)
13ImmBorrowField[0](BalanceManager.id: UID)
14Call object::uid_to_inner(&UID): ID
15Pack[11](DeepBookReferralSetEvent)
16Call event::emit<DeepBookReferralSetEvent>(DeepBookReferralSetEvent)
17Ret
}
public balance<Ty0>(Arg0: &BalanceManager): u64 {
L1: loc0: u64
L2: loc1: BalanceKey<Ty0>
B0:
0LdFalse
1PackGeneric[0](BalanceKey<Ty0>)
2StLoc[2](loc1: BalanceKey<Ty0>)
3CopyLoc[0](Arg0: &BalanceManager)
4ImmBorrowField[3](BalanceManager.balances: Bag)
5CopyLoc[2](loc1: BalanceKey<Ty0>)
6Call bag::contains<BalanceKey<Ty0>>(&Bag, BalanceKey<Ty0>): bool
7Not
8BrFalse(14)
B1:
9MoveLoc[0](Arg0: &BalanceManager)
10Pop
11LdU64(0)
12StLoc[1](loc0: u64)
13Branch(20)
B2:
14MoveLoc[0](Arg0: &BalanceManager)
15ImmBorrowField[3](BalanceManager.balances: Bag)
16MoveLoc[2](loc1: BalanceKey<Ty0>)
17Call bag::borrow<BalanceKey<Ty0>, Balance<Ty0>>(&Bag, BalanceKey<Ty0>): &Balance<Ty0>
18Call balance::value<Ty0>(&Balance<Ty0>): u64
19StLoc[1](loc0: u64)
B3:
20MoveLoc[1](loc0: u64)
21Ret
}
public mint_trade_cap(Arg0: &mut BalanceManager, Arg1: &mut TxContext): TradeCap {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2CopyLoc[1](Arg1: &mut TxContext)
3FreezeRef
4Call validate_owner(&BalanceManager, &TxContext)
5MoveLoc[0](Arg0: &mut BalanceManager)
6MoveLoc[1](Arg1: &mut TxContext)
7Call mint_trade_cap_internal(&mut BalanceManager, &mut TxContext): TradeCap
8Ret
}
public mint_deposit_cap(Arg0: &mut BalanceManager, Arg1: &mut TxContext): DepositCap {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2CopyLoc[1](Arg1: &mut TxContext)
3FreezeRef
4Call validate_owner(&BalanceManager, &TxContext)
5MoveLoc[0](Arg0: &mut BalanceManager)
6MoveLoc[1](Arg1: &mut TxContext)
7Call mint_deposit_cap_internal(&mut BalanceManager, &mut TxContext): DepositCap
8Ret
}
public mint_withdraw_cap(Arg0: &mut BalanceManager, Arg1: &mut TxContext): WithdrawCap {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2CopyLoc[1](Arg1: &mut TxContext)
3FreezeRef
4Call validate_owner(&BalanceManager, &TxContext)
5MoveLoc[0](Arg0: &mut BalanceManager)
6MoveLoc[1](Arg1: &mut TxContext)
7Call mint_withdraw_cap_internal(&mut BalanceManager, &mut TxContext): WithdrawCap
8Ret
}
public revoke_trade_cap(Arg0: &mut BalanceManager, Arg1: &ID, Arg2: &TxContext) {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2MoveLoc[2](Arg2: &TxContext)
3Call validate_owner(&BalanceManager, &TxContext)
4CopyLoc[0](Arg0: &mut BalanceManager)
5ImmBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
6CopyLoc[1](Arg1: &ID)
7Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
8BrFalse(10)
B1:
9Branch(16)
B2:
10MoveLoc[1](Arg1: &ID)
11Pop
12MoveLoc[0](Arg0: &mut BalanceManager)
13Pop
14LdConst[5](u64: 5)
15Abort
B3:
16MoveLoc[0](Arg0: &mut BalanceManager)
17MutBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
18MoveLoc[1](Arg1: &ID)
19Call vec_set::remove<ID>(&mut VecSet<ID>, &ID)
20Ret
}
public generate_proof_as_owner(Arg0: &mut BalanceManager, Arg1: &TxContext): TradeProof {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2CopyLoc[1](Arg1: &TxContext)
3Call validate_owner(&BalanceManager, &TxContext)
4MoveLoc[0](Arg0: &mut BalanceManager)
5FreezeRef
6Call object::id<BalanceManager>(&BalanceManager): ID
7MoveLoc[1](Arg1: &TxContext)
8Call tx_context::sender(&TxContext): address
9Pack[12](TradeProof)
10Ret
}
public generate_proof_as_trader(Arg0: &mut BalanceManager, Arg1: &TradeCap, Arg2: &TxContext): TradeProof {
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2MoveLoc[1](Arg1: &TradeCap)
3Call validate_trader(&BalanceManager, &TradeCap)
4MoveLoc[0](Arg0: &mut BalanceManager)
5FreezeRef
6Call object::id<BalanceManager>(&BalanceManager): ID
7MoveLoc[2](Arg2: &TxContext)
8Call tx_context::sender(&TxContext): address
9Pack[12](TradeProof)
10Ret
}
public deposit<Ty0>(Arg0: &mut BalanceManager, Arg1: Coin<Ty0>, Arg2: &mut TxContext) {
L3: loc0: TradeProof
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2Call type_name::with_defining_ids<Ty0>(): TypeName
3ImmBorrowLoc[1](Arg1: Coin<Ty0>)
4Call coin::value<Ty0>(&Coin<Ty0>): u64
5LdTrue
6Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
7CopyLoc[0](Arg0: &mut BalanceManager)
8MoveLoc[2](Arg2: &mut TxContext)
9FreezeRef
10Call generate_proof_as_owner(&mut BalanceManager, &TxContext): TradeProof
11StLoc[3](loc0: TradeProof)
12MoveLoc[0](Arg0: &mut BalanceManager)
13ImmBorrowLoc[3](loc0: TradeProof)
14MoveLoc[1](Arg1: Coin<Ty0>)
15Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
16Call deposit_with_proof<Ty0>(&mut BalanceManager, &TradeProof, Balance<Ty0>)
17Ret
}
public deposit_with_cap<Ty0>(Arg0: &mut BalanceManager, Arg1: &DepositCap, Arg2: Coin<Ty0>, Arg3: &TxContext) {
L4: loc0: TradeProof
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2Call type_name::with_defining_ids<Ty0>(): TypeName
3ImmBorrowLoc[2](Arg2: Coin<Ty0>)
4Call coin::value<Ty0>(&Coin<Ty0>): u64
5LdTrue
6Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
7CopyLoc[0](Arg0: &mut BalanceManager)
8FreezeRef
9MoveLoc[1](Arg1: &DepositCap)
10MoveLoc[3](Arg3: &TxContext)
11Call generate_proof_as_depositor(&BalanceManager, &DepositCap, &TxContext): TradeProof
12StLoc[4](loc0: TradeProof)
13MoveLoc[0](Arg0: &mut BalanceManager)
14ImmBorrowLoc[4](loc0: TradeProof)
15MoveLoc[2](Arg2: Coin<Ty0>)
16Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
17Call deposit_with_proof<Ty0>(&mut BalanceManager, &TradeProof, Balance<Ty0>)
18Ret
}
public withdraw_with_cap<Ty0>(Arg0: &mut BalanceManager, Arg1: &WithdrawCap, Arg2: u64, Arg3: &mut TxContext): Coin<Ty0> {
L4: loc0: Coin<Ty0>
L5: loc1: TradeProof
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2MoveLoc[1](Arg1: &WithdrawCap)
3CopyLoc[3](Arg3: &mut TxContext)
4FreezeRef
5Call generate_proof_as_withdrawer(&BalanceManager, &WithdrawCap, &TxContext): TradeProof
6StLoc[5](loc1: TradeProof)
7CopyLoc[0](Arg0: &mut BalanceManager)
8ImmBorrowLoc[5](loc1: TradeProof)
9MoveLoc[2](Arg2: u64)
10LdFalse
11Call withdraw_with_proof<Ty0>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty0>
12MoveLoc[3](Arg3: &mut TxContext)
13Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
14StLoc[4](loc0: Coin<Ty0>)
15MoveLoc[0](Arg0: &mut BalanceManager)
16FreezeRef
17Call type_name::with_defining_ids<Ty0>(): TypeName
18ImmBorrowLoc[4](loc0: Coin<Ty0>)
19Call coin::value<Ty0>(&Coin<Ty0>): u64
20LdFalse
21Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
22MoveLoc[4](loc0: Coin<Ty0>)
23Ret
}
public withdraw<Ty0>(Arg0: &mut BalanceManager, Arg1: u64, Arg2: &mut TxContext): Coin<Ty0> {
L3: loc0: Coin<Ty0>
L4: loc1: TradeProof
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1CopyLoc[2](Arg2: &mut TxContext)
2FreezeRef
3Call generate_proof_as_owner(&mut BalanceManager, &TxContext): TradeProof
4StLoc[4](loc1: TradeProof)
5CopyLoc[0](Arg0: &mut BalanceManager)
6ImmBorrowLoc[4](loc1: TradeProof)
7MoveLoc[1](Arg1: u64)
8LdFalse
9Call withdraw_with_proof<Ty0>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty0>
10MoveLoc[2](Arg2: &mut TxContext)
11Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
12StLoc[3](loc0: Coin<Ty0>)
13MoveLoc[0](Arg0: &mut BalanceManager)
14FreezeRef
15Call type_name::with_defining_ids<Ty0>(): TypeName
16ImmBorrowLoc[3](loc0: Coin<Ty0>)
17Call coin::value<Ty0>(&Coin<Ty0>): u64
18LdFalse
19Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
20MoveLoc[3](loc0: Coin<Ty0>)
21Ret
}
public withdraw_all<Ty0>(Arg0: &mut BalanceManager, Arg1: &mut TxContext): Coin<Ty0> {
L2: loc0: Coin<Ty0>
L3: loc1: TradeProof
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1CopyLoc[1](Arg1: &mut TxContext)
2FreezeRef
3Call generate_proof_as_owner(&mut BalanceManager, &TxContext): TradeProof
4StLoc[3](loc1: TradeProof)
5CopyLoc[0](Arg0: &mut BalanceManager)
6ImmBorrowLoc[3](loc1: TradeProof)
7LdU64(0)
8LdTrue
9Call withdraw_with_proof<Ty0>(&mut BalanceManager, &TradeProof, u64, bool): Balance<Ty0>
10MoveLoc[1](Arg1: &mut TxContext)
11Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
12StLoc[2](loc0: Coin<Ty0>)
13MoveLoc[0](Arg0: &mut BalanceManager)
14FreezeRef
15Call type_name::with_defining_ids<Ty0>(): TypeName
16ImmBorrowLoc[2](loc0: Coin<Ty0>)
17Call coin::value<Ty0>(&Coin<Ty0>): u64
18LdFalse
19Call emit_balance_event(&BalanceManager, TypeName, u64, bool)
20MoveLoc[2](loc0: Coin<Ty0>)
21Ret
}
public register_manager(Arg0: &BalanceManager, Arg1: &mut Registry) {
B0:
0LdU64(1337)
1Abort
}
public register_balance_manager(Arg0: &BalanceManager, Arg1: &mut Registry, Arg2: &mut TxContext) {
L3: loc0: ID
L4: loc1: address
B0:
0CopyLoc[0](Arg0: &BalanceManager)
1MoveLoc[2](Arg2: &mut TxContext)
2FreezeRef
3Call validate_owner(&BalanceManager, &TxContext)
4CopyLoc[0](Arg0: &BalanceManager)
5Call owner(&BalanceManager): address
6StLoc[4](loc1: address)
7MoveLoc[0](Arg0: &BalanceManager)
8Call id(&BalanceManager): ID
9StLoc[3](loc0: ID)
10MoveLoc[1](Arg1: &mut Registry)
11MoveLoc[4](loc1: address)
12MoveLoc[3](loc0: ID)
13Call registry::add_balance_manager(&mut Registry, address, ID)
14Ret
}
public get_referral_id(Arg0: &BalanceManager): Option<ID> {
B0:
0LdU64(13906835909510168575)
1Abort
}
public get_balance_manager_referral_id(Arg0: &BalanceManager, Arg1: ID): Option<ID> {
L2: loc0: ReferralKey
B0:
0MoveLoc[1](Arg1: ID)
1Pack[4](ReferralKey)
2StLoc[2](loc0: ReferralKey)
3CopyLoc[0](Arg0: &BalanceManager)
4ImmBorrowField[0](BalanceManager.id: UID)
5CopyLoc[2](loc0: ReferralKey)
6Call dynamic_field::exists<ReferralKey>(&UID, ReferralKey): bool
7Not
8BrFalse(13)
B1:
9MoveLoc[0](Arg0: &BalanceManager)
10Pop
11Call option::none<ID>(): Option<ID>
12Ret
B2:
13MoveLoc[0](Arg0: &BalanceManager)
14ImmBorrowField[0](BalanceManager.id: UID)
15MoveLoc[2](loc0: ReferralKey)
16Call dynamic_field::borrow<ReferralKey, ID>(&UID, ReferralKey): &ID
17ReadRef
18Call option::some<ID>(ID): Option<ID>
19Ret
}
public validate_proof(Arg0: &BalanceManager, Arg1: &TradeProof) {
B0:
0MoveLoc[0](Arg0: &BalanceManager)
1Call object::id<BalanceManager>(&BalanceManager): ID
2MoveLoc[1](Arg1: &TradeProof)
3ImmBorrowField[5](TradeProof.balance_manager_id: ID)
4ReadRef
5Eq
6BrFalse(8)
B1:
7Branch(10)
B2:
8LdConst[2](u64: 2)
9Abort
B3:
10Ret
}
public owner(Arg0: &BalanceManager): address {
B0:
0MoveLoc[0](Arg0: &BalanceManager)
1ImmBorrowField[6](BalanceManager.owner: address)
2ReadRef
3Ret
}
public id(Arg0: &BalanceManager): ID {
B0:
0MoveLoc[0](Arg0: &BalanceManager)
1ImmBorrowField[0](BalanceManager.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public referral_owner(Arg0: &DeepBookReferral): address {
B0:
0LdU64(13906836051244089343)
1Abort
}
public balance_manager_referral_owner(Arg0: &DeepBookPoolReferral): address {
B0:
0MoveLoc[0](Arg0: &DeepBookPoolReferral)
1ImmBorrowField[7](DeepBookPoolReferral.owner: address)
2ReadRef
3Ret
}
public balance_manager_referral_pool_id(Arg0: &DeepBookPoolReferral): ID {
B0:
0MoveLoc[0](Arg0: &DeepBookPoolReferral)
1ImmBorrowField[1](DeepBookPoolReferral.pool_id: ID)
2ReadRef
3Ret
}
public(friend) mint_referral(Arg0: ID, Arg1: &mut TxContext): ID {
L2: loc0: UID
L3: loc1: DeepBookPoolReferral
L4: loc2: ID
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[2](loc0: UID)
3ImmBorrowLoc[2](loc0: UID)
4Call object::uid_to_inner(&UID): ID
5StLoc[4](loc2: ID)
6MoveLoc[2](loc0: UID)
7CopyLoc[1](Arg1: &mut TxContext)
8FreezeRef
9Call tx_context::sender(&TxContext): address
10MoveLoc[0](Arg0: ID)
11Pack[9](DeepBookPoolReferral)
12StLoc[3](loc1: DeepBookPoolReferral)
13CopyLoc[4](loc2: ID)
14MoveLoc[1](Arg1: &mut TxContext)
15FreezeRef
16Call tx_context::sender(&TxContext): address
17Pack[10](DeepBookReferralCreatedEvent)
18Call event::emit<DeepBookReferralCreatedEvent>(DeepBookReferralCreatedEvent)
19MoveLoc[3](loc1: DeepBookPoolReferral)
20Call transfer::share_object<DeepBookPoolReferral>(DeepBookPoolReferral)
21MoveLoc[4](loc2: ID)
22Ret
}
public(friend) assert_referral_owner(Arg0: &DeepBookPoolReferral, Arg1: &TxContext) {
B0:
0MoveLoc[1](Arg1: &TxContext)
1Call tx_context::sender(&TxContext): address
2MoveLoc[0](Arg0: &DeepBookPoolReferral)
3ImmBorrowField[7](DeepBookPoolReferral.owner: address)
4ReadRef
5Eq
6BrFalse(8)
B1:
7Branch(10)
B2:
8LdConst[6](u64: 6)
9Abort
B3:
10Ret
}
public(friend) deposit_with_proof<Ty0>(Arg0: &mut BalanceManager, Arg1: &TradeProof, Arg2: Balance<Ty0>) {
L3: loc0: BalanceKey<Ty0>
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2MoveLoc[1](Arg1: &TradeProof)
3Call validate_proof(&BalanceManager, &TradeProof)
4LdFalse
5PackGeneric[0](BalanceKey<Ty0>)
6StLoc[3](loc0: BalanceKey<Ty0>)
7CopyLoc[0](Arg0: &mut BalanceManager)
8ImmBorrowField[3](BalanceManager.balances: Bag)
9CopyLoc[3](loc0: BalanceKey<Ty0>)
10Call bag::contains<BalanceKey<Ty0>>(&Bag, BalanceKey<Ty0>): bool
11BrFalse(20)
B1:
12MoveLoc[0](Arg0: &mut BalanceManager)
13MutBorrowField[3](BalanceManager.balances: Bag)
14MoveLoc[3](loc0: BalanceKey<Ty0>)
15Call bag::borrow_mut<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): &mut Balance<Ty0>
16MoveLoc[2](Arg2: Balance<Ty0>)
17Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
18Pop
19Branch(25)
B2:
20MoveLoc[0](Arg0: &mut BalanceManager)
21MutBorrowField[3](BalanceManager.balances: Bag)
22MoveLoc[3](loc0: BalanceKey<Ty0>)
23MoveLoc[2](Arg2: Balance<Ty0>)
24Call bag::add<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>, Balance<Ty0>)
B3:
25Ret
}
public(friend) deposit_permissionless<Ty0>(Arg0: &mut BalanceManager, Arg1: Balance<Ty0>) {
L2: loc0: BalanceKey<Ty0>
B0:
0LdFalse
1PackGeneric[0](BalanceKey<Ty0>)
2StLoc[2](loc0: BalanceKey<Ty0>)
3CopyLoc[0](Arg0: &mut BalanceManager)
4ImmBorrowField[3](BalanceManager.balances: Bag)
5CopyLoc[2](loc0: BalanceKey<Ty0>)
6Call bag::contains<BalanceKey<Ty0>>(&Bag, BalanceKey<Ty0>): bool
7BrFalse(16)
B1:
8MoveLoc[0](Arg0: &mut BalanceManager)
9MutBorrowField[3](BalanceManager.balances: Bag)
10MoveLoc[2](loc0: BalanceKey<Ty0>)
11Call bag::borrow_mut<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): &mut Balance<Ty0>
12MoveLoc[1](Arg1: Balance<Ty0>)
13Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
14Pop
15Branch(21)
B2:
16MoveLoc[0](Arg0: &mut BalanceManager)
17MutBorrowField[3](BalanceManager.balances: Bag)
18MoveLoc[2](loc0: BalanceKey<Ty0>)
19MoveLoc[1](Arg1: Balance<Ty0>)
20Call bag::add<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>, Balance<Ty0>)
B3:
21Ret
}
public(friend) generate_proof_as_depositor(Arg0: &BalanceManager, Arg1: &DepositCap, Arg2: &TxContext): TradeProof {
B0:
0CopyLoc[0](Arg0: &BalanceManager)
1MoveLoc[1](Arg1: &DepositCap)
2Call validate_deposit_cap(&BalanceManager, &DepositCap)
3MoveLoc[0](Arg0: &BalanceManager)
4Call object::id<BalanceManager>(&BalanceManager): ID
5MoveLoc[2](Arg2: &TxContext)
6Call tx_context::sender(&TxContext): address
7Pack[12](TradeProof)
8Ret
}
public(friend) generate_proof_as_withdrawer(Arg0: &BalanceManager, Arg1: &WithdrawCap, Arg2: &TxContext): TradeProof {
B0:
0CopyLoc[0](Arg0: &BalanceManager)
1MoveLoc[1](Arg1: &WithdrawCap)
2Call validate_withdraw_cap(&BalanceManager, &WithdrawCap)
3MoveLoc[0](Arg0: &BalanceManager)
4Call object::id<BalanceManager>(&BalanceManager): ID
5MoveLoc[2](Arg2: &TxContext)
6Call tx_context::sender(&TxContext): address
7Pack[12](TradeProof)
8Ret
}
public(friend) withdraw_with_proof<Ty0>(Arg0: &mut BalanceManager, Arg1: &TradeProof, Arg2: u64, Arg3: bool): Balance<Ty0> {
L4: loc0: Balance<Ty0>
L5: loc1: Balance<Ty0>
L6: loc2: &mut Balance<Ty0>
L7: loc3: u64
L8: loc4: BalanceKey<Ty0>
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1FreezeRef
2MoveLoc[1](Arg1: &TradeProof)
3Call validate_proof(&BalanceManager, &TradeProof)
4LdFalse
5PackGeneric[0](BalanceKey<Ty0>)
6StLoc[8](loc4: BalanceKey<Ty0>)
7CopyLoc[0](Arg0: &mut BalanceManager)
8ImmBorrowField[3](BalanceManager.balances: Bag)
9CopyLoc[8](loc4: BalanceKey<Ty0>)
10Call bag::contains<BalanceKey<Ty0>>(&Bag, BalanceKey<Ty0>): bool
11Not
12BrFalse(18)
B1:
13CopyLoc[0](Arg0: &mut BalanceManager)
14MutBorrowField[3](BalanceManager.balances: Bag)
15CopyLoc[8](loc4: BalanceKey<Ty0>)
16Call balance::zero<Ty0>(): Balance<Ty0>
17Call bag::add<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>, Balance<Ty0>)
B2:
18MoveLoc[3](Arg3: bool)
19BrFalse(26)
B3:
20MoveLoc[0](Arg0: &mut BalanceManager)
21MutBorrowField[3](BalanceManager.balances: Bag)
22MoveLoc[8](loc4: BalanceKey<Ty0>)
23Call bag::remove<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): Balance<Ty0>
24StLoc[5](loc1: Balance<Ty0>)
25Branch(66)
B4:
26CopyLoc[0](Arg0: &mut BalanceManager)
27MutBorrowField[3](BalanceManager.balances: Bag)
28CopyLoc[8](loc4: BalanceKey<Ty0>)
29Call bag::borrow_mut<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): &mut Balance<Ty0>
30StLoc[6](loc2: &mut Balance<Ty0>)
31CopyLoc[6](loc2: &mut Balance<Ty0>)
32FreezeRef
33Call balance::value<Ty0>(&Balance<Ty0>): u64
34StLoc[7](loc3: u64)
35CopyLoc[7](loc3: u64)
36CopyLoc[2](Arg2: u64)
37Ge
38BrFalse(40)
B5:
39Branch(46)
B6:
40MoveLoc[0](Arg0: &mut BalanceManager)
41Pop
42MoveLoc[6](loc2: &mut Balance<Ty0>)
43Pop
44LdConst[3](u64: 3)
45Abort
B7:
46CopyLoc[2](Arg2: u64)
47MoveLoc[7](loc3: u64)
48Eq
49BrFalse(58)
B8:
50MoveLoc[6](loc2: &mut Balance<Ty0>)
51Pop
52MoveLoc[0](Arg0: &mut BalanceManager)
53MutBorrowField[3](BalanceManager.balances: Bag)
54MoveLoc[8](loc4: BalanceKey<Ty0>)
55Call bag::remove<BalanceKey<Ty0>, Balance<Ty0>>(&mut Bag, BalanceKey<Ty0>): Balance<Ty0>
56StLoc[4](loc0: Balance<Ty0>)
57Branch(64)
B9:
58MoveLoc[0](Arg0: &mut BalanceManager)
59Pop
60MoveLoc[6](loc2: &mut Balance<Ty0>)
61MoveLoc[2](Arg2: u64)
62Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
63StLoc[4](loc0: Balance<Ty0>)
B10:
64MoveLoc[4](loc0: Balance<Ty0>)
65StLoc[5](loc1: Balance<Ty0>)
B11:
66MoveLoc[5](loc1: Balance<Ty0>)
67Ret
}
public(friend) delete(Arg0: BalanceManager) {
L1: loc0: Bag
B0:
0MoveLoc[0](Arg0: BalanceManager)
1Unpack[0](BalanceManager)
2Pop
3StLoc[1](loc0: Bag)
4Pop
5Call object::delete(UID)
6MoveLoc[1](loc0: Bag)
7Call bag::destroy_empty(Bag)
8Ret
}
public(friend) trader(Arg0: &TradeProof): address {
B0:
0MoveLoc[0](Arg0: &TradeProof)
1ImmBorrowField[8](TradeProof.trader: address)
2ReadRef
3Ret
}
public(friend) emit_balance_event(Arg0: &BalanceManager, Arg1: TypeName, Arg2: u64, Arg3: bool) {
B0:
0MoveLoc[0](Arg0: &BalanceManager)
1Call id(&BalanceManager): ID
2MoveLoc[1](Arg1: TypeName)
3MoveLoc[2](Arg2: u64)
4MoveLoc[3](Arg3: bool)
5Pack[2](BalanceEvent)
6Call event::emit<BalanceEvent>(BalanceEvent)
7Ret
}
mint_trade_cap_internal(Arg0: &mut BalanceManager, Arg1: &mut TxContext): TradeCap {
L2: loc0: UID
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1ImmBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
2Call vec_set::length<ID>(&VecSet<ID>): u64
3LdConst[7](u64: 1000)
4Lt
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut TxContext)
8Pop
9MoveLoc[0](Arg0: &mut BalanceManager)
10Pop
11LdConst[4](u64: 4)
12Abort
B3:
13MoveLoc[1](Arg1: &mut TxContext)
14Call object::new(&mut TxContext): UID
15StLoc[2](loc0: UID)
16CopyLoc[0](Arg0: &mut BalanceManager)
17MutBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
18ImmBorrowLoc[2](loc0: UID)
19Call object::uid_to_inner(&UID): ID
20Call vec_set::insert<ID>(&mut VecSet<ID>, ID)
21MoveLoc[2](loc0: UID)
22MoveLoc[0](Arg0: &mut BalanceManager)
23FreezeRef
24Call object::id<BalanceManager>(&BalanceManager): ID
25Pack[5](TradeCap)
26Ret
}
mint_deposit_cap_internal(Arg0: &mut BalanceManager, Arg1: &mut TxContext): DepositCap {
L2: loc0: UID
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1ImmBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
2Call vec_set::length<ID>(&VecSet<ID>): u64
3LdConst[7](u64: 1000)
4Lt
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut TxContext)
8Pop
9MoveLoc[0](Arg0: &mut BalanceManager)
10Pop
11LdConst[4](u64: 4)
12Abort
B3:
13MoveLoc[1](Arg1: &mut TxContext)
14Call object::new(&mut TxContext): UID
15StLoc[2](loc0: UID)
16CopyLoc[0](Arg0: &mut BalanceManager)
17MutBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
18ImmBorrowLoc[2](loc0: UID)
19Call object::uid_to_inner(&UID): ID
20Call vec_set::insert<ID>(&mut VecSet<ID>, ID)
21MoveLoc[2](loc0: UID)
22MoveLoc[0](Arg0: &mut BalanceManager)
23FreezeRef
24Call object::id<BalanceManager>(&BalanceManager): ID
25Pack[6](DepositCap)
26Ret
}
mint_withdraw_cap_internal(Arg0: &mut BalanceManager, Arg1: &mut TxContext): WithdrawCap {
L2: loc0: UID
B0:
0CopyLoc[0](Arg0: &mut BalanceManager)
1ImmBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
2Call vec_set::length<ID>(&VecSet<ID>): u64
3LdConst[7](u64: 1000)
4Lt
5BrFalse(7)
B1:
6Branch(13)
B2:
7MoveLoc[1](Arg1: &mut TxContext)
8Pop
9MoveLoc[0](Arg0: &mut BalanceManager)
10Pop
11LdConst[4](u64: 4)
12Abort
B3:
13MoveLoc[1](Arg1: &mut TxContext)
14Call object::new(&mut TxContext): UID
15StLoc[2](loc0: UID)
16CopyLoc[0](Arg0: &mut BalanceManager)
17MutBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
18ImmBorrowLoc[2](loc0: UID)
19Call object::uid_to_inner(&UID): ID
20Call vec_set::insert<ID>(&mut VecSet<ID>, ID)
21MoveLoc[2](loc0: UID)
22MoveLoc[0](Arg0: &mut BalanceManager)
23FreezeRef
24Call object::id<BalanceManager>(&BalanceManager): ID
25Pack[7](WithdrawCap)
26Ret
}
validate_owner(Arg0: &BalanceManager, Arg1: &TxContext) {
B0:
0MoveLoc[1](Arg1: &TxContext)
1Call tx_context::sender(&TxContext): address
2MoveLoc[0](Arg0: &BalanceManager)
3Call owner(&BalanceManager): address
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[0](u64: 0)
8Abort
B3:
9Ret
}
validate_trader(Arg0: &BalanceManager, Arg1: &TradeCap) {
B0:
0MoveLoc[0](Arg0: &BalanceManager)
1ImmBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
2MoveLoc[1](Arg1: &TradeCap)
3Call object::borrow_id<TradeCap>(&TradeCap): &ID
4Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[1](u64: 1)
8Abort
B3:
9Ret
}
validate_deposit_cap(Arg0: &BalanceManager, Arg1: &DepositCap) {
B0:
0MoveLoc[0](Arg0: &BalanceManager)
1ImmBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
2MoveLoc[1](Arg1: &DepositCap)
3Call object::borrow_id<DepositCap>(&DepositCap): &ID
4Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[1](u64: 1)
8Abort
B3:
9Ret
}
validate_withdraw_cap(Arg0: &BalanceManager, Arg1: &WithdrawCap) {
B0:
0MoveLoc[0](Arg0: &BalanceManager)
1ImmBorrowField[4](BalanceManager.allow_listed: VecSet<ID>)
2MoveLoc[1](Arg1: &WithdrawCap)
3Call object::borrow_id<WithdrawCap>(&WithdrawCap): &ID
4Call vec_set::contains<ID>(&VecSet<ID>, &ID): bool
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[1](u64: 1)
8Abort
B3:
9Ret
}
Constants [
0 => u64: 0
1 => u64: 1
2 => u64: 2
3 => u64: 3
4 => u64: 4
5 => u64: 5
6 => u64: 6
7 => u64: 1000
8 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
]
}