inventory
Module0x4e71…3cdf
- Move path
- 0x8628…5437::inventory
- Functions
- 97 public, 0 entry
- Structs
- 2
- Friend modules
- None
Bytecode223 lines
The on-chain disassembly. Offsets are instruction numbers within each function.
// Move bytecode v6
module 862810efecf0296db2e9df3e075a7af8034ba374e73ff1098e88cc4bb7c15437.inventory {
use 862810efecf0296db2e9df3e075a7af8034ba374e73ff1098e88cc4bb7c15437::admin;
use 862810efecf0296db2e9df3e075a7af8034ba374e73ff1098e88cc4bb7c15437::doubleup_citizens;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct InventoryConfig has key {
id: UID,
blacklist_types: Table<TypeName, bool>,
version_set: VecSet<u64>
}
struct BorrowReceipt<phantom Ty0> {
item_id: ID,
citizen_id: ID
}
init(Arg0: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut TxContext)
1Call object::new(&mut TxContext): UID
2MoveLoc[0](Arg0: &mut TxContext)
3Call table::new<TypeName, bool>(&mut TxContext): Table<TypeName, bool>
4LdConst[0](u64: 0)
5Call vec_set::singleton<u64>(u64): VecSet<u64>
6Pack[0](InventoryConfig)
7Call transfer::share_object<InventoryConfig>(InventoryConfig)
8Ret
}
public receive<Ty0: store + key>(Arg0: &mut DoubleUpCitizen, Arg1: Receiving<Ty0>, Arg2: &InventoryConfig): Ty0 {
L3: loc0: TypeName
B0:
0CopyLoc[2](Arg2: &InventoryConfig)
1Call is_valid_version(&InventoryConfig): bool
2BrFalse(4)
B1:
3Branch(10)
B2:
4MoveLoc[2](Arg2: &InventoryConfig)
5Pop
6MoveLoc[0](Arg0: &mut DoubleUpCitizen)
7Pop
8LdConst[1](u64: 1)
9Abort
B3:
10Call type_name::get<Ty0>(): TypeName
11StLoc[3](loc0: TypeName)
12MoveLoc[2](Arg2: &InventoryConfig)
13ImmBorrowField[0](InventoryConfig.blacklist_types: Table<TypeName, bool>)
14MoveLoc[3](loc0: TypeName)
15Call table::contains<TypeName, bool>(&Table<TypeName, bool>, TypeName): bool
16Not
17BrFalse(19)
B4:
18Branch(23)
B5:
19MoveLoc[0](Arg0: &mut DoubleUpCitizen)
20Pop
21LdConst[0](u64: 0)
22Abort
B6:
23MoveLoc[0](Arg0: &mut DoubleUpCitizen)
24MoveLoc[1](Arg1: Receiving<Ty0>)
25Call doubleup_citizens::receive<Ty0>(&mut DoubleUpCitizen, Receiving<Ty0>): Ty0
26Ret
}
public borrow<Ty0: store + key>(Arg0: &mut DoubleUpCitizen, Arg1: Receiving<Ty0>): Ty0 * BorrowReceipt<Ty0> {
L2: loc0: BorrowReceipt<Ty0>
L3: loc1: Ty0
B0:
0CopyLoc[0](Arg0: &mut DoubleUpCitizen)
1MoveLoc[1](Arg1: Receiving<Ty0>)
2Call doubleup_citizens::receive<Ty0>(&mut DoubleUpCitizen, Receiving<Ty0>): Ty0
3StLoc[3](loc1: Ty0)
4ImmBorrowLoc[3](loc1: Ty0)
5Call object::id<Ty0>(&Ty0): ID
6MoveLoc[0](Arg0: &mut DoubleUpCitizen)
7FreezeRef
8Call object::id<DoubleUpCitizen>(&DoubleUpCitizen): ID
9PackGeneric[0](BorrowReceipt<Ty0>)
10StLoc[2](loc0: BorrowReceipt<Ty0>)
11MoveLoc[3](loc1: Ty0)
12MoveLoc[2](loc0: BorrowReceipt<Ty0>)
13Ret
}
public return_borrowed<Ty0: store + key>(Arg0: &mut DoubleUpCitizen, Arg1: Ty0, Arg2: BorrowReceipt<Ty0>) {
L3: loc0: ID
B0:
0MoveLoc[2](Arg2: BorrowReceipt<Ty0>)
1UnpackGeneric[0](BorrowReceipt<Ty0>)
2StLoc[3](loc0: ID)
3ImmBorrowLoc[1](Arg1: Ty0)
4Call object::id<Ty0>(&Ty0): ID
5Eq
6BrFalse(8)
B1:
7Branch(12)
B2:
8MoveLoc[0](Arg0: &mut DoubleUpCitizen)
9Pop
10LdConst[4](u64: 4)
11Abort
B3:
12CopyLoc[3](loc0: ID)
13MoveLoc[0](Arg0: &mut DoubleUpCitizen)
14FreezeRef
15Call object::id<DoubleUpCitizen>(&DoubleUpCitizen): ID
16Eq
17BrFalse(19)
B4:
18Branch(21)
B5:
19LdConst[5](u64: 5)
20Abort
B6:
21MoveLoc[1](Arg1: Ty0)
22ImmBorrowLoc[3](loc0: ID)
23Call object::id_to_address(&ID): address
24Call transfer::public_transfer<Ty0>(Ty0, address)
25Ret
}
public add_version(Arg0: &mut InventoryConfig, Arg1: u64, Arg2: &CitizenCap) {
B0:
0MoveLoc[0](Arg0: &mut InventoryConfig)
1MutBorrowField[1](InventoryConfig.version_set: VecSet<u64>)
2MoveLoc[1](Arg1: u64)
3Call vec_set::insert<u64>(&mut VecSet<u64>, u64)
4Ret
}
public remove_version(Arg0: &mut InventoryConfig, Arg1: u64, Arg2: &CitizenCap) {
B0:
0MoveLoc[0](Arg0: &mut InventoryConfig)
1MutBorrowField[1](InventoryConfig.version_set: VecSet<u64>)
2ImmBorrowLoc[1](Arg1: u64)
3Call vec_set::remove<u64>(&mut VecSet<u64>, &u64)
4Ret
}
public add_blacklist_type<Ty0>(Arg0: &mut InventoryConfig, Arg1: &CitizenCap) {
L2: loc0: TypeName
B0:
0Call type_name::get<Ty0>(): TypeName
1StLoc[2](loc0: TypeName)
2CopyLoc[0](Arg0: &mut InventoryConfig)
3ImmBorrowField[0](InventoryConfig.blacklist_types: Table<TypeName, bool>)
4CopyLoc[2](loc0: TypeName)
5Call table::contains<TypeName, bool>(&Table<TypeName, bool>, TypeName): bool
6Not
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &mut InventoryConfig)
10Pop
11LdConst[2](u64: 2)
12Abort
B3:
13MoveLoc[0](Arg0: &mut InventoryConfig)
14MutBorrowField[0](InventoryConfig.blacklist_types: Table<TypeName, bool>)
15MoveLoc[2](loc0: TypeName)
16LdTrue
17Call table::add<TypeName, bool>(&mut Table<TypeName, bool>, TypeName, bool)
18Ret
}
public remove_blacklist_type<Ty0>(Arg0: &mut InventoryConfig, Arg1: &CitizenCap) {
L2: loc0: TypeName
B0:
0Call type_name::get<Ty0>(): TypeName
1StLoc[2](loc0: TypeName)
2CopyLoc[0](Arg0: &mut InventoryConfig)
3ImmBorrowField[0](InventoryConfig.blacklist_types: Table<TypeName, bool>)
4CopyLoc[2](loc0: TypeName)
5Call table::contains<TypeName, bool>(&Table<TypeName, bool>, TypeName): bool
6BrFalse(8)
B1:
7Branch(12)
B2:
8MoveLoc[0](Arg0: &mut InventoryConfig)
9Pop
10LdConst[3](u64: 3)
11Abort
B3:
12MoveLoc[0](Arg0: &mut InventoryConfig)
13MutBorrowField[0](InventoryConfig.blacklist_types: Table<TypeName, bool>)
14MoveLoc[2](loc0: TypeName)
15Call table::remove<TypeName, bool>(&mut Table<TypeName, bool>, TypeName): bool
16Pop
17Ret
}
is_valid_version(Arg0: &InventoryConfig): bool {
L1: loc0: u64
B0:
0LdConst[0](u64: 0)
1StLoc[1](loc0: u64)
2MoveLoc[0](Arg0: &InventoryConfig)
3ImmBorrowField[1](InventoryConfig.version_set: VecSet<u64>)
4ImmBorrowLoc[1](loc0: u64)
5Call vec_set::contains<u64>(&VecSet<u64>, &u64): bool
6Ret
}
Constants [
0 => u64: 0
1 => u64: 1
2 => u64: 2
3 => u64: 3
4 => u64: 4
5 => u64: 5
]
}