app
Module0x45ba…fc70
- Move path
- 0xfe1d…80bf::app
- Functions
- 172 public, 0 entry
- Structs
- 6
app
- adl21
- adl_admin6
- app17
- asset21
- asset_admin7
- borrow1
- borrow_index4
- coin_decimals_registry5
- ctoken1
- ctoken_table9
- debt9
- decimals_admin2
- deposit1
- emode31
- emode_admin6
- enter_market4
- error81
- flash_loan5
- generic_store10
- interest8
- limiter10
- liquidate6
- liquidity_miner14
- liquidity_mining2
- liquidity_mining_admin3
- liquidity_mining_reward_manager17
- market50
- market_admin6
- market_query3
- market_type0
- obligation17
- obligation_query2
- query_types3
- referral19
- referral_admin2
- repay3
- reserve25
- revenue_admin1
- user_rebates8
- value2
- version_admin1
- whitelist_admin8
- wit_table11
- withdraw2
Bytecode385 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module fe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf.app {
use fe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::error;
use fe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::market;
use fe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::referral;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
struct APP has drop {
dummy_field: bool
}
struct AdminCap has store, key {
id: UID
}
struct PackageCallerCap has store, key {
id: UID
}
struct ReferralKey has copy, drop, store {
dummy_field: bool
}
struct PackageWhitestKey has copy, drop, store {
dummy_field: bool
}
struct ProtocolApp has store, key {
id: UID,
version: u64,
markets: Table<TypeName, ID>
}
init(Arg0: APP, Arg1: &mut TxContext) {
L2: loc0: ProtocolApp
B0:
0MoveLoc[0](Arg0: APP)
1CopyLoc[1](Arg1: &mut TxContext)
2Call package::claim_and_keep<APP>(APP, &mut TxContext)
3CopyLoc[1](Arg1: &mut TxContext)
4Call create(&mut TxContext): AdminCap * ProtocolApp
5StLoc[2](loc0: ProtocolApp)
6MoveLoc[1](Arg1: &mut TxContext)
7FreezeRef
8Call tx_context::sender(&TxContext): address
9Call transfer::transfer<AdminCap>(AdminCap, address)
10MoveLoc[2](loc0: ProtocolApp)
11Call transfer::public_share_object<ProtocolApp>(ProtocolApp)
12Ret
}
create(Arg0: &mut TxContext): AdminCap * ProtocolApp {
L1: loc0: AdminCap
L2: loc1: ProtocolApp
B0:
0CopyLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Pack[1](AdminCap)
3StLoc[1](loc0: AdminCap)
4CopyLoc[0](Arg0: &mut TxContext)
5Call object::new(&mut TxContext): UID
6LdConst[0](u64: 1)
7CopyLoc[0](Arg0: &mut TxContext)
8Call table::new<TypeName, ID>(&mut TxContext): Table<TypeName, ID>
9Pack[5](ProtocolApp)
10StLoc[2](loc1: ProtocolApp)
11MutBorrowLoc[2](loc1: ProtocolApp)
12MutBorrowField[0](ProtocolApp.id: UID)
13LdFalse
14Pack[3](ReferralKey)
15MoveLoc[0](Arg0: &mut TxContext)
16Call referral::default(&mut TxContext): Referral
17Call dynamic_field::add<ReferralKey, Referral>(&mut UID, ReferralKey, Referral)
18MutBorrowLoc[2](loc1: ProtocolApp)
19MutBorrowField[0](ProtocolApp.id: UID)
20LdFalse
21Pack[4](PackageWhitestKey)
22Call vec_map::empty<ID, u32>(): VecMap<ID, u32>
23Call dynamic_field::add<PackageWhitestKey, VecMap<ID, u32>>(&mut UID, PackageWhitestKey, VecMap<ID, u32>)
24MoveLoc[1](loc0: AdminCap)
25MoveLoc[2](loc1: ProtocolApp)
26Ret
}
public permissions(Arg0: &ProtocolApp, Arg1: &PackageCallerCap): u32 {
L2: loc0: ID
L3: loc1: &VecMap<ID, u32>
B0:
0MoveLoc[0](Arg0: &ProtocolApp)
1ImmBorrowField[0](ProtocolApp.id: UID)
2LdFalse
3Pack[4](PackageWhitestKey)
4Call dynamic_field::borrow<PackageWhitestKey, VecMap<ID, u32>>(&UID, PackageWhitestKey): &VecMap<ID, u32>
5StLoc[3](loc1: &VecMap<ID, u32>)
6MoveLoc[1](Arg1: &PackageCallerCap)
7Call object::id<PackageCallerCap>(&PackageCallerCap): ID
8StLoc[2](loc0: ID)
9CopyLoc[3](loc1: &VecMap<ID, u32>)
10ImmBorrowLoc[2](loc0: ID)
11Call vec_map::contains<ID, u32>(&VecMap<ID, u32>, &ID): bool
12BrFalse(14)
B1:
13Branch(18)
B2:
14MoveLoc[3](loc1: &VecMap<ID, u32>)
15Pop
16Call error::caller_not_whitelisted(): u64
17Abort
B3:
18MoveLoc[3](loc1: &VecMap<ID, u32>)
19ImmBorrowLoc[2](loc0: ID)
20Call vec_map::get<ID, u32>(&VecMap<ID, u32>, &ID): &u32
21ReadRef
22Ret
}
public current_version(): u64 {
B0:
0LdConst[0](u64: 1)
1Ret
}
public(friend) ensure_version_matches(Arg0: &ProtocolApp) {
B0:
0MoveLoc[0](Arg0: &ProtocolApp)
1ImmBorrowField[1](ProtocolApp.version: u64)
2ReadRef
3LdConst[0](u64: 1)
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7Call error::version_mismatch(): u64
8Abort
B3:
9Ret
}
public(friend) migrate(Arg0: &mut ProtocolApp): u64 {
B0:
0CopyLoc[0](Arg0: &mut ProtocolApp)
1ImmBorrowField[1](ProtocolApp.version: u64)
2ReadRef
3LdConst[0](u64: 1)
4Lt
5BrFalse(7)
B1:
6Branch(11)
B2:
7MoveLoc[0](Arg0: &mut ProtocolApp)
8Pop
9Call error::version_mismatch(): u64
10Abort
B3:
11LdConst[0](u64: 1)
12MoveLoc[0](Arg0: &mut ProtocolApp)
13MutBorrowField[1](ProtocolApp.version: u64)
14WriteRef
15LdConst[0](u64: 1)
16Ret
}
public(friend) get_market_config<Ty0>(Arg0: &ProtocolApp, Arg1: &Market<Ty0>): &MarketConfiguration {
B0:
0MoveLoc[0](Arg0: &ProtocolApp)
1CopyLoc[1](Arg1: &Market<Ty0>)
2Call validate_market<Ty0>(&ProtocolApp, &Market<Ty0>)
3MoveLoc[1](Arg1: &Market<Ty0>)
4Call market::market_config<Ty0>(&Market<Ty0>): &MarketConfiguration
5Ret
}
public(friend) get_market_id<Ty0>(Arg0: &ProtocolApp): &ID {
L1: loc0: TypeName
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1StLoc[1](loc0: TypeName)
2CopyLoc[0](Arg0: &ProtocolApp)
3ImmBorrowField[2](ProtocolApp.markets: Table<TypeName, ID>)
4CopyLoc[1](loc0: TypeName)
5Call table::contains<TypeName, ID>(&Table<TypeName, ID>, TypeName): bool
6BrFalse(8)
B1:
7Branch(12)
B2:
8MoveLoc[0](Arg0: &ProtocolApp)
9Pop
10Call error::market_not_found(): u64
11Abort
B3:
12MoveLoc[0](Arg0: &ProtocolApp)
13ImmBorrowField[2](ProtocolApp.markets: Table<TypeName, ID>)
14MoveLoc[1](loc0: TypeName)
15Call table::borrow<TypeName, ID>(&Table<TypeName, ID>, TypeName): &ID
16Ret
}
public(friend) is_market_registered<Ty0>(Arg0: &ProtocolApp): bool {
L1: loc0: TypeName
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1StLoc[1](loc0: TypeName)
2MoveLoc[0](Arg0: &ProtocolApp)
3ImmBorrowField[2](ProtocolApp.markets: Table<TypeName, ID>)
4MoveLoc[1](loc0: TypeName)
5Call table::contains<TypeName, ID>(&Table<TypeName, ID>, TypeName): bool
6Ret
}
public(friend) referral(Arg0: &ProtocolApp): &Referral {
B0:
0MoveLoc[0](Arg0: &ProtocolApp)
1ImmBorrowField[0](ProtocolApp.id: UID)
2LdFalse
3Pack[3](ReferralKey)
4Call dynamic_field::borrow<ReferralKey, Referral>(&UID, ReferralKey): &Referral
5Ret
}
public(friend) referral_mut(Arg0: &mut ProtocolApp): &mut Referral {
B0:
0MoveLoc[0](Arg0: &mut ProtocolApp)
1MutBorrowField[0](ProtocolApp.id: UID)
2LdFalse
3Pack[3](ReferralKey)
4Call dynamic_field::borrow_mut<ReferralKey, Referral>(&mut UID, ReferralKey): &mut Referral
5Ret
}
public(friend) add_market<Ty0>(Arg0: &mut ProtocolApp, Arg1: ID) {
L2: loc0: TypeName
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1StLoc[2](loc0: TypeName)
2CopyLoc[0](Arg0: &mut ProtocolApp)
3ImmBorrowField[2](ProtocolApp.markets: Table<TypeName, ID>)
4CopyLoc[2](loc0: TypeName)
5Call table::contains<TypeName, ID>(&Table<TypeName, ID>, TypeName): bool
6Not
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &mut ProtocolApp)
10Pop
11Call error::market_already_exists(): u64
12Abort
B3:
13MoveLoc[0](Arg0: &mut ProtocolApp)
14MutBorrowField[2](ProtocolApp.markets: Table<TypeName, ID>)
15MoveLoc[2](loc0: TypeName)
16MoveLoc[1](Arg1: ID)
17Call table::add<TypeName, ID>(&mut Table<TypeName, ID>, TypeName, ID)
18Ret
}
public(friend) validate_market<Ty0>(Arg0: &ProtocolApp, Arg1: &Market<Ty0>) {
L2: loc0: ID
L3: loc1: &ID
L4: loc2: TypeName
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1StLoc[4](loc2: TypeName)
2CopyLoc[0](Arg0: &ProtocolApp)
3ImmBorrowField[2](ProtocolApp.markets: Table<TypeName, ID>)
4CopyLoc[4](loc2: TypeName)
5Call table::contains<TypeName, ID>(&Table<TypeName, ID>, TypeName): bool
6BrFalse(8)
B1:
7Branch(14)
B2:
8MoveLoc[0](Arg0: &ProtocolApp)
9Pop
10MoveLoc[1](Arg1: &Market<Ty0>)
11Pop
12Call error::market_not_found(): u64
13Abort
B3:
14MoveLoc[0](Arg0: &ProtocolApp)
15ImmBorrowField[2](ProtocolApp.markets: Table<TypeName, ID>)
16MoveLoc[4](loc2: TypeName)
17Call table::borrow<TypeName, ID>(&Table<TypeName, ID>, TypeName): &ID
18StLoc[3](loc1: &ID)
19MoveLoc[1](Arg1: &Market<Ty0>)
20Call object::id<Market<Ty0>>(&Market<Ty0>): ID
21StLoc[2](loc0: ID)
22MoveLoc[3](loc1: &ID)
23ImmBorrowLoc[2](loc0: ID)
24Eq
25BrFalse(27)
B4:
26Branch(29)
B5:
27Call error::invalid_market(): u64
28Abort
B6:
29Ret
}
public(friend) mint_cap(Arg0: &mut TxContext): PackageCallerCap {
B0:
0MoveLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2Pack[2](PackageCallerCap)
3Ret
}
public(friend) burn_cap(Arg0: PackageCallerCap) {
B0:
0MoveLoc[0](Arg0: PackageCallerCap)
1Unpack[2](PackageCallerCap)
2Call object::delete(UID)
3Ret
}
public(friend) whitelist_mut(Arg0: &mut ProtocolApp): &mut VecMap<ID, u32> {
B0:
0MoveLoc[0](Arg0: &mut ProtocolApp)
1MutBorrowField[0](ProtocolApp.id: UID)
2LdFalse
3Pack[4](PackageWhitestKey)
4Call dynamic_field::borrow_mut<PackageWhitestKey, VecMap<ID, u32>>(&mut UID, PackageWhitestKey): &mut VecMap<ID, u32>
5Ret
}
public(friend) ensure_has_permission(Arg0: &ProtocolApp, Arg1: ID, Arg2: u8) {
L3: loc0: u32
L4: loc1: u32
L5: loc2: &VecMap<ID, u32>
B0:
0MoveLoc[0](Arg0: &ProtocolApp)
1ImmBorrowField[0](ProtocolApp.id: UID)
2LdFalse
3Pack[4](PackageWhitestKey)
4Call dynamic_field::borrow<PackageWhitestKey, VecMap<ID, u32>>(&UID, PackageWhitestKey): &VecMap<ID, u32>
5StLoc[5](loc2: &VecMap<ID, u32>)
6CopyLoc[5](loc2: &VecMap<ID, u32>)
7ImmBorrowLoc[1](Arg1: ID)
8Call vec_map::contains<ID, u32>(&VecMap<ID, u32>, &ID): bool
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[5](loc2: &VecMap<ID, u32>)
12Pop
13Call error::caller_not_whitelisted(): u64
14Abort
B3:
15MoveLoc[5](loc2: &VecMap<ID, u32>)
16ImmBorrowLoc[1](Arg1: ID)
17Call vec_map::get<ID, u32>(&VecMap<ID, u32>, &ID): &u32
18ReadRef
19StLoc[4](loc1: u32)
20LdU32(1)
21MoveLoc[2](Arg2: u8)
22Shl
23StLoc[3](loc0: u32)
24MoveLoc[4](loc1: u32)
25MoveLoc[3](loc0: u32)
26BitAnd
27LdU32(0)
28Neq
29BrFalse(31)
B4:
30Branch(33)
B5:
31Call error::caller_has_no_permission(): u64
32Abort
B6:
33Ret
}
Constants [
0 => u64: 1
]
}