collection
Module0xbd2e…e190
- Move path
- 0xee0e…d45f::collection
- Functions
- 7612 public, 24 entry
- Structs
- 29
collection
Bytecode3861 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module ee0e96c6dcfa447bd5e026be5c995fca0c058e12530c8b5dfef57aa390c8d45f.collection {
use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::kiosk_lock_rule;
use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::personal_kiosk;
use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::royalty_rule;
use 0000000000000000000000000000000000000000000000000000000000000001::internal;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000001::u8;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::address;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::display;
use 0000000000000000000000000000000000000000000000000000000000000002::display_registry;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::kiosk;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::random;
use 0000000000000000000000000000000000000000000000000000000000000002::sui;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer_policy;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
struct COLLECTION has drop {
dummy_field: bool
}
struct AdminCap has key {
id: UID,
collection: ID
}
struct PublisherKey has copy, drop, store {
dummy_field: bool
}
struct DisplayCapKey has copy, drop, store {
dummy_field: bool
}
struct PriceTier has copy, drop, store {
start_ms: u64,
price: u64
}
struct Gate has copy, drop, store {
price: u64,
start_ms: u64,
end_ms: u64,
max_per_wallet: u64,
open: bool
}
struct GateKey has copy, drop, store {
gate: TypeName,
wallet: address
}
struct Pack has copy, drop, store {
min_count: u64,
max_unit_price: u64
}
struct Collection has key {
id: UID,
version: u64,
revision: u64,
name: String,
supply: u64,
minted: u64,
public_start_ms: u64,
mint_open: bool,
tiers: vector<PriceTier>,
max_per_tx: u64,
max_per_wallet: u64,
minted_by: Table<address, u64>,
luck_max: u8,
packs: vector<Pack>,
gates: Table<TypeName, Gate>,
gate_minted: Table<GateKey, u64>,
wallet_a: address,
wallet_b: address,
bps_a: u64,
policy: ID,
policy_cap: TransferPolicyCap<Mortem>,
display: ID,
media_base: String,
rising: Rising,
media_frozen: bool
}
struct Rising has store {
reveal_open: bool,
reveal_start_ms: u64,
seeded: u64,
drawn: u64,
pool: vector<u16>,
provenance_hash: vector<u8>,
provenance_scheme: String,
running_hash: vector<u8>,
seeding_sealed: bool
}
struct Mortem has store, key {
id: UID,
number: u64,
index: u64,
name: String,
attributes: VecMap<String, String>,
filler: VecMap<String, String>,
metadata_version: u64,
luck: u8,
pad: vector<u8>
}
struct CollectionCreated has copy, drop {
collection: ID,
policy: ID,
display: ID,
supply: u64
}
struct GraveMinted has copy, drop {
collection: ID,
item: ID,
number: u64,
minter: address,
kiosk: ID,
price: u64,
luck: u8
}
struct PaymentSplit has copy, drop {
collection: ID,
total: u64,
to_a: u64,
to_b: u64
}
struct ConfigUpdated has copy, drop {
collection: ID,
revision: u64,
section: u8
}
struct MintOpenSet has copy, drop {
collection: ID,
open: bool
}
struct SaleSet has copy, drop {
collection: ID,
public_start_ms: u64,
starts: vector<u64>,
prices: vector<u64>
}
struct LimitsSet has copy, drop {
collection: ID,
max_per_tx: u64,
max_per_wallet: u64
}
struct SplitSet has copy, drop {
collection: ID,
wallet_a: address,
wallet_b: address,
bps_a: u64
}
struct RoyaltySet has copy, drop {
collection: ID,
bps: u16,
min: u64
}
struct RoyaltiesDistributed has copy, drop {
collection: ID,
total: u64,
to_a: u64,
to_b: u64
}
struct MediaConfigured has copy, drop {
collection: ID,
base: String
}
struct RevealStartSet has copy, drop {
collection: ID,
reveal_start_ms: u64
}
struct LuckMaxSet has copy, drop {
collection: ID,
luck_max: u8
}
struct GateSet has copy, drop {
collection: ID,
gate: TypeName,
price: u64,
start_ms: u64,
end_ms: u64,
max_per_wallet: u64,
open: bool
}
struct PacksSet has copy, drop {
collection: ID,
min_counts: vector<u64>,
max_unit_prices: vector<u64>
}
struct GateUsed has copy, drop {
collection: ID,
gate: TypeName,
wallet: address,
count: u64,
price: u64
}
struct AdminTransferred has copy, drop {
collection: ID,
to: address
}
struct Migrated has copy, drop {
collection: ID,
from: u64,
to: u64
}
init(Arg0: COLLECTION, Arg1: &mut TxContext) {
L2: loc0: Collection
L3: loc1: ID
L4: loc2: Display<Mortem>
L5: loc3: address
L6: loc4: String
L7: loc5: TransferPolicy<Mortem>
L8: loc6: TransferPolicyCap<Mortem>
L9: loc7: Publisher
L10: loc8: UID
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[5](loc3: address)
4MoveLoc[0](Arg0: COLLECTION)
5CopyLoc[1](Arg1: &mut TxContext)
6Call package::claim<COLLECTION>(COLLECTION, &mut TxContext): Publisher
7StLoc[9](loc7: Publisher)
8LdConst[5](vector<u8>: "htt..)
9Call string::utf8(vector<u8>): String
10LdConst[6](vector<u8>: "tok..)
11Call media_url(String, vector<u8>): String
12StLoc[6](loc4: String)
13ImmBorrowLoc[9](loc7: Publisher)
14Call v1_keys(): vector<String>
15LdConst[10](vector<u8>: "{na..)
16Call string::utf8(vector<u8>): String
17LdConst[12](vector<u8>: "A s..)
18Call string::utf8(vector<u8>): String
19CopyLoc[6](loc4: String)
20MoveLoc[6](loc4: String)
21LdConst[8](vector<u8>: "htt..)
22Call string::utf8(vector<u8>): String
23LdConst[9](vector<u8>: "Pul..)
24Call string::utf8(vector<u8>): String
25LdConst[49](vector<u8>: "{nu..)
26Call string::utf8(vector<u8>): String
27VecPack(18, 7)
28CopyLoc[1](Arg1: &mut TxContext)
29Call display::new_with_fields<Mortem>(&Publisher, vector<String>, vector<String>, &mut TxContext): Display<Mortem>
30StLoc[4](loc2: Display<Mortem>)
31MutBorrowLoc[4](loc2: Display<Mortem>)
32Call display::update_version<Mortem>(&mut Display<Mortem>)
33ImmBorrowLoc[9](loc7: Publisher)
34CopyLoc[1](Arg1: &mut TxContext)
35Call transfer_policy::new<Mortem>(&Publisher, &mut TxContext): TransferPolicy<Mortem> * TransferPolicyCap<Mortem>
36StLoc[8](loc6: TransferPolicyCap<Mortem>)
37StLoc[7](loc5: TransferPolicy<Mortem>)
38MutBorrowLoc[7](loc5: TransferPolicy<Mortem>)
39ImmBorrowLoc[8](loc6: TransferPolicyCap<Mortem>)
40LdConst[3](u16: 300)
41LdConst[4](u64: 5000..)
42Call royalty_rule::add<Mortem>(&mut TransferPolicy<Mortem>, &TransferPolicyCap<Mortem>, u16, u64)
43MutBorrowLoc[7](loc5: TransferPolicy<Mortem>)
44ImmBorrowLoc[8](loc6: TransferPolicyCap<Mortem>)
45Call kiosk_lock_rule::add<Mortem>(&mut TransferPolicy<Mortem>, &TransferPolicyCap<Mortem>)
46CopyLoc[1](Arg1: &mut TxContext)
47Call object::new(&mut TxContext): UID
48StLoc[10](loc8: UID)
49ImmBorrowLoc[10](loc8: UID)
50Call object::uid_to_inner(&UID): ID
51StLoc[3](loc1: ID)
52MutBorrowLoc[10](loc8: UID)
53LdFalse
54Pack[2](PublisherKey)
55MoveLoc[9](loc7: Publisher)
56Call dynamic_field::add<PublisherKey, Publisher>(&mut UID, PublisherKey, Publisher)
57MoveLoc[10](loc8: UID)
58LdConst[21](u64: 1)
59LdU64(0)
60LdConst[0](vector<u8>: "MOR..)
61Call string::utf8(vector<u8>): String
62LdConst[2](u64: 666)
63LdU64(0)
64LdConst[20](u64: 1844..)
65LdFalse
66VecPack(85, 0)
67LdConst[15](u64: 10)
68LdConst[16](u64: 5)
69CopyLoc[1](Arg1: &mut TxContext)
70Call table::new<address, u64>(&mut TxContext): Table<address, u64>
71LdConst[13](u8: 13)
72VecPack(88, 0)
73CopyLoc[1](Arg1: &mut TxContext)
74Call table::new<TypeName, Gate>(&mut TxContext): Table<TypeName, Gate>
75CopyLoc[1](Arg1: &mut TxContext)
76Call table::new<GateKey, u64>(&mut TxContext): Table<GateKey, u64>
77LdConst[50](address: 0x00..)
78LdConst[50](address: 0x00..)
79LdConst[19](u64: 10000)
80ImmBorrowLoc[7](loc5: TransferPolicy<Mortem>)
81Call object::id<TransferPolicy<Mortem>>(&TransferPolicy<Mortem>): ID
82MoveLoc[8](loc6: TransferPolicyCap<Mortem>)
83ImmBorrowLoc[4](loc2: Display<Mortem>)
84Call object::id<Display<Mortem>>(&Display<Mortem>): ID
85LdConst[5](vector<u8>: "htt..)
86Call string::utf8(vector<u8>): String
87LdFalse
88LdConst[20](u64: 1844..)
89LdU64(0)
90LdU64(0)
91LdConst[51](vector<u16>: 00)
92LdConst[52](vector<u8>: "" /..)
93LdConst[52](vector<u8>: "" /..)
94Call string::utf8(vector<u8>): String
95LdConst[52](vector<u8>: "" /..)
96LdFalse
97Pack[9](Rising)
98LdFalse
99Pack[8](Collection)
100StLoc[2](loc0: Collection)
101CopyLoc[3](loc1: ID)
102ImmBorrowLoc[7](loc5: TransferPolicy<Mortem>)
103Call object::id<TransferPolicy<Mortem>>(&TransferPolicy<Mortem>): ID
104ImmBorrowLoc[4](loc2: Display<Mortem>)
105Call object::id<Display<Mortem>>(&Display<Mortem>): ID
106LdConst[2](u64: 666)
107Pack[11](CollectionCreated)
108Call event::emit<CollectionCreated>(CollectionCreated)
109MoveLoc[7](loc5: TransferPolicy<Mortem>)
110Call transfer::public_share_object<TransferPolicy<Mortem>>(TransferPolicy<Mortem>)
111MoveLoc[2](loc0: Collection)
112Call transfer::share_object<Collection>(Collection)
113MoveLoc[4](loc2: Display<Mortem>)
114CopyLoc[5](loc3: address)
115Call transfer::public_transfer<Display<Mortem>>(Display<Mortem>, address)
116MoveLoc[1](Arg1: &mut TxContext)
117Call object::new(&mut TxContext): UID
118MoveLoc[3](loc1: ID)
119Pack[1](AdminCap)
120MoveLoc[5](loc3: address)
121Call transfer::transfer<AdminCap>(AdminCap, address)
122Ret
}
entry mint_to_kiosk(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: &mut Kiosk, Arg3: &KioskOwnerCap, Arg4: Coin<SUI>, Arg5: u64, Arg6: u64, Arg7: &Clock, Arg8: &Random, Arg9: &mut TxContext) {
L10: loc0: RandomGenerator
B0:
0MoveLoc[8](Arg8: &Random)
1CopyLoc[9](Arg9: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[10](loc0: RandomGenerator)
4MoveLoc[0](Arg0: &mut Collection)
5MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
6MoveLoc[2](Arg2: &mut Kiosk)
7MoveLoc[3](Arg3: &KioskOwnerCap)
8MoveLoc[4](Arg4: Coin<SUI>)
9MoveLoc[5](Arg5: u64)
10MoveLoc[6](Arg6: u64)
11MoveLoc[7](Arg7: &Clock)
12MutBorrowLoc[10](loc0: RandomGenerator)
13MoveLoc[9](Arg9: &mut TxContext)
14Call mint_graves(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, &Clock, &mut RandomGenerator, &mut TxContext)
15Ret
}
entry mint_to_new_kiosk(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: Coin<SUI>, Arg3: u64, Arg4: u64, Arg5: &Clock, Arg6: &Random, Arg7: &mut TxContext) {
L8: loc0: RandomGenerator
L9: loc1: Kiosk
L10: loc2: KioskOwnerCap
B0:
0MoveLoc[6](Arg6: &Random)
1CopyLoc[7](Arg7: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[8](loc0: RandomGenerator)
4CopyLoc[7](Arg7: &mut TxContext)
5Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap
6StLoc[10](loc2: KioskOwnerCap)
7StLoc[9](loc1: Kiosk)
8MoveLoc[0](Arg0: &mut Collection)
9MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
10MutBorrowLoc[9](loc1: Kiosk)
11ImmBorrowLoc[10](loc2: KioskOwnerCap)
12MoveLoc[2](Arg2: Coin<SUI>)
13MoveLoc[3](Arg3: u64)
14MoveLoc[4](Arg4: u64)
15MoveLoc[5](Arg5: &Clock)
16MutBorrowLoc[8](loc0: RandomGenerator)
17CopyLoc[7](Arg7: &mut TxContext)
18Call mint_graves(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, &Clock, &mut RandomGenerator, &mut TxContext)
19MoveLoc[9](loc1: Kiosk)
20Call transfer::public_share_object<Kiosk>(Kiosk)
21MoveLoc[10](loc2: KioskOwnerCap)
22MoveLoc[7](Arg7: &mut TxContext)
23FreezeRef
24Call tx_context::sender(&TxContext): address
25Call transfer::public_transfer<KioskOwnerCap>(KioskOwnerCap, address)
26Ret
}
entry mint_to_personal_kiosk(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: &mut Kiosk, Arg3: &mut PersonalKioskCap, Arg4: Coin<SUI>, Arg5: u64, Arg6: u64, Arg7: &Clock, Arg8: &Random, Arg9: &mut TxContext) {
L10: loc0: Borrow
L11: loc1: RandomGenerator
L12: loc2: KioskOwnerCap
B0:
0MoveLoc[8](Arg8: &Random)
1CopyLoc[9](Arg9: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[11](loc1: RandomGenerator)
4CopyLoc[3](Arg3: &mut PersonalKioskCap)
5Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow
6StLoc[10](loc0: Borrow)
7StLoc[12](loc2: KioskOwnerCap)
8MoveLoc[0](Arg0: &mut Collection)
9MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
10MoveLoc[2](Arg2: &mut Kiosk)
11ImmBorrowLoc[12](loc2: KioskOwnerCap)
12MoveLoc[4](Arg4: Coin<SUI>)
13MoveLoc[5](Arg5: u64)
14MoveLoc[6](Arg6: u64)
15MoveLoc[7](Arg7: &Clock)
16MutBorrowLoc[11](loc1: RandomGenerator)
17MoveLoc[9](Arg9: &mut TxContext)
18Call mint_graves(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, &Clock, &mut RandomGenerator, &mut TxContext)
19MoveLoc[3](Arg3: &mut PersonalKioskCap)
20MoveLoc[12](loc2: KioskOwnerCap)
21MoveLoc[10](loc0: Borrow)
22Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)
23Ret
}
mint_graves(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: &mut Kiosk, Arg3: &KioskOwnerCap, Arg4: Coin<SUI>, Arg5: u64, Arg6: u64, Arg7: &Clock, Arg8: &mut RandomGenerator, Arg9: &mut TxContext) {
L10: loc0: u64
L11: loc1: u64
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2Call check_version(&Collection)
3CopyLoc[0](Arg0: &mut Collection)
4ImmBorrowField[0](Collection.mint_open: bool)
5ReadRef
6BrFalse(8)
B1:
7Branch(24)
B2:
8MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
9Pop
10MoveLoc[3](Arg3: &KioskOwnerCap)
11Pop
12MoveLoc[2](Arg2: &mut Kiosk)
13Pop
14MoveLoc[8](Arg8: &mut RandomGenerator)
15Pop
16MoveLoc[9](Arg9: &mut TxContext)
17Pop
18MoveLoc[7](Arg7: &Clock)
19Pop
20MoveLoc[0](Arg0: &mut Collection)
21Pop
22LdConst[23](u64: 101)
23Abort
B3:
24MoveLoc[7](Arg7: &Clock)
25Call clock::timestamp_ms(&Clock): u64
26StLoc[10](loc0: u64)
27CopyLoc[10](loc0: u64)
28CopyLoc[0](Arg0: &mut Collection)
29ImmBorrowField[1](Collection.public_start_ms: u64)
30ReadRef
31Ge
32BrFalse(34)
B4:
33Branch(48)
B5:
34MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
35Pop
36MoveLoc[3](Arg3: &KioskOwnerCap)
37Pop
38MoveLoc[2](Arg2: &mut Kiosk)
39Pop
40MoveLoc[8](Arg8: &mut RandomGenerator)
41Pop
42MoveLoc[9](Arg9: &mut TxContext)
43Pop
44MoveLoc[0](Arg0: &mut Collection)
45Pop
46LdConst[24](u64: 102)
47Abort
B6:
48CopyLoc[0](Arg0: &mut Collection)
49FreezeRef
50CopyLoc[0](Arg0: &mut Collection)
51FreezeRef
52MoveLoc[10](loc0: u64)
53Call price_at(&Collection, u64): u64
54CopyLoc[5](Arg5: u64)
55Call unit_price(&Collection, u64, u64): u64
56StLoc[11](loc1: u64)
57MoveLoc[0](Arg0: &mut Collection)
58MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
59MoveLoc[2](Arg2: &mut Kiosk)
60MoveLoc[3](Arg3: &KioskOwnerCap)
61MoveLoc[4](Arg4: Coin<SUI>)
62MoveLoc[5](Arg5: u64)
63MoveLoc[11](loc1: u64)
64MoveLoc[6](Arg6: u64)
65MoveLoc[8](Arg8: &mut RandomGenerator)
66MoveLoc[9](Arg9: &mut TxContext)
67Call bury(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, &mut RandomGenerator, &mut TxContext)
68Ret
}
bury(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: &mut Kiosk, Arg3: &KioskOwnerCap, Arg4: Coin<SUI>, Arg5: u64, Arg6: u64, Arg7: u64, Arg8: &mut RandomGenerator, Arg9: &mut TxContext) {
L10: loc0: bool
L11: loc1: u64
L12: loc2: bool
L13: loc3: u64
L14: loc4: Coin<SUI>
L15: loc5: Mortem
L16: loc6: u64
L17: loc7: ID
L18: loc8: address
L19: loc9: &mut u64
L20: loc10: u64
L21: loc11: u64
L22: loc12: u64
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[0](Collection.mint_open: bool)
2ReadRef
3BrFalse(5)
B1:
4Branch(19)
B2:
5MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
6Pop
7MoveLoc[3](Arg3: &KioskOwnerCap)
8Pop
9MoveLoc[2](Arg2: &mut Kiosk)
10Pop
11MoveLoc[8](Arg8: &mut RandomGenerator)
12Pop
13MoveLoc[9](Arg9: &mut TxContext)
14Pop
15MoveLoc[0](Arg0: &mut Collection)
16Pop
17LdConst[23](u64: 101)
18Abort
B3:
19CopyLoc[1](Arg1: &TransferPolicy<Mortem>)
20Call object::id<TransferPolicy<Mortem>>(&TransferPolicy<Mortem>): ID
21CopyLoc[0](Arg0: &mut Collection)
22ImmBorrowField[2](Collection.policy: ID)
23ReadRef
24Eq
25BrFalse(27)
B4:
26Branch(41)
B5:
27MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
28Pop
29MoveLoc[3](Arg3: &KioskOwnerCap)
30Pop
31MoveLoc[2](Arg2: &mut Kiosk)
32Pop
33MoveLoc[8](Arg8: &mut RandomGenerator)
34Pop
35MoveLoc[9](Arg9: &mut TxContext)
36Pop
37MoveLoc[0](Arg0: &mut Collection)
38Pop
39LdConst[30](u64: 108)
40Abort
B6:
41CopyLoc[5](Arg5: u64)
42LdU64(0)
43Gt
44BrFalse(52)
B7:
45CopyLoc[5](Arg5: u64)
46CopyLoc[0](Arg0: &mut Collection)
47ImmBorrowField[3](Collection.max_per_tx: u64)
48ReadRef
49Le
50StLoc[10](loc0: bool)
51Branch(54)
B8:
52LdFalse
53StLoc[10](loc0: bool)
B9:
54MoveLoc[10](loc0: bool)
55BrFalse(57)
B10:
56Branch(71)
B11:
57MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
58Pop
59MoveLoc[3](Arg3: &KioskOwnerCap)
60Pop
61MoveLoc[2](Arg2: &mut Kiosk)
62Pop
63MoveLoc[8](Arg8: &mut RandomGenerator)
64Pop
65MoveLoc[9](Arg9: &mut TxContext)
66Pop
67MoveLoc[0](Arg0: &mut Collection)
68Pop
69LdConst[26](u64: 104)
70Abort
B12:
71CopyLoc[0](Arg0: &mut Collection)
72ImmBorrowField[4](Collection.minted: u64)
73ReadRef
74CopyLoc[5](Arg5: u64)
75Add
76CopyLoc[0](Arg0: &mut Collection)
77ImmBorrowField[5](Collection.supply: u64)
78ReadRef
79Le
80BrFalse(82)
B13:
81Branch(96)
B14:
82MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
83Pop
84MoveLoc[3](Arg3: &KioskOwnerCap)
85Pop
86MoveLoc[2](Arg2: &mut Kiosk)
87Pop
88MoveLoc[8](Arg8: &mut RandomGenerator)
89Pop
90MoveLoc[9](Arg9: &mut TxContext)
91Pop
92MoveLoc[0](Arg0: &mut Collection)
93Pop
94LdConst[25](u64: 103)
95Abort
B15:
96CopyLoc[9](Arg9: &mut TxContext)
97FreezeRef
98Call tx_context::sender(&TxContext): address
99StLoc[18](loc8: address)
100CopyLoc[0](Arg0: &mut Collection)
101ImmBorrowField[6](Collection.minted_by: Table<address, u64>)
102CopyLoc[18](loc8: address)
103Call table::contains<address, u64>(&Table<address, u64>, address): bool
104BrFalse(112)
B16:
105CopyLoc[0](Arg0: &mut Collection)
106ImmBorrowField[6](Collection.minted_by: Table<address, u64>)
107CopyLoc[18](loc8: address)
108Call table::borrow<address, u64>(&Table<address, u64>, address): &u64
109ReadRef
110StLoc[11](loc1: u64)
111Branch(114)
B17:
112LdU64(0)
113StLoc[11](loc1: u64)
B18:
114MoveLoc[11](loc1: u64)
115StLoc[13](loc3: u64)
116CopyLoc[0](Arg0: &mut Collection)
117ImmBorrowField[7](Collection.max_per_wallet: u64)
118ReadRef
119LdU64(0)
120Eq
121BrFalse(125)
B19:
122LdTrue
123StLoc[12](loc2: bool)
124Branch(133)
B20:
125CopyLoc[13](loc3: u64)
126CopyLoc[5](Arg5: u64)
127Add
128CopyLoc[0](Arg0: &mut Collection)
129ImmBorrowField[7](Collection.max_per_wallet: u64)
130ReadRef
131Le
132StLoc[12](loc2: bool)
B21:
133MoveLoc[12](loc2: bool)
134BrFalse(136)
B22:
135Branch(150)
B23:
136MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
137Pop
138MoveLoc[3](Arg3: &KioskOwnerCap)
139Pop
140MoveLoc[2](Arg2: &mut Kiosk)
141Pop
142MoveLoc[8](Arg8: &mut RandomGenerator)
143Pop
144MoveLoc[9](Arg9: &mut TxContext)
145Pop
146MoveLoc[0](Arg0: &mut Collection)
147Pop
148LdConst[27](u64: 105)
149Abort
B24:
150CopyLoc[6](Arg6: u64)
151MoveLoc[7](Arg7: u64)
152Le
153BrFalse(155)
B25:
154Branch(169)
B26:
155MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
156Pop
157MoveLoc[3](Arg3: &KioskOwnerCap)
158Pop
159MoveLoc[2](Arg2: &mut Kiosk)
160Pop
161MoveLoc[8](Arg8: &mut RandomGenerator)
162Pop
163MoveLoc[9](Arg9: &mut TxContext)
164Pop
165MoveLoc[0](Arg0: &mut Collection)
166Pop
167LdConst[28](u64: 106)
168Abort
B27:
169CopyLoc[6](Arg6: u64)
170CopyLoc[5](Arg5: u64)
171Mul
172StLoc[22](loc12: u64)
173ImmBorrowLoc[4](Arg4: Coin<SUI>)
174Call coin::value<SUI>(&Coin<SUI>): u64
175CopyLoc[22](loc12: u64)
176Ge
177BrFalse(179)
B28:
178Branch(193)
B29:
179MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
180Pop
181MoveLoc[3](Arg3: &KioskOwnerCap)
182Pop
183MoveLoc[2](Arg2: &mut Kiosk)
184Pop
185MoveLoc[8](Arg8: &mut RandomGenerator)
186Pop
187MoveLoc[9](Arg9: &mut TxContext)
188Pop
189MoveLoc[0](Arg0: &mut Collection)
190Pop
191LdConst[29](u64: 107)
192Abort
B30:
193MutBorrowLoc[4](Arg4: Coin<SUI>)
194CopyLoc[22](loc12: u64)
195CopyLoc[9](Arg9: &mut TxContext)
196Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>
197StLoc[14](loc4: Coin<SUI>)
198CopyLoc[0](Arg0: &mut Collection)
199FreezeRef
200MoveLoc[14](loc4: Coin<SUI>)
201CopyLoc[9](Arg9: &mut TxContext)
202Call settle(&Collection, Coin<SUI>, &mut TxContext): u64 * u64
203StLoc[21](loc11: u64)
204StLoc[20](loc10: u64)
205CopyLoc[0](Arg0: &mut Collection)
206FreezeRef
207Call object::id<Collection>(&Collection): ID
208MoveLoc[22](loc12: u64)
209MoveLoc[20](loc10: u64)
210MoveLoc[21](loc11: u64)
211Pack[13](PaymentSplit)
212Call event::emit<PaymentSplit>(PaymentSplit)
213ImmBorrowLoc[4](Arg4: Coin<SUI>)
214Call coin::value<SUI>(&Coin<SUI>): u64
215LdU64(0)
216Gt
217BrFalse(222)
B31:
218MoveLoc[4](Arg4: Coin<SUI>)
219CopyLoc[18](loc8: address)
220Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
221Branch(224)
B32:
222MoveLoc[4](Arg4: Coin<SUI>)
223Call coin::destroy_zero<SUI>(Coin<SUI>)
B33:
224CopyLoc[0](Arg0: &mut Collection)
225ImmBorrowField[6](Collection.minted_by: Table<address, u64>)
226CopyLoc[18](loc8: address)
227Call table::contains<address, u64>(&Table<address, u64>, address): bool
228BrFalse(240)
B34:
229CopyLoc[0](Arg0: &mut Collection)
230MutBorrowField[6](Collection.minted_by: Table<address, u64>)
231CopyLoc[18](loc8: address)
232Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64
233StLoc[19](loc9: &mut u64)
234MoveLoc[13](loc3: u64)
235CopyLoc[5](Arg5: u64)
236Add
237MoveLoc[19](loc9: &mut u64)
238WriteRef
239Branch(245)
B35:
240CopyLoc[0](Arg0: &mut Collection)
241MutBorrowField[6](Collection.minted_by: Table<address, u64>)
242CopyLoc[18](loc8: address)
243CopyLoc[5](Arg5: u64)
244Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
B36:
245CopyLoc[2](Arg2: &mut Kiosk)
246FreezeRef
247Call object::id<Kiosk>(&Kiosk): ID
248StLoc[17](loc7: ID)
249LdU64(0)
250StLoc[16](loc6: u64)
B37:
251CopyLoc[16](loc6: u64)
252CopyLoc[5](Arg5: u64)
253Lt
254BrFalse(273)
B38:
255CopyLoc[0](Arg0: &mut Collection)
256CopyLoc[18](loc8: address)
257CopyLoc[17](loc7: ID)
258CopyLoc[6](Arg6: u64)
259CopyLoc[8](Arg8: &mut RandomGenerator)
260CopyLoc[9](Arg9: &mut TxContext)
261Call forge_grave(&mut Collection, address, ID, u64, &mut RandomGenerator, &mut TxContext): Mortem
262StLoc[15](loc5: Mortem)
263CopyLoc[2](Arg2: &mut Kiosk)
264CopyLoc[3](Arg3: &KioskOwnerCap)
265CopyLoc[1](Arg1: &TransferPolicy<Mortem>)
266MoveLoc[15](loc5: Mortem)
267Call kiosk::lock<Mortem>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<Mortem>, Mortem)
268MoveLoc[16](loc6: u64)
269LdU64(1)
270Add
271StLoc[16](loc6: u64)
272Branch(251)
B39:
273MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
274Pop
275MoveLoc[3](Arg3: &KioskOwnerCap)
276Pop
277MoveLoc[2](Arg2: &mut Kiosk)
278Pop
279MoveLoc[8](Arg8: &mut RandomGenerator)
280Pop
281MoveLoc[9](Arg9: &mut TxContext)
282Pop
283MoveLoc[0](Arg0: &mut Collection)
284Pop
285Ret
}
entry gate_mint_owned_to_new_kiosk<Ty0: store + key>(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: Ty0, Arg3: Coin<SUI>, Arg4: u64, Arg5: u64, Arg6: &Clock, Arg7: &Random, Arg8: &mut TxContext) {
L9: loc0: RandomGenerator
L10: loc1: Kiosk
L11: loc2: KioskOwnerCap
L12: loc3: u64
B0:
0MoveLoc[7](Arg7: &Random)
1CopyLoc[8](Arg8: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[9](loc0: RandomGenerator)
4CopyLoc[0](Arg0: &mut Collection)
5CopyLoc[4](Arg4: u64)
6MoveLoc[6](Arg6: &Clock)
7CopyLoc[8](Arg8: &mut TxContext)
8FreezeRef
9Call enter_gate<Ty0>(&mut Collection, u64, &Clock, &TxContext): u64
10StLoc[12](loc3: u64)
11CopyLoc[8](Arg8: &mut TxContext)
12Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap
13StLoc[11](loc2: KioskOwnerCap)
14StLoc[10](loc1: Kiosk)
15MoveLoc[0](Arg0: &mut Collection)
16MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
17MutBorrowLoc[10](loc1: Kiosk)
18ImmBorrowLoc[11](loc2: KioskOwnerCap)
19MoveLoc[3](Arg3: Coin<SUI>)
20MoveLoc[4](Arg4: u64)
21MoveLoc[12](loc3: u64)
22MoveLoc[5](Arg5: u64)
23MutBorrowLoc[9](loc0: RandomGenerator)
24CopyLoc[8](Arg8: &mut TxContext)
25Call bury(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, &mut RandomGenerator, &mut TxContext)
26MoveLoc[10](loc1: Kiosk)
27Call transfer::public_share_object<Kiosk>(Kiosk)
28MoveLoc[11](loc2: KioskOwnerCap)
29CopyLoc[8](Arg8: &mut TxContext)
30FreezeRef
31Call tx_context::sender(&TxContext): address
32Call transfer::public_transfer<KioskOwnerCap>(KioskOwnerCap, address)
33MoveLoc[2](Arg2: Ty0)
34MoveLoc[8](Arg8: &mut TxContext)
35FreezeRef
36Call tx_context::sender(&TxContext): address
37Call transfer::public_transfer<Ty0>(Ty0, address)
38Ret
}
entry gate_mint_owned_to_kiosk<Ty0: store + key>(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: Ty0, Arg3: &mut Kiosk, Arg4: &KioskOwnerCap, Arg5: Coin<SUI>, Arg6: u64, Arg7: u64, Arg8: &Clock, Arg9: &Random, Arg10: &mut TxContext) {
L11: loc0: RandomGenerator
L12: loc1: u64
B0:
0MoveLoc[9](Arg9: &Random)
1CopyLoc[10](Arg10: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[11](loc0: RandomGenerator)
4CopyLoc[0](Arg0: &mut Collection)
5CopyLoc[6](Arg6: u64)
6MoveLoc[8](Arg8: &Clock)
7CopyLoc[10](Arg10: &mut TxContext)
8FreezeRef
9Call enter_gate<Ty0>(&mut Collection, u64, &Clock, &TxContext): u64
10StLoc[12](loc1: u64)
11MoveLoc[0](Arg0: &mut Collection)
12MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
13MoveLoc[3](Arg3: &mut Kiosk)
14MoveLoc[4](Arg4: &KioskOwnerCap)
15MoveLoc[5](Arg5: Coin<SUI>)
16MoveLoc[6](Arg6: u64)
17MoveLoc[12](loc1: u64)
18MoveLoc[7](Arg7: u64)
19MutBorrowLoc[11](loc0: RandomGenerator)
20CopyLoc[10](Arg10: &mut TxContext)
21Call bury(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, &mut RandomGenerator, &mut TxContext)
22MoveLoc[2](Arg2: Ty0)
23MoveLoc[10](Arg10: &mut TxContext)
24FreezeRef
25Call tx_context::sender(&TxContext): address
26Call transfer::public_transfer<Ty0>(Ty0, address)
27Ret
}
entry gate_mint_owned_to_personal_kiosk<Ty0: store + key>(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: Ty0, Arg3: &mut Kiosk, Arg4: &mut PersonalKioskCap, Arg5: Coin<SUI>, Arg6: u64, Arg7: u64, Arg8: &Clock, Arg9: &Random, Arg10: &mut TxContext) {
L11: loc0: Borrow
L12: loc1: RandomGenerator
L13: loc2: KioskOwnerCap
L14: loc3: u64
B0:
0MoveLoc[9](Arg9: &Random)
1CopyLoc[10](Arg10: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[12](loc1: RandomGenerator)
4CopyLoc[0](Arg0: &mut Collection)
5CopyLoc[6](Arg6: u64)
6MoveLoc[8](Arg8: &Clock)
7CopyLoc[10](Arg10: &mut TxContext)
8FreezeRef
9Call enter_gate<Ty0>(&mut Collection, u64, &Clock, &TxContext): u64
10StLoc[14](loc3: u64)
11CopyLoc[4](Arg4: &mut PersonalKioskCap)
12Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow
13StLoc[11](loc0: Borrow)
14StLoc[13](loc2: KioskOwnerCap)
15MoveLoc[0](Arg0: &mut Collection)
16MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
17MoveLoc[3](Arg3: &mut Kiosk)
18ImmBorrowLoc[13](loc2: KioskOwnerCap)
19MoveLoc[5](Arg5: Coin<SUI>)
20MoveLoc[6](Arg6: u64)
21MoveLoc[14](loc3: u64)
22MoveLoc[7](Arg7: u64)
23MutBorrowLoc[12](loc1: RandomGenerator)
24CopyLoc[10](Arg10: &mut TxContext)
25Call bury(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, &mut RandomGenerator, &mut TxContext)
26MoveLoc[4](Arg4: &mut PersonalKioskCap)
27MoveLoc[13](loc2: KioskOwnerCap)
28MoveLoc[11](loc0: Borrow)
29Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)
30MoveLoc[2](Arg2: Ty0)
31MoveLoc[10](Arg10: &mut TxContext)
32FreezeRef
33Call tx_context::sender(&TxContext): address
34Call transfer::public_transfer<Ty0>(Ty0, address)
35Ret
}
entry gate_mint_in_kiosk<Ty0: store + key>(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: &mut Kiosk, Arg3: KioskOwnerCap, Arg4: ID, Arg5: Coin<SUI>, Arg6: u64, Arg7: u64, Arg8: &Clock, Arg9: &Random, Arg10: &mut TxContext) {
L11: loc0: bool
L12: loc1: RandomGenerator
L13: loc2: u64
B0:
0MoveLoc[9](Arg9: &Random)
1CopyLoc[10](Arg10: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[12](loc1: RandomGenerator)
4CopyLoc[2](Arg2: &mut Kiosk)
5ImmBorrowLoc[3](Arg3: KioskOwnerCap)
6Call kiosk::has_access(&mut Kiosk, &KioskOwnerCap): bool
7BrFalse(14)
B1:
8CopyLoc[2](Arg2: &mut Kiosk)
9FreezeRef
10MoveLoc[4](Arg4: ID)
11Call kiosk::has_item_with_type<Ty0>(&Kiosk, ID): bool
12StLoc[11](loc0: bool)
13Branch(16)
B2:
14LdFalse
15StLoc[11](loc0: bool)
B3:
16MoveLoc[11](loc0: bool)
17BrFalse(19)
B4:
18Branch(31)
B5:
19MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
20Pop
21MoveLoc[2](Arg2: &mut Kiosk)
22Pop
23MoveLoc[10](Arg10: &mut TxContext)
24Pop
25MoveLoc[8](Arg8: &Clock)
26Pop
27MoveLoc[0](Arg0: &mut Collection)
28Pop
29LdConst[46](u64: 124)
30Abort
B6:
31CopyLoc[0](Arg0: &mut Collection)
32CopyLoc[6](Arg6: u64)
33MoveLoc[8](Arg8: &Clock)
34CopyLoc[10](Arg10: &mut TxContext)
35FreezeRef
36Call enter_gate<Ty0>(&mut Collection, u64, &Clock, &TxContext): u64
37StLoc[13](loc2: u64)
38MoveLoc[0](Arg0: &mut Collection)
39MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
40MoveLoc[2](Arg2: &mut Kiosk)
41ImmBorrowLoc[3](Arg3: KioskOwnerCap)
42MoveLoc[5](Arg5: Coin<SUI>)
43MoveLoc[6](Arg6: u64)
44MoveLoc[13](loc2: u64)
45MoveLoc[7](Arg7: u64)
46MutBorrowLoc[12](loc1: RandomGenerator)
47CopyLoc[10](Arg10: &mut TxContext)
48Call bury(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, &mut RandomGenerator, &mut TxContext)
49MoveLoc[3](Arg3: KioskOwnerCap)
50MoveLoc[10](Arg10: &mut TxContext)
51FreezeRef
52Call tx_context::sender(&TxContext): address
53Call transfer::public_transfer<KioskOwnerCap>(KioskOwnerCap, address)
54Ret
}
entry gate_mint_in_personal_kiosk<Ty0: store + key>(Arg0: &mut Collection, Arg1: &TransferPolicy<Mortem>, Arg2: &mut Kiosk, Arg3: &mut PersonalKioskCap, Arg4: ID, Arg5: Coin<SUI>, Arg6: u64, Arg7: u64, Arg8: &Clock, Arg9: &Random, Arg10: &mut TxContext) {
L11: loc0: bool
L12: loc1: Borrow
L13: loc2: RandomGenerator
L14: loc3: KioskOwnerCap
L15: loc4: u64
B0:
0MoveLoc[9](Arg9: &Random)
1CopyLoc[10](Arg10: &mut TxContext)
2Call random::new_generator(&Random, &mut TxContext): RandomGenerator
3StLoc[13](loc2: RandomGenerator)
4CopyLoc[3](Arg3: &mut PersonalKioskCap)
5Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow
6StLoc[12](loc1: Borrow)
7StLoc[14](loc3: KioskOwnerCap)
8CopyLoc[2](Arg2: &mut Kiosk)
9ImmBorrowLoc[14](loc3: KioskOwnerCap)
10Call kiosk::has_access(&mut Kiosk, &KioskOwnerCap): bool
11BrFalse(18)
B1:
12CopyLoc[2](Arg2: &mut Kiosk)
13FreezeRef
14MoveLoc[4](Arg4: ID)
15Call kiosk::has_item_with_type<Ty0>(&Kiosk, ID): bool
16StLoc[11](loc0: bool)
17Branch(20)
B2:
18LdFalse
19StLoc[11](loc0: bool)
B3:
20MoveLoc[11](loc0: bool)
21BrFalse(23)
B4:
22Branch(37)
B5:
23MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
24Pop
25MoveLoc[3](Arg3: &mut PersonalKioskCap)
26Pop
27MoveLoc[2](Arg2: &mut Kiosk)
28Pop
29MoveLoc[10](Arg10: &mut TxContext)
30Pop
31MoveLoc[8](Arg8: &Clock)
32Pop
33MoveLoc[0](Arg0: &mut Collection)
34Pop
35LdConst[46](u64: 124)
36Abort
B6:
37CopyLoc[0](Arg0: &mut Collection)
38CopyLoc[6](Arg6: u64)
39MoveLoc[8](Arg8: &Clock)
40CopyLoc[10](Arg10: &mut TxContext)
41FreezeRef
42Call enter_gate<Ty0>(&mut Collection, u64, &Clock, &TxContext): u64
43StLoc[15](loc4: u64)
44MoveLoc[0](Arg0: &mut Collection)
45MoveLoc[1](Arg1: &TransferPolicy<Mortem>)
46MoveLoc[2](Arg2: &mut Kiosk)
47ImmBorrowLoc[14](loc3: KioskOwnerCap)
48MoveLoc[5](Arg5: Coin<SUI>)
49MoveLoc[6](Arg6: u64)
50MoveLoc[15](loc4: u64)
51MoveLoc[7](Arg7: u64)
52MutBorrowLoc[13](loc2: RandomGenerator)
53MoveLoc[10](Arg10: &mut TxContext)
54Call bury(&mut Collection, &TransferPolicy<Mortem>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, &mut RandomGenerator, &mut TxContext)
55MoveLoc[3](Arg3: &mut PersonalKioskCap)
56MoveLoc[14](loc3: KioskOwnerCap)
57MoveLoc[12](loc1: Borrow)
58Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)
59Ret
}
enter_gate<Ty0>(Arg0: &mut Collection, Arg1: u64, Arg2: &Clock, Arg3: &TxContext): u64 {
L4: loc0: bool
L5: loc1: u64
L6: loc2: bool
L7: loc3: Gate
L8: loc4: GateKey
L9: loc5: TypeName
L10: loc6: &mut u64
L11: loc7: u64
L12: loc8: u64
L13: loc9: address
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2Call check_version(&Collection)
3CopyLoc[0](Arg0: &mut Collection)
4ImmBorrowField[0](Collection.mint_open: bool)
5ReadRef
6BrFalse(8)
B1:
7Branch(16)
B2:
8MoveLoc[3](Arg3: &TxContext)
9Pop
10MoveLoc[2](Arg2: &Clock)
11Pop
12MoveLoc[0](Arg0: &mut Collection)
13Pop
14LdConst[23](u64: 101)
15Abort
B3:
16Call type_name::with_original_ids<Ty0>(): TypeName
17StLoc[9](loc5: TypeName)
18CopyLoc[0](Arg0: &mut Collection)
19ImmBorrowField[8](Collection.gates: Table<TypeName, Gate>)
20CopyLoc[9](loc5: TypeName)
21Call table::contains<TypeName, Gate>(&Table<TypeName, Gate>, TypeName): bool
22BrFalse(24)
B4:
23Branch(32)
B5:
24MoveLoc[3](Arg3: &TxContext)
25Pop
26MoveLoc[2](Arg2: &Clock)
27Pop
28MoveLoc[0](Arg0: &mut Collection)
29Pop
30LdConst[44](u64: 122)
31Abort
B6:
32CopyLoc[0](Arg0: &mut Collection)
33ImmBorrowField[8](Collection.gates: Table<TypeName, Gate>)
34CopyLoc[9](loc5: TypeName)
35Call table::borrow<TypeName, Gate>(&Table<TypeName, Gate>, TypeName): &Gate
36ReadRef
37StLoc[7](loc3: Gate)
38MoveLoc[2](Arg2: &Clock)
39Call clock::timestamp_ms(&Clock): u64
40StLoc[11](loc7: u64)
41ImmBorrowLoc[7](loc3: Gate)
42ImmBorrowField[9](Gate.open: bool)
43ReadRef
44BrFalse(61)
B7:
45CopyLoc[11](loc7: u64)
46ImmBorrowLoc[7](loc3: Gate)
47ImmBorrowField[10](Gate.start_ms: u64)
48ReadRef
49Ge
50BrFalse(58)
B8:
51MoveLoc[11](loc7: u64)
52ImmBorrowLoc[7](loc3: Gate)
53ImmBorrowField[11](Gate.end_ms: u64)
54ReadRef
55Lt
56StLoc[4](loc0: bool)
57Branch(63)
B9:
58LdFalse
59StLoc[4](loc0: bool)
60Branch(63)
B10:
61LdFalse
62StLoc[4](loc0: bool)
B11:
63MoveLoc[4](loc0: bool)
64BrFalse(66)
B12:
65Branch(72)
B13:
66MoveLoc[3](Arg3: &TxContext)
67Pop
68MoveLoc[0](Arg0: &mut Collection)
69Pop
70LdConst[45](u64: 123)
71Abort
B14:
72MoveLoc[3](Arg3: &TxContext)
73Call tx_context::sender(&TxContext): address
74StLoc[13](loc9: address)
75CopyLoc[9](loc5: TypeName)
76CopyLoc[13](loc9: address)
77Pack[6](GateKey)
78StLoc[8](loc4: GateKey)
79CopyLoc[0](Arg0: &mut Collection)
80ImmBorrowField[12](Collection.gate_minted: Table<GateKey, u64>)
81CopyLoc[8](loc4: GateKey)
82Call table::contains<GateKey, u64>(&Table<GateKey, u64>, GateKey): bool
83BrFalse(91)
B15:
84CopyLoc[0](Arg0: &mut Collection)
85ImmBorrowField[12](Collection.gate_minted: Table<GateKey, u64>)
86CopyLoc[8](loc4: GateKey)
87Call table::borrow<GateKey, u64>(&Table<GateKey, u64>, GateKey): &u64
88ReadRef
89StLoc[5](loc1: u64)
90Branch(93)
B16:
91LdU64(0)
92StLoc[5](loc1: u64)
B17:
93MoveLoc[5](loc1: u64)
94StLoc[12](loc8: u64)
95ImmBorrowLoc[7](loc3: Gate)
96ImmBorrowField[13](Gate.max_per_wallet: u64)
97ReadRef
98LdU64(0)
99Eq
100BrFalse(104)
B18:
101LdTrue
102StLoc[6](loc2: bool)
103Branch(112)
B19:
104CopyLoc[12](loc8: u64)
105CopyLoc[1](Arg1: u64)
106Add
107ImmBorrowLoc[7](loc3: Gate)
108ImmBorrowField[13](Gate.max_per_wallet: u64)
109ReadRef
110Le
111StLoc[6](loc2: bool)
B20:
112MoveLoc[6](loc2: bool)
113BrFalse(115)
B21:
114Branch(119)
B22:
115MoveLoc[0](Arg0: &mut Collection)
116Pop
117LdConst[47](u64: 125)
118Abort
B23:
119CopyLoc[0](Arg0: &mut Collection)
120ImmBorrowField[12](Collection.gate_minted: Table<GateKey, u64>)
121CopyLoc[8](loc4: GateKey)
122Call table::contains<GateKey, u64>(&Table<GateKey, u64>, GateKey): bool
123BrFalse(135)
B24:
124CopyLoc[0](Arg0: &mut Collection)
125MutBorrowField[12](Collection.gate_minted: Table<GateKey, u64>)
126MoveLoc[8](loc4: GateKey)
127Call table::borrow_mut<GateKey, u64>(&mut Table<GateKey, u64>, GateKey): &mut u64
128StLoc[10](loc6: &mut u64)
129MoveLoc[12](loc8: u64)
130CopyLoc[1](Arg1: u64)
131Add
132MoveLoc[10](loc6: &mut u64)
133WriteRef
134Branch(140)
B25:
135CopyLoc[0](Arg0: &mut Collection)
136MutBorrowField[12](Collection.gate_minted: Table<GateKey, u64>)
137MoveLoc[8](loc4: GateKey)
138CopyLoc[1](Arg1: u64)
139Call table::add<GateKey, u64>(&mut Table<GateKey, u64>, GateKey, u64)
B26:
140MoveLoc[0](Arg0: &mut Collection)
141FreezeRef
142Call object::id<Collection>(&Collection): ID
143MoveLoc[9](loc5: TypeName)
144MoveLoc[13](loc9: address)
145MoveLoc[1](Arg1: u64)
146ImmBorrowLoc[7](loc3: Gate)
147ImmBorrowField[14](Gate.price: u64)
148ReadRef
149Pack[26](GateUsed)
150Call event::emit<GateUsed>(GateUsed)
151ImmBorrowLoc[7](loc3: Gate)
152ImmBorrowField[14](Gate.price: u64)
153ReadRef
154Ret
}
forge_grave(Arg0: &mut Collection, Arg1: address, Arg2: ID, Arg3: u64, Arg4: &mut RandomGenerator, Arg5: &mut TxContext): Mortem {
L6: loc0: VecMap<String, String>
L7: loc1: UID
L8: loc2: u8
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[4](Collection.minted: u64)
2ReadRef
3CopyLoc[0](Arg0: &mut Collection)
4ImmBorrowField[5](Collection.supply: u64)
5ReadRef
6Lt
7BrFalse(9)
B1:
8Branch(17)
B2:
9MoveLoc[4](Arg4: &mut RandomGenerator)
10Pop
11MoveLoc[5](Arg5: &mut TxContext)
12Pop
13MoveLoc[0](Arg0: &mut Collection)
14Pop
15LdConst[25](u64: 103)
16Abort
B3:
17CopyLoc[0](Arg0: &mut Collection)
18ImmBorrowField[4](Collection.minted: u64)
19ReadRef
20LdU64(1)
21Add
22CopyLoc[0](Arg0: &mut Collection)
23MutBorrowField[4](Collection.minted: u64)
24WriteRef
25MoveLoc[4](Arg4: &mut RandomGenerator)
26CopyLoc[0](Arg0: &mut Collection)
27ImmBorrowField[15](Collection.luck_max: u8)
28ReadRef
29Call draw_luck(&mut RandomGenerator, u8): u8
30StLoc[8](loc2: u8)
31MoveLoc[5](Arg5: &mut TxContext)
32Call object::new(&mut TxContext): UID
33StLoc[7](loc1: UID)
34CopyLoc[0](Arg0: &mut Collection)
35FreezeRef
36Call object::id<Collection>(&Collection): ID
37ImmBorrowLoc[7](loc1: UID)
38Call object::uid_to_inner(&UID): ID
39CopyLoc[0](Arg0: &mut Collection)
40ImmBorrowField[4](Collection.minted: u64)
41ReadRef
42MoveLoc[1](Arg1: address)
43MoveLoc[2](Arg2: ID)
44MoveLoc[3](Arg3: u64)
45CopyLoc[8](loc2: u8)
46Pack[12](GraveMinted)
47Call event::emit<GraveMinted>(GraveMinted)
48Call vec_map::empty<String, String>(): VecMap<String, String>
49StLoc[6](loc0: VecMap<String, String>)
50MutBorrowLoc[6](loc0: VecMap<String, String>)
51LdConst[53](vector<u8>: "Luc..)
52Call string::utf8(vector<u8>): String
53CopyLoc[8](loc2: u8)
54Call luck_label(u8): String
55Call vec_map::insert<String, String>(&mut VecMap<String, String>, String, String)
56MoveLoc[7](loc1: UID)
57MoveLoc[0](Arg0: &mut Collection)
58ImmBorrowField[4](Collection.minted: u64)
59ReadRef
60LdU64(0)
61LdConst[11](vector<u8>: "MOR..)
62Call string::utf8(vector<u8>): String
63MoveLoc[6](loc0: VecMap<String, String>)
64Call vec_map::empty<String, String>(): VecMap<String, String>
65LdU64(0)
66MoveLoc[8](loc2: u8)
67LdConst[52](vector<u8>: "" /..)
68Pack[10](Mortem)
69Ret
}
draw_luck(Arg0: &mut RandomGenerator, Arg1: u8): u8 {
L2: loc0: u8
L3: loc1: u8
L4: loc2: u8
B0:
0CopyLoc[0](Arg0: &mut RandomGenerator)
1LdU8(0)
2CopyLoc[1](Arg1: u8)
3Call random::generate_u8_in_range(&mut RandomGenerator, u8, u8): u8
4StLoc[3](loc1: u8)
5MoveLoc[0](Arg0: &mut RandomGenerator)
6LdU8(0)
7MoveLoc[1](Arg1: u8)
8Call random::generate_u8_in_range(&mut RandomGenerator, u8, u8): u8
9StLoc[4](loc2: u8)
10CopyLoc[3](loc1: u8)
11CopyLoc[4](loc2: u8)
12Lt
13BrFalse(17)
B1:
14MoveLoc[3](loc1: u8)
15StLoc[2](loc0: u8)
16Branch(19)
B2:
17MoveLoc[4](loc2: u8)
18StLoc[2](loc0: u8)
B3:
19MoveLoc[2](loc0: u8)
20Ret
}
luck_label(Arg0: u8): String {
L1: loc0: String
B0:
0MoveLoc[0](Arg0: u8)
1Call u8::to_string(u8): String
2StLoc[1](loc0: String)
3MutBorrowLoc[1](loc0: String)
4LdConst[54](vector<u8>: "%" ..)
5Call string::utf8(vector<u8>): String
6Call string::append(&mut String, String)
7MoveLoc[1](loc0: String)
8Ret
}
settle(Arg0: &Collection, Arg1: Coin<SUI>, Arg2: &mut TxContext): u64 * u64 {
L3: loc0: bool
L4: loc1: u64
L5: loc2: u64
L6: loc3: u64
B0:
0CopyLoc[0](Arg0: &Collection)
1ImmBorrowField[16](Collection.wallet_a: address)
2ReadRef
3LdConst[50](address: 0x00..)
4Neq
5BrFalse(13)
B1:
6CopyLoc[0](Arg0: &Collection)
7ImmBorrowField[17](Collection.wallet_b: address)
8ReadRef
9LdConst[50](address: 0x00..)
10Neq
11StLoc[3](loc0: bool)
12Branch(15)
B2:
13LdFalse
14StLoc[3](loc0: bool)
B3:
15MoveLoc[3](loc0: bool)
16BrFalse(18)
B4:
17Branch(24)
B5:
18MoveLoc[2](Arg2: &mut TxContext)
19Pop
20MoveLoc[0](Arg0: &Collection)
21Pop
22LdConst[34](u64: 112)
23Abort
B6:
24ImmBorrowLoc[1](Arg1: Coin<SUI>)
25Call coin::value<SUI>(&Coin<SUI>): u64
26StLoc[6](loc3: u64)
27CopyLoc[6](loc3: u64)
28CastU128
29LdConst[19](u64: 10000)
30CopyLoc[0](Arg0: &Collection)
31ImmBorrowField[18](Collection.bps_a: u64)
32ReadRef
33Sub
34CastU128
35Mul
36LdConst[19](u64: 10000)
37CastU128
38Div
39CastU64
40StLoc[5](loc2: u64)
41MoveLoc[6](loc3: u64)
42CopyLoc[5](loc2: u64)
43Sub
44StLoc[4](loc1: u64)
45CopyLoc[5](loc2: u64)
46LdU64(0)
47Gt
48BrFalse(58)
B7:
49MutBorrowLoc[1](Arg1: Coin<SUI>)
50CopyLoc[5](loc2: u64)
51MoveLoc[2](Arg2: &mut TxContext)
52Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>
53CopyLoc[0](Arg0: &Collection)
54ImmBorrowField[17](Collection.wallet_b: address)
55ReadRef
56Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
57Branch(60)
B8:
58MoveLoc[2](Arg2: &mut TxContext)
59Pop
B9:
60CopyLoc[4](loc1: u64)
61LdU64(0)
62Gt
63BrFalse(70)
B10:
64MoveLoc[1](Arg1: Coin<SUI>)
65MoveLoc[0](Arg0: &Collection)
66ImmBorrowField[16](Collection.wallet_a: address)
67ReadRef
68Call transfer::public_transfer<Coin<SUI>>(Coin<SUI>, address)
69Branch(74)
B11:
70MoveLoc[0](Arg0: &Collection)
71Pop
72MoveLoc[1](Arg1: Coin<SUI>)
73Call coin::destroy_zero<SUI>(Coin<SUI>)
B12:
74MoveLoc[4](loc1: u64)
75MoveLoc[5](loc2: u64)
76Ret
}
unit_price(Arg0: &Collection, Arg1: u64, Arg2: u64): u64 {
L3: loc0: bool
L4: loc1: u64
L5: loc2: &Pack
L6: loc3: u64
B0:
0MoveLoc[1](Arg1: u64)
1StLoc[6](loc3: u64)
2LdU64(0)
3StLoc[4](loc1: u64)
B1:
4CopyLoc[4](loc1: u64)
5CopyLoc[0](Arg0: &Collection)
6ImmBorrowField[19](Collection.packs: vector<Pack>)
7VecLen(88)
8Lt
9BrFalse(45)
B2:
10Branch(11)
B3:
11CopyLoc[0](Arg0: &Collection)
12ImmBorrowField[19](Collection.packs: vector<Pack>)
13CopyLoc[4](loc1: u64)
14VecImmBorrow(88)
15StLoc[5](loc2: &Pack)
16CopyLoc[2](Arg2: u64)
17CopyLoc[5](loc2: &Pack)
18ImmBorrowField[20](Pack.min_count: u64)
19ReadRef
20Ge
21BrFalse(29)
B4:
22CopyLoc[5](loc2: &Pack)
23ImmBorrowField[21](Pack.max_unit_price: u64)
24ReadRef
25CopyLoc[6](loc3: u64)
26Lt
27StLoc[3](loc0: bool)
28Branch(31)
B5:
29LdFalse
30StLoc[3](loc0: bool)
B6:
31MoveLoc[3](loc0: bool)
32BrFalse(38)
B7:
33MoveLoc[5](loc2: &Pack)
34ImmBorrowField[21](Pack.max_unit_price: u64)
35ReadRef
36StLoc[6](loc3: u64)
37Branch(40)
B8:
38MoveLoc[5](loc2: &Pack)
39Pop
B9:
40MoveLoc[4](loc1: u64)
41LdU64(1)
42Add
43StLoc[4](loc1: u64)
44Branch(4)
B10:
45MoveLoc[0](Arg0: &Collection)
46Pop
47MoveLoc[6](loc3: u64)
48Ret
}
price_at(Arg0: &Collection, Arg1: u64): u64 {
L2: loc0: bool
L3: loc1: u64
L4: loc2: u64
L5: loc3: u64
L6: loc4: &PriceTier
B0:
0CopyLoc[0](Arg0: &Collection)
1ImmBorrowField[22](Collection.tiers: vector<PriceTier>)
2VecLen(85)
3StLoc[4](loc2: u64)
4CopyLoc[4](loc2: u64)
5LdU64(0)
6Gt
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[0](Arg0: &Collection)
10Pop
11LdConst[34](u64: 112)
12Abort
B3:
13LdU64(0)
14StLoc[5](loc3: u64)
15LdFalse
16StLoc[2](loc0: bool)
17LdU64(0)
18StLoc[3](loc1: u64)
B4:
19CopyLoc[3](loc1: u64)
20CopyLoc[4](loc2: u64)
21Lt
22BrFalse(49)
B5:
23CopyLoc[0](Arg0: &Collection)
24ImmBorrowField[22](Collection.tiers: vector<PriceTier>)
25CopyLoc[3](loc1: u64)
26VecImmBorrow(85)
27StLoc[6](loc4: &PriceTier)
28CopyLoc[6](loc4: &PriceTier)
29ImmBorrowField[23](PriceTier.start_ms: u64)
30ReadRef
31CopyLoc[1](Arg1: u64)
32Le
33BrFalse(42)
B6:
34Branch(35)
B7:
35MoveLoc[6](loc4: &PriceTier)
36ImmBorrowField[24](PriceTier.price: u64)
37ReadRef
38StLoc[5](loc3: u64)
39LdTrue
40StLoc[2](loc0: bool)
41Branch(44)
B8:
42MoveLoc[6](loc4: &PriceTier)
43Pop
B9:
44MoveLoc[3](loc1: u64)
45LdU64(1)
46Add
47StLoc[3](loc1: u64)
48Branch(19)
B10:
49MoveLoc[0](Arg0: &Collection)
50Pop
51MoveLoc[2](loc0: bool)
52BrFalse(54)
B11:
53Branch(56)
B12:
54LdConst[24](u64: 102)
55Abort
B13:
56MoveLoc[5](loc3: u64)
57Ret
}
entry distribute(Arg0: &Collection, Arg1: &mut TransferPolicy<Mortem>, Arg2: &mut TxContext) {
L3: loc0: Coin<SUI>
L4: loc1: u64
L5: loc2: u64
L6: loc3: u64
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_version(&Collection)
2CopyLoc[1](Arg1: &mut TransferPolicy<Mortem>)
3FreezeRef
4Call object::id<TransferPolicy<Mortem>>(&TransferPolicy<Mortem>): ID
5CopyLoc[0](Arg0: &Collection)
6ImmBorrowField[2](Collection.policy: ID)
7ReadRef
8Eq
9BrFalse(11)
B1:
10Branch(19)
B2:
11MoveLoc[1](Arg1: &mut TransferPolicy<Mortem>)
12Pop
13MoveLoc[2](Arg2: &mut TxContext)
14Pop
15MoveLoc[0](Arg0: &Collection)
16Pop
17LdConst[30](u64: 108)
18Abort
B3:
19MoveLoc[1](Arg1: &mut TransferPolicy<Mortem>)
20CopyLoc[0](Arg0: &Collection)
21ImmBorrowField[25](Collection.policy_cap: TransferPolicyCap<Mortem>)
22Call option::none<u64>(): Option<u64>
23CopyLoc[2](Arg2: &mut TxContext)
24Call transfer_policy::withdraw<Mortem>(&mut TransferPolicy<Mortem>, &TransferPolicyCap<Mortem>, Option<u64>, &mut TxContext): Coin<SUI>
25StLoc[3](loc0: Coin<SUI>)
26ImmBorrowLoc[3](loc0: Coin<SUI>)
27Call coin::value<SUI>(&Coin<SUI>): u64
28StLoc[6](loc3: u64)
29CopyLoc[6](loc3: u64)
30LdU64(0)
31Gt
32BrFalse(34)
B4:
33Branch(40)
B5:
34MoveLoc[2](Arg2: &mut TxContext)
35Pop
36MoveLoc[0](Arg0: &Collection)
37Pop
38LdConst[39](u64: 117)
39Abort
B6:
40CopyLoc[0](Arg0: &Collection)
41MoveLoc[3](loc0: Coin<SUI>)
42MoveLoc[2](Arg2: &mut TxContext)
43Call settle(&Collection, Coin<SUI>, &mut TxContext): u64 * u64
44StLoc[5](loc2: u64)
45StLoc[4](loc1: u64)
46MoveLoc[0](Arg0: &Collection)
47Call object::id<Collection>(&Collection): ID
48MoveLoc[6](loc3: u64)
49MoveLoc[4](loc1: u64)
50MoveLoc[5](loc2: u64)
51Pack[20](RoyaltiesDistributed)
52Call event::emit<RoyaltiesDistributed>(RoyaltiesDistributed)
53Ret
}
entry set_sale(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: vector<u64>, Arg4: vector<u64>) {
L5: loc0: bool
L6: loc1: bool
L7: loc2: u64
L8: loc3: u64
L9: loc4: vector<PriceTier>
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7ImmBorrowLoc[3](Arg3: vector<u64>)
8VecLen(13)
9StLoc[8](loc3: u64)
10CopyLoc[8](loc3: u64)
11LdU64(0)
12Gt
13BrFalse(20)
B1:
14CopyLoc[8](loc3: u64)
15ImmBorrowLoc[4](Arg4: vector<u64>)
16VecLen(13)
17Eq
18StLoc[5](loc0: bool)
19Branch(22)
B2:
20LdFalse
21StLoc[5](loc0: bool)
B3:
22MoveLoc[5](loc0: bool)
23BrFalse(25)
B4:
24Branch(29)
B5:
25MoveLoc[1](Arg1: &mut Collection)
26Pop
27LdConst[32](u64: 110)
28Abort
B6:
29ImmBorrowLoc[3](Arg3: vector<u64>)
30LdU64(0)
31VecImmBorrow(13)
32ReadRef
33CopyLoc[2](Arg2: u64)
34Eq
35BrFalse(41)
B7:
36CopyLoc[2](Arg2: u64)
37LdConst[20](u64: 1844..)
38Neq
39StLoc[6](loc1: bool)
40Branch(43)
B8:
41LdFalse
42StLoc[6](loc1: bool)
B9:
43MoveLoc[6](loc1: bool)
44BrFalse(46)
B10:
45Branch(50)
B11:
46MoveLoc[1](Arg1: &mut Collection)
47Pop
48LdConst[32](u64: 110)
49Abort
B12:
50VecPack(85, 0)
51StLoc[9](loc4: vector<PriceTier>)
52LdU64(0)
53StLoc[7](loc2: u64)
B13:
54CopyLoc[7](loc2: u64)
55CopyLoc[8](loc3: u64)
56Lt
57BrFalse(107)
B14:
58ImmBorrowLoc[4](Arg4: vector<u64>)
59CopyLoc[7](loc2: u64)
60VecImmBorrow(13)
61ReadRef
62LdU64(0)
63Gt
64BrFalse(66)
B15:
65Branch(70)
B16:
66MoveLoc[1](Arg1: &mut Collection)
67Pop
68LdConst[32](u64: 110)
69Abort
B17:
70CopyLoc[7](loc2: u64)
71LdU64(0)
72Gt
73BrFalse(91)
B18:
74ImmBorrowLoc[3](Arg3: vector<u64>)
75CopyLoc[7](loc2: u64)
76VecImmBorrow(13)
77ReadRef
78ImmBorrowLoc[3](Arg3: vector<u64>)
79CopyLoc[7](loc2: u64)
80LdU64(1)
81Sub
82VecImmBorrow(13)
83ReadRef
84Gt
85BrFalse(87)
B19:
86Branch(91)
B20:
87MoveLoc[1](Arg1: &mut Collection)
88Pop
89LdConst[32](u64: 110)
90Abort
B21:
91MutBorrowLoc[9](loc4: vector<PriceTier>)
92ImmBorrowLoc[3](Arg3: vector<u64>)
93CopyLoc[7](loc2: u64)
94VecImmBorrow(13)
95ReadRef
96ImmBorrowLoc[4](Arg4: vector<u64>)
97CopyLoc[7](loc2: u64)
98VecImmBorrow(13)
99ReadRef
100Pack[4](PriceTier)
101VecPushBack(85)
102MoveLoc[7](loc2: u64)
103LdU64(1)
104Add
105StLoc[7](loc2: u64)
106Branch(54)
B22:
107MoveLoc[9](loc4: vector<PriceTier>)
108CopyLoc[1](Arg1: &mut Collection)
109MutBorrowField[22](Collection.tiers: vector<PriceTier>)
110WriteRef
111CopyLoc[2](Arg2: u64)
112CopyLoc[1](Arg1: &mut Collection)
113MutBorrowField[1](Collection.public_start_ms: u64)
114WriteRef
115CopyLoc[1](Arg1: &mut Collection)
116LdU8(1)
117Call changed(&mut Collection, u8)
118MoveLoc[1](Arg1: &mut Collection)
119FreezeRef
120Call object::id<Collection>(&Collection): ID
121MoveLoc[2](Arg2: u64)
122MoveLoc[3](Arg3: vector<u64>)
123MoveLoc[4](Arg4: vector<u64>)
124Pack[16](SaleSet)
125Call event::emit<SaleSet>(SaleSet)
126Ret
}
entry set_packs(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<u64>, Arg3: vector<u64>) {
L4: loc0: bool
L5: loc1: u64
L6: loc2: u64
L7: loc3: vector<Pack>
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7ImmBorrowLoc[2](Arg2: vector<u64>)
8VecLen(13)
9StLoc[6](loc2: u64)
10CopyLoc[6](loc2: u64)
11ImmBorrowLoc[3](Arg3: vector<u64>)
12VecLen(13)
13Eq
14BrFalse(16)
B1:
15Branch(20)
B2:
16MoveLoc[1](Arg1: &mut Collection)
17Pop
18LdConst[32](u64: 110)
19Abort
B3:
20VecPack(88, 0)
21StLoc[7](loc3: vector<Pack>)
22LdU64(0)
23StLoc[5](loc1: u64)
B4:
24CopyLoc[5](loc1: u64)
25CopyLoc[6](loc2: u64)
26Lt
27BrFalse(102)
B5:
28ImmBorrowLoc[2](Arg2: vector<u64>)
29CopyLoc[5](loc1: u64)
30VecImmBorrow(13)
31ReadRef
32LdU64(1)
33Gt
34BrFalse(56)
B6:
35Branch(36)
B7:
36ImmBorrowLoc[2](Arg2: vector<u64>)
37CopyLoc[5](loc1: u64)
38VecImmBorrow(13)
39ReadRef
40CopyLoc[1](Arg1: &mut Collection)
41ImmBorrowField[3](Collection.max_per_tx: u64)
42ReadRef
43Le
44BrFalse(53)
B8:
45ImmBorrowLoc[3](Arg3: vector<u64>)
46CopyLoc[5](loc1: u64)
47VecImmBorrow(13)
48ReadRef
49LdU64(0)
50Gt
51StLoc[4](loc0: bool)
52Branch(58)
B9:
53LdFalse
54StLoc[4](loc0: bool)
55Branch(58)
B10:
56LdFalse
57StLoc[4](loc0: bool)
B11:
58MoveLoc[4](loc0: bool)
59BrFalse(61)
B12:
60Branch(65)
B13:
61MoveLoc[1](Arg1: &mut Collection)
62Pop
63LdConst[32](u64: 110)
64Abort
B14:
65CopyLoc[5](loc1: u64)
66LdU64(0)
67Gt
68BrFalse(86)
B15:
69ImmBorrowLoc[2](Arg2: vector<u64>)
70CopyLoc[5](loc1: u64)
71VecImmBorrow(13)
72ReadRef
73ImmBorrowLoc[2](Arg2: vector<u64>)
74CopyLoc[5](loc1: u64)
75LdU64(1)
76Sub
77VecImmBorrow(13)
78ReadRef
79Gt
80BrFalse(82)
B16:
81Branch(86)
B17:
82MoveLoc[1](Arg1: &mut Collection)
83Pop
84LdConst[32](u64: 110)
85Abort
B18:
86MutBorrowLoc[7](loc3: vector<Pack>)
87ImmBorrowLoc[2](Arg2: vector<u64>)
88CopyLoc[5](loc1: u64)
89VecImmBorrow(13)
90ReadRef
91ImmBorrowLoc[3](Arg3: vector<u64>)
92CopyLoc[5](loc1: u64)
93VecImmBorrow(13)
94ReadRef
95Pack[7](Pack)
96VecPushBack(88)
97MoveLoc[5](loc1: u64)
98LdU64(1)
99Add
100StLoc[5](loc1: u64)
101Branch(24)
B19:
102MoveLoc[7](loc3: vector<Pack>)
103CopyLoc[1](Arg1: &mut Collection)
104MutBorrowField[19](Collection.packs: vector<Pack>)
105WriteRef
106CopyLoc[1](Arg1: &mut Collection)
107LdU8(11)
108Call changed(&mut Collection, u8)
109MoveLoc[1](Arg1: &mut Collection)
110FreezeRef
111Call object::id<Collection>(&Collection): ID
112MoveLoc[2](Arg2: vector<u64>)
113MoveLoc[3](Arg3: vector<u64>)
114Pack[25](PacksSet)
115Call event::emit<PacksSet>(PacksSet)
116Ret
}
entry set_limits(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: u64) {
L4: loc0: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[2](Arg2: u64)
8LdU64(0)
9Gt
10BrFalse(16)
B1:
11CopyLoc[2](Arg2: u64)
12LdConst[17](u64: 50)
13Le
14StLoc[4](loc0: bool)
15Branch(18)
B2:
16LdFalse
17StLoc[4](loc0: bool)
B3:
18MoveLoc[4](loc0: bool)
19BrFalse(21)
B4:
20Branch(25)
B5:
21MoveLoc[1](Arg1: &mut Collection)
22Pop
23LdConst[41](u64: 119)
24Abort
B6:
25CopyLoc[2](Arg2: u64)
26CopyLoc[1](Arg1: &mut Collection)
27MutBorrowField[3](Collection.max_per_tx: u64)
28WriteRef
29CopyLoc[3](Arg3: u64)
30CopyLoc[1](Arg1: &mut Collection)
31MutBorrowField[7](Collection.max_per_wallet: u64)
32WriteRef
33CopyLoc[1](Arg1: &mut Collection)
34LdU8(2)
35Call changed(&mut Collection, u8)
36MoveLoc[1](Arg1: &mut Collection)
37FreezeRef
38Call object::id<Collection>(&Collection): ID
39MoveLoc[2](Arg2: u64)
40MoveLoc[3](Arg3: u64)
41Pack[17](LimitsSet)
42Call event::emit<LimitsSet>(LimitsSet)
43Ret
}
entry set_split(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: address, Arg3: address, Arg4: u64) {
L5: loc0: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[2](Arg2: address)
8LdConst[50](address: 0x00..)
9Neq
10BrFalse(23)
B1:
11CopyLoc[3](Arg3: address)
12LdConst[50](address: 0x00..)
13Neq
14BrFalse(20)
B2:
15CopyLoc[4](Arg4: u64)
16LdConst[19](u64: 10000)
17Le
18StLoc[5](loc0: bool)
19Branch(25)
B3:
20LdFalse
21StLoc[5](loc0: bool)
22Branch(25)
B4:
23LdFalse
24StLoc[5](loc0: bool)
B5:
25MoveLoc[5](loc0: bool)
26BrFalse(28)
B6:
27Branch(32)
B7:
28MoveLoc[1](Arg1: &mut Collection)
29Pop
30LdConst[33](u64: 111)
31Abort
B8:
32CopyLoc[2](Arg2: address)
33CopyLoc[1](Arg1: &mut Collection)
34MutBorrowField[16](Collection.wallet_a: address)
35WriteRef
36CopyLoc[3](Arg3: address)
37CopyLoc[1](Arg1: &mut Collection)
38MutBorrowField[17](Collection.wallet_b: address)
39WriteRef
40CopyLoc[4](Arg4: u64)
41CopyLoc[1](Arg1: &mut Collection)
42MutBorrowField[18](Collection.bps_a: u64)
43WriteRef
44CopyLoc[1](Arg1: &mut Collection)
45LdU8(3)
46Call changed(&mut Collection, u8)
47MoveLoc[1](Arg1: &mut Collection)
48FreezeRef
49Call object::id<Collection>(&Collection): ID
50MoveLoc[2](Arg2: address)
51MoveLoc[3](Arg3: address)
52MoveLoc[4](Arg4: u64)
53Pack[18](SplitSet)
54Call event::emit<SplitSet>(SplitSet)
55Ret
}
entry set_royalty(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut TransferPolicy<Mortem>, Arg3: u16, Arg4: u64) {
L5: loc0: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[2](Arg2: &mut TransferPolicy<Mortem>)
8FreezeRef
9Call object::id<TransferPolicy<Mortem>>(&TransferPolicy<Mortem>): ID
10CopyLoc[1](Arg1: &mut Collection)
11ImmBorrowField[2](Collection.policy: ID)
12ReadRef
13Eq
14BrFalse(16)
B1:
15Branch(22)
B2:
16MoveLoc[2](Arg2: &mut TransferPolicy<Mortem>)
17Pop
18MoveLoc[1](Arg1: &mut Collection)
19Pop
20LdConst[30](u64: 108)
21Abort
B3:
22CopyLoc[3](Arg3: u16)
23LdU16(0)
24Gt
25BrFalse(31)
B4:
26CopyLoc[3](Arg3: u16)
27LdConst[18](u16: 1000)
28Le
29StLoc[5](loc0: bool)
30Branch(33)
B5:
31LdFalse
32StLoc[5](loc0: bool)
B6:
33MoveLoc[5](loc0: bool)
34BrFalse(36)
B7:
35Branch(42)
B8:
36MoveLoc[2](Arg2: &mut TransferPolicy<Mortem>)
37Pop
38MoveLoc[1](Arg1: &mut Collection)
39Pop
40LdConst[35](u64: 113)
41Abort
B9:
42CopyLoc[2](Arg2: &mut TransferPolicy<Mortem>)
43CopyLoc[1](Arg1: &mut Collection)
44ImmBorrowField[25](Collection.policy_cap: TransferPolicyCap<Mortem>)
45Call transfer_policy::remove_rule<Mortem, Rule, Config>(&mut TransferPolicy<Mortem>, &TransferPolicyCap<Mortem>)
46MoveLoc[2](Arg2: &mut TransferPolicy<Mortem>)
47CopyLoc[1](Arg1: &mut Collection)
48ImmBorrowField[25](Collection.policy_cap: TransferPolicyCap<Mortem>)
49CopyLoc[3](Arg3: u16)
50CopyLoc[4](Arg4: u64)
51Call royalty_rule::add<Mortem>(&mut TransferPolicy<Mortem>, &TransferPolicyCap<Mortem>, u16, u64)
52CopyLoc[1](Arg1: &mut Collection)
53LdU8(4)
54Call changed(&mut Collection, u8)
55MoveLoc[1](Arg1: &mut Collection)
56FreezeRef
57Call object::id<Collection>(&Collection): ID
58MoveLoc[3](Arg3: u16)
59MoveLoc[4](Arg4: u64)
60Pack[19](RoyaltySet)
61Call event::emit<RoyaltySet>(RoyaltySet)
62Ret
}
entry configure_media(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut Display<Mortem>, Arg3: String) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8FreezeRef
9Call has_display_v2(&Collection): bool
10Not
11BrFalse(13)
B1:
12Branch(19)
B2:
13MoveLoc[2](Arg2: &mut Display<Mortem>)
14Pop
15MoveLoc[1](Arg1: &mut Collection)
16Pop
17LdConst[36](u64: 114)
18Abort
B3:
19MoveLoc[1](Arg1: &mut Collection)
20MoveLoc[2](Arg2: &mut Display<Mortem>)
21MoveLoc[3](Arg3: String)
22Call configure_media_internal(&mut Collection, &mut Display<Mortem>, String)
23Ret
}
entry configure_media_and_sync(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut Display<Mortem>, Arg3: &mut Display<Mortem>, Arg4: String) {
L5: loc0: String
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8FreezeRef
9Call has_display_v2(&Collection): bool
10BrFalse(12)
B1:
11Branch(20)
B2:
12MoveLoc[3](Arg3: &mut Display<Mortem>)
13Pop
14MoveLoc[2](Arg2: &mut Display<Mortem>)
15Pop
16MoveLoc[1](Arg1: &mut Collection)
17Pop
18LdConst[36](u64: 114)
19Abort
B3:
20CopyLoc[1](Arg1: &mut Collection)
21CopyLoc[2](Arg2: &mut Display<Mortem>)
22MoveLoc[4](Arg4: String)
23Call configure_media_internal(&mut Collection, &mut Display<Mortem>, String)
24CopyLoc[1](Arg1: &mut Collection)
25ImmBorrowField[26](Collection.media_base: String)
26ReadRef
27LdConst[7](vector<u8>: "tok..)
28Call media_url(String, vector<u8>): String
29StLoc[5](loc0: String)
30MoveLoc[1](Arg1: &mut Collection)
31FreezeRef
32MoveLoc[2](Arg2: &mut Display<Mortem>)
33FreezeRef
34MoveLoc[3](Arg3: &mut Display<Mortem>)
35MoveLoc[5](loc0: String)
36Call option::some<String>(String): Option<String>
37Call rebuild_v2(&Collection, &Display<Mortem>, &mut Display<Mortem>, Option<String>)
38Ret
}
entry create_display_v2(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut DisplayRegistry, Arg3: &Display<Mortem>, Arg4: &mut TxContext) {
L5: loc0: ID
L6: loc1: DisplayCap<Mortem>
L7: loc2: u64
L8: loc3: vector<String>
L9: loc4: Display<Mortem>
L10: loc5: vector<String>
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[2](Arg2: &mut DisplayRegistry)
8FreezeRef
9Call object::id<DisplayRegistry>(&DisplayRegistry): ID
10StLoc[5](loc0: ID)
11ImmBorrowLoc[5](loc0: ID)
12Call object::id_to_address(&ID): address
13LdConst[55](address: 0x00..)
14Eq
15BrFalse(17)
B1:
16Branch(27)
B2:
17MoveLoc[3](Arg3: &Display<Mortem>)
18Pop
19MoveLoc[2](Arg2: &mut DisplayRegistry)
20Pop
21MoveLoc[4](Arg4: &mut TxContext)
22Pop
23MoveLoc[1](Arg1: &mut Collection)
24Pop
25LdConst[37](u64: 115)
26Abort
B3:
27CopyLoc[1](Arg1: &mut Collection)
28FreezeRef
29Call has_display_v2(&Collection): bool
30Not
31BrFalse(33)
B4:
32Branch(43)
B5:
33MoveLoc[3](Arg3: &Display<Mortem>)
34Pop
35MoveLoc[2](Arg2: &mut DisplayRegistry)
36Pop
37MoveLoc[4](Arg4: &mut TxContext)
38Pop
39MoveLoc[1](Arg1: &mut Collection)
40Pop
41LdConst[37](u64: 115)
42Abort
B6:
43CopyLoc[3](Arg3: &Display<Mortem>)
44Call object::id<Display<Mortem>>(&Display<Mortem>): ID
45CopyLoc[1](Arg1: &mut Collection)
46ImmBorrowField[27](Collection.display: ID)
47ReadRef
48Eq
49BrFalse(51)
B7:
50Branch(61)
B8:
51MoveLoc[3](Arg3: &Display<Mortem>)
52Pop
53MoveLoc[2](Arg2: &mut DisplayRegistry)
54Pop
55MoveLoc[4](Arg4: &mut TxContext)
56Pop
57MoveLoc[1](Arg1: &mut Collection)
58Pop
59LdConst[38](u64: 116)
60Abort
B9:
61CopyLoc[1](Arg1: &mut Collection)
62FreezeRef
63Call media_ready(&Collection): bool
64BrFalse(66)
B10:
65Branch(76)
B11:
66MoveLoc[3](Arg3: &Display<Mortem>)
67Pop
68MoveLoc[2](Arg2: &mut DisplayRegistry)
69Pop
70MoveLoc[4](Arg4: &mut TxContext)
71Pop
72MoveLoc[1](Arg1: &mut Collection)
73Pop
74LdConst[34](u64: 112)
75Abort
B12:
76MoveLoc[2](Arg2: &mut DisplayRegistry)
77Call internal::permit<Mortem>(): Permit<Mortem>
78MoveLoc[4](Arg4: &mut TxContext)
79Call display_registry::new<Mortem>(&mut DisplayRegistry, Permit<Mortem>, &mut TxContext): Display<Mortem> * DisplayCap<Mortem>
80StLoc[6](loc1: DisplayCap<Mortem>)
81StLoc[9](loc4: Display<Mortem>)
82MoveLoc[3](Arg3: &Display<Mortem>)
83MutBorrowLoc[9](loc4: Display<Mortem>)
84ImmBorrowLoc[6](loc1: DisplayCap<Mortem>)
85Call copy_v1(&Display<Mortem>, &mut Display<Mortem>, &DisplayCap<Mortem>)
86CopyLoc[1](Arg1: &mut Collection)
87FreezeRef
88Call v2_extras(&Collection): vector<String> * vector<String>
89StLoc[10](loc5: vector<String>)
90StLoc[8](loc3: vector<String>)
91LdU64(0)
92StLoc[7](loc2: u64)
B13:
93CopyLoc[7](loc2: u64)
94ImmBorrowLoc[8](loc3: vector<String>)
95VecLen(18)
96Lt
97BrFalse(114)
B14:
98MutBorrowLoc[9](loc4: Display<Mortem>)
99ImmBorrowLoc[6](loc1: DisplayCap<Mortem>)
100ImmBorrowLoc[8](loc3: vector<String>)
101CopyLoc[7](loc2: u64)
102VecImmBorrow(18)
103ReadRef
104ImmBorrowLoc[10](loc5: vector<String>)
105CopyLoc[7](loc2: u64)
106VecImmBorrow(18)
107ReadRef
108Call display_registry::set<Mortem>(&mut Display<Mortem>, &DisplayCap<Mortem>, String, String)
109MoveLoc[7](loc2: u64)
110LdU64(1)
111Add
112StLoc[7](loc2: u64)
113Branch(93)
B15:
114MoveLoc[9](loc4: Display<Mortem>)
115Call display_registry::share<Mortem>(Display<Mortem>)
116CopyLoc[1](Arg1: &mut Collection)
117MutBorrowField[28](Collection.id: UID)
118LdFalse
119Pack[3](DisplayCapKey)
120MoveLoc[6](loc1: DisplayCap<Mortem>)
121Call dynamic_field::add<DisplayCapKey, DisplayCap<Mortem>>(&mut UID, DisplayCapKey, DisplayCap<Mortem>)
122MoveLoc[1](Arg1: &mut Collection)
123LdU8(6)
124Call changed(&mut Collection, u8)
125Ret
}
entry sync_display_v2(Arg0: &AdminCap, Arg1: &Collection, Arg2: &Display<Mortem>, Arg3: &mut Display<Mortem>) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &Collection)
2Call assert_admin(&AdminCap, &Collection)
3CopyLoc[1](Arg1: &Collection)
4Call check_version(&Collection)
5MoveLoc[1](Arg1: &Collection)
6MoveLoc[2](Arg2: &Display<Mortem>)
7MoveLoc[3](Arg3: &mut Display<Mortem>)
8Call option::none<String>(): Option<String>
9Call rebuild_v2(&Collection, &Display<Mortem>, &mut Display<Mortem>, Option<String>)
10Ret
}
entry set_gate<Ty0: key>(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: bool) {
L7: loc0: bool
L8: loc1: &mut Gate
L9: loc2: Gate
L10: loc3: TypeName
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[2](Arg2: u64)
8LdU64(0)
9Gt
10BrFalse(16)
B1:
11CopyLoc[3](Arg3: u64)
12CopyLoc[4](Arg4: u64)
13Lt
14StLoc[7](loc0: bool)
15Branch(18)
B2:
16LdFalse
17StLoc[7](loc0: bool)
B3:
18MoveLoc[7](loc0: bool)
19BrFalse(21)
B4:
20Branch(25)
B5:
21MoveLoc[1](Arg1: &mut Collection)
22Pop
23LdConst[48](u64: 126)
24Abort
B6:
25Call type_name::with_original_ids<Ty0>(): TypeName
26StLoc[10](loc3: TypeName)
27CopyLoc[2](Arg2: u64)
28CopyLoc[3](Arg3: u64)
29CopyLoc[4](Arg4: u64)
30CopyLoc[5](Arg5: u64)
31CopyLoc[6](Arg6: bool)
32Pack[5](Gate)
33StLoc[9](loc2: Gate)
34CopyLoc[1](Arg1: &mut Collection)
35ImmBorrowField[8](Collection.gates: Table<TypeName, Gate>)
36CopyLoc[10](loc3: TypeName)
37Call table::contains<TypeName, Gate>(&Table<TypeName, Gate>, TypeName): bool
38BrFalse(48)
B7:
39CopyLoc[1](Arg1: &mut Collection)
40MutBorrowField[8](Collection.gates: Table<TypeName, Gate>)
41CopyLoc[10](loc3: TypeName)
42Call table::borrow_mut<TypeName, Gate>(&mut Table<TypeName, Gate>, TypeName): &mut Gate
43StLoc[8](loc1: &mut Gate)
44MoveLoc[9](loc2: Gate)
45MoveLoc[8](loc1: &mut Gate)
46WriteRef
47Branch(53)
B8:
48CopyLoc[1](Arg1: &mut Collection)
49MutBorrowField[8](Collection.gates: Table<TypeName, Gate>)
50CopyLoc[10](loc3: TypeName)
51MoveLoc[9](loc2: Gate)
52Call table::add<TypeName, Gate>(&mut Table<TypeName, Gate>, TypeName, Gate)
B9:
53CopyLoc[1](Arg1: &mut Collection)
54LdU8(10)
55Call changed(&mut Collection, u8)
56MoveLoc[1](Arg1: &mut Collection)
57FreezeRef
58Call object::id<Collection>(&Collection): ID
59MoveLoc[10](loc3: TypeName)
60MoveLoc[2](Arg2: u64)
61MoveLoc[3](Arg3: u64)
62MoveLoc[4](Arg4: u64)
63MoveLoc[5](Arg5: u64)
64MoveLoc[6](Arg6: bool)
65Pack[24](GateSet)
66Call event::emit<GateSet>(GateSet)
67Ret
}
entry set_luck_max(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u8) {
L3: loc0: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8ImmBorrowField[0](Collection.mint_open: bool)
9ReadRef
10Not
11BrFalse(17)
B1:
12CopyLoc[2](Arg2: u8)
13LdConst[14](u8: 50)
14Le
15StLoc[3](loc0: bool)
16Branch(19)
B2:
17LdFalse
18StLoc[3](loc0: bool)
B3:
19MoveLoc[3](loc0: bool)
20BrFalse(22)
B4:
21Branch(26)
B5:
22MoveLoc[1](Arg1: &mut Collection)
23Pop
24LdConst[43](u64: 121)
25Abort
B6:
26CopyLoc[2](Arg2: u8)
27CopyLoc[1](Arg1: &mut Collection)
28MutBorrowField[15](Collection.luck_max: u8)
29WriteRef
30CopyLoc[1](Arg1: &mut Collection)
31LdU8(9)
32Call changed(&mut Collection, u8)
33MoveLoc[1](Arg1: &mut Collection)
34FreezeRef
35Call object::id<Collection>(&Collection): ID
36MoveLoc[2](Arg2: u8)
37Pack[23](LuckMaxSet)
38Call event::emit<LuckMaxSet>(LuckMaxSet)
39Ret
}
entry set_reveal_start(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[2](Arg2: u64)
8CopyLoc[1](Arg1: &mut Collection)
9MutBorrowField[29](Collection.rising: Rising)
10MutBorrowField[30](Rising.reveal_start_ms: u64)
11WriteRef
12CopyLoc[1](Arg1: &mut Collection)
13LdU8(7)
14Call changed(&mut Collection, u8)
15MoveLoc[1](Arg1: &mut Collection)
16FreezeRef
17Call object::id<Collection>(&Collection): ID
18MoveLoc[2](Arg2: u64)
19Pack[22](RevealStartSet)
20Call event::emit<RevealStartSet>(RevealStartSet)
21Ret
}
entry set_mint_open(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: bool) {
L3: loc0: bool
L4: loc1: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_version(&Collection)
7CopyLoc[2](Arg2: bool)
8BrFalse(96)
B1:
9CopyLoc[1](Arg1: &mut Collection)
10ImmBorrowField[16](Collection.wallet_a: address)
11ReadRef
12LdConst[50](address: 0x00..)
13Neq
14BrFalse(31)
B2:
15CopyLoc[1](Arg1: &mut Collection)
16ImmBorrowField[17](Collection.wallet_b: address)
17ReadRef
18LdConst[50](address: 0x00..)
19Neq
20BrFalse(28)
B3:
21CopyLoc[1](Arg1: &mut Collection)
22ImmBorrowField[18](Collection.bps_a: u64)
23ReadRef
24LdConst[19](u64: 10000)
25Le
26StLoc[3](loc0: bool)
27Branch(33)
B4:
28LdFalse
29StLoc[3](loc0: bool)
30Branch(33)
B5:
31LdFalse
32StLoc[3](loc0: bool)
B6:
33MoveLoc[3](loc0: bool)
34BrFalse(36)
B7:
35Branch(40)
B8:
36MoveLoc[1](Arg1: &mut Collection)
37Pop
38LdConst[34](u64: 112)
39Abort
B9:
40CopyLoc[1](Arg1: &mut Collection)
41ImmBorrowField[22](Collection.tiers: vector<PriceTier>)
42VecLen(85)
43LdU64(0)
44Gt
45BrFalse(53)
B10:
46CopyLoc[1](Arg1: &mut Collection)
47ImmBorrowField[1](Collection.public_start_ms: u64)
48ReadRef
49LdConst[20](u64: 1844..)
50Neq
51StLoc[4](loc1: bool)
52Branch(55)
B11:
53LdFalse
54StLoc[4](loc1: bool)
B12:
55MoveLoc[4](loc1: bool)
56BrFalse(58)
B13:
57Branch(62)
B14:
58MoveLoc[1](Arg1: &mut Collection)
59Pop
60LdConst[32](u64: 110)
61Abort
B15:
62CopyLoc[1](Arg1: &mut Collection)
63ImmBorrowField[22](Collection.tiers: vector<PriceTier>)
64LdU64(0)
65VecImmBorrow(85)
66ImmBorrowField[23](PriceTier.start_ms: u64)
67ReadRef
68CopyLoc[1](Arg1: &mut Collection)
69ImmBorrowField[1](Collection.public_start_ms: u64)
70ReadRef
71Eq
72BrFalse(74)
B16:
73Branch(78)
B17:
74MoveLoc[1](Arg1: &mut Collection)
75Pop
76LdConst[32](u64: 110)
77Abort
B18:
78CopyLoc[1](Arg1: &mut Collection)
79FreezeRef
80Call media_ready(&Collection): bool
81BrFalse(83)
B19:
82Branch(87)
B20:
83MoveLoc[1](Arg1: &mut Collection)
84Pop
85LdConst[42](u64: 120)
86Abort
B21:
87CopyLoc[1](Arg1: &mut Collection)
88FreezeRef
89Call has_display_v2(&Collection): bool
90BrFalse(92)
B22:
91Branch(96)
B23:
92MoveLoc[1](Arg1: &mut Collection)
93Pop
94LdConst[36](u64: 114)
95Abort
B24:
96CopyLoc[2](Arg2: bool)
97CopyLoc[1](Arg1: &mut Collection)
98MutBorrowField[0](Collection.mint_open: bool)
99WriteRef
100CopyLoc[1](Arg1: &mut Collection)
101LdU8(8)
102Call changed(&mut Collection, u8)
103MoveLoc[1](Arg1: &mut Collection)
104FreezeRef
105Call object::id<Collection>(&Collection): ID
106MoveLoc[2](Arg2: bool)
107Pack[15](MintOpenSet)
108Call event::emit<MintOpenSet>(MintOpenSet)
109Ret
}
entry transfer_admin(Arg0: AdminCap, Arg1: address) {
B0:
0ImmBorrowLoc[0](Arg0: AdminCap)
1ImmBorrowField[31](AdminCap.collection: ID)
2ReadRef
3CopyLoc[1](Arg1: address)
4Pack[27](AdminTransferred)
5Call event::emit<AdminTransferred>(AdminTransferred)
6MoveLoc[0](Arg0: AdminCap)
7MoveLoc[1](Arg1: address)
8Call transfer::transfer<AdminCap>(AdminCap, address)
9Ret
}
entry migrate(Arg0: &AdminCap, Arg1: &mut Collection) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5ImmBorrowField[32](Collection.version: u64)
6ReadRef
7LdConst[21](u64: 1)
8Lt
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[1](Arg1: &mut Collection)
12Pop
13LdConst[40](u64: 118)
14Abort
B3:
15CopyLoc[1](Arg1: &mut Collection)
16FreezeRef
17Call object::id<Collection>(&Collection): ID
18CopyLoc[1](Arg1: &mut Collection)
19ImmBorrowField[32](Collection.version: u64)
20ReadRef
21LdConst[21](u64: 1)
22Pack[28](Migrated)
23Call event::emit<Migrated>(Migrated)
24LdConst[21](u64: 1)
25MoveLoc[1](Arg1: &mut Collection)
26MutBorrowField[32](Collection.version: u64)
27WriteRef
28Ret
}
public(friend) grave_uid(Arg0: &Mortem): &UID {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[33](Mortem.id: UID)
2Ret
}
public(friend) grave_uid_mut(Arg0: &mut Mortem): &mut UID {
B0:
0MoveLoc[0](Arg0: &mut Mortem)
1MutBorrowField[33](Mortem.id: UID)
2Ret
}
public(friend) collection_uid(Arg0: &Collection): &UID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[28](Collection.id: UID)
2Ret
}
public(friend) collection_uid_mut(Arg0: &mut Collection): &mut UID {
B0:
0MoveLoc[0](Arg0: &mut Collection)
1MutBorrowField[28](Collection.id: UID)
2Ret
}
public(friend) check_admin(Arg0: &AdminCap, Arg1: &Collection) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &Collection)
2Call assert_admin(&AdminCap, &Collection)
3MoveLoc[1](Arg1: &Collection)
4Call check_version(&Collection)
5Ret
}
public(friend) check_current(Arg0: &Collection) {
B0:
0MoveLoc[0](Arg0: &Collection)
1Call check_version(&Collection)
2Ret
}
public(friend) rising_state(Arg0: &Collection): bool * u64 * u64 * u64 * bool {
L1: loc0: &Rising
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[29](Collection.rising: Rising)
2StLoc[1](loc0: &Rising)
3CopyLoc[1](loc0: &Rising)
4ImmBorrowField[34](Rising.reveal_open: bool)
5ReadRef
6CopyLoc[1](loc0: &Rising)
7ImmBorrowField[30](Rising.reveal_start_ms: u64)
8ReadRef
9CopyLoc[1](loc0: &Rising)
10ImmBorrowField[35](Rising.seeded: u64)
11ReadRef
12CopyLoc[1](loc0: &Rising)
13ImmBorrowField[36](Rising.drawn: u64)
14ReadRef
15MoveLoc[1](loc0: &Rising)
16ImmBorrowField[37](Rising.seeding_sealed: bool)
17ReadRef
18Ret
}
public(friend) running_hash(Arg0: &Collection): vector<u8> {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[29](Collection.rising: Rising)
2ImmBorrowField[38](Rising.running_hash: vector<u8>)
3ReadRef
4Ret
}
public(friend) pool_mut(Arg0: &mut Collection): &mut vector<u16> {
B0:
0MoveLoc[0](Arg0: &mut Collection)
1MutBorrowField[29](Collection.rising: Rising)
2MutBorrowField[39](Rising.pool: vector<u16>)
3Ret
}
public(friend) record_seeds(Arg0: &mut Collection, Arg1: vector<u16>, Arg2: vector<u8>) {
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[29](Collection.rising: Rising)
2ImmBorrowField[35](Rising.seeded: u64)
3ReadRef
4ImmBorrowLoc[1](Arg1: vector<u16>)
5VecLen(174)
6Add
7CopyLoc[0](Arg0: &mut Collection)
8MutBorrowField[29](Collection.rising: Rising)
9MutBorrowField[35](Rising.seeded: u64)
10WriteRef
11CopyLoc[0](Arg0: &mut Collection)
12MutBorrowField[29](Collection.rising: Rising)
13MutBorrowField[39](Rising.pool: vector<u16>)
14MoveLoc[1](Arg1: vector<u16>)
15Call vector::append<u16>(&mut vector<u16>, vector<u16>)
16MoveLoc[2](Arg2: vector<u8>)
17MoveLoc[0](Arg0: &mut Collection)
18MutBorrowField[29](Collection.rising: Rising)
19MutBorrowField[38](Rising.running_hash: vector<u8>)
20WriteRef
21Ret
}
public(friend) seal_seeding(Arg0: &mut Collection, Arg1: vector<u8>, Arg2: String) {
B0:
0MoveLoc[1](Arg1: vector<u8>)
1CopyLoc[0](Arg0: &mut Collection)
2MutBorrowField[29](Collection.rising: Rising)
3MutBorrowField[40](Rising.provenance_hash: vector<u8>)
4WriteRef
5MoveLoc[2](Arg2: String)
6CopyLoc[0](Arg0: &mut Collection)
7MutBorrowField[29](Collection.rising: Rising)
8MutBorrowField[41](Rising.provenance_scheme: String)
9WriteRef
10LdTrue
11CopyLoc[0](Arg0: &mut Collection)
12MutBorrowField[29](Collection.rising: Rising)
13MutBorrowField[37](Rising.seeding_sealed: bool)
14WriteRef
15LdTrue
16CopyLoc[0](Arg0: &mut Collection)
17MutBorrowField[29](Collection.rising: Rising)
18MutBorrowField[34](Rising.reveal_open: bool)
19WriteRef
20MoveLoc[0](Arg0: &mut Collection)
21LdU8(12)
22Call changed(&mut Collection, u8)
23Ret
}
public(friend) set_reveal_open(Arg0: &mut Collection, Arg1: bool) {
B0:
0MoveLoc[1](Arg1: bool)
1CopyLoc[0](Arg0: &mut Collection)
2MutBorrowField[29](Collection.rising: Rising)
3MutBorrowField[34](Rising.reveal_open: bool)
4WriteRef
5MoveLoc[0](Arg0: &mut Collection)
6LdU8(13)
7Call changed(&mut Collection, u8)
8Ret
}
public(friend) move_reveal_start(Arg0: &mut Collection, Arg1: u64) {
B0:
0CopyLoc[1](Arg1: u64)
1CopyLoc[0](Arg0: &mut Collection)
2MutBorrowField[29](Collection.rising: Rising)
3MutBorrowField[30](Rising.reveal_start_ms: u64)
4WriteRef
5CopyLoc[0](Arg0: &mut Collection)
6LdU8(7)
7Call changed(&mut Collection, u8)
8MoveLoc[0](Arg0: &mut Collection)
9FreezeRef
10Call object::id<Collection>(&Collection): ID
11MoveLoc[1](Arg1: u64)
12Pack[22](RevealStartSet)
13Call event::emit<RevealStartSet>(RevealStartSet)
14Ret
}
public(friend) count_drawn(Arg0: &mut Collection) {
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[29](Collection.rising: Rising)
2ImmBorrowField[36](Rising.drawn: u64)
3ReadRef
4LdU64(1)
5Add
6MoveLoc[0](Arg0: &mut Collection)
7MutBorrowField[29](Collection.rising: Rising)
8MutBorrowField[36](Rising.drawn: u64)
9WriteRef
10Ret
}
public(friend) grave_number(Arg0: &Mortem): u64 {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[42](Mortem.number: u64)
2ReadRef
3Ret
}
public(friend) grave_luck(Arg0: &Mortem): u8 {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[43](Mortem.luck: u8)
2ReadRef
3Ret
}
public(friend) grave_metadata_version(Arg0: &Mortem): u64 {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[44](Mortem.metadata_version: u64)
2ReadRef
3Ret
}
public(friend) grave_attributes(Arg0: &Mortem): &VecMap<String, String> {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[45](Mortem.attributes: VecMap<String, String>)
2Ret
}
public(friend) raise_grave(Arg0: &mut Mortem, Arg1: u64, Arg2: String, Arg3: VecMap<String, String>, Arg4: vector<u8>) {
B0:
0MoveLoc[1](Arg1: u64)
1CopyLoc[0](Arg0: &mut Mortem)
2MutBorrowField[46](Mortem.index: u64)
3WriteRef
4MoveLoc[2](Arg2: String)
5CopyLoc[0](Arg0: &mut Mortem)
6MutBorrowField[47](Mortem.name: String)
7WriteRef
8MoveLoc[3](Arg3: VecMap<String, String>)
9CopyLoc[0](Arg0: &mut Mortem)
10MutBorrowField[45](Mortem.attributes: VecMap<String, String>)
11WriteRef
12MoveLoc[4](Arg4: vector<u8>)
13CopyLoc[0](Arg0: &mut Mortem)
14MutBorrowField[48](Mortem.pad: vector<u8>)
15WriteRef
16LdU64(1)
17MoveLoc[0](Arg0: &mut Mortem)
18MutBorrowField[44](Mortem.metadata_version: u64)
19WriteRef
20Ret
}
v1_keys(): vector<String> {
B0:
0LdConst[56](vector<u8>: "nam..)
1Call string::utf8(vector<u8>): String
2LdConst[57](vector<u8>: "des..)
3Call string::utf8(vector<u8>): String
4LdConst[58](vector<u8>: "ima..)
5Call string::utf8(vector<u8>): String
6LdConst[59](vector<u8>: "thu..)
7Call string::utf8(vector<u8>): String
8LdConst[60](vector<u8>: "pro..)
9Call string::utf8(vector<u8>): String
10LdConst[61](vector<u8>: "cre..)
11Call string::utf8(vector<u8>): String
12LdConst[62](vector<u8>: "num..)
13Call string::utf8(vector<u8>): String
14VecPack(18, 7)
15Ret
}
v2_extras(Arg0: &Collection): vector<String> * vector<String> {
L1: loc0: ID
L2: loc1: &mut String
L3: loc2: String
B0:
0LdConst[63](vector<u8>: "0x"..)
1Call string::utf8(vector<u8>): String
2StLoc[3](loc2: String)
3MutBorrowLoc[3](loc2: String)
4StLoc[2](loc1: &mut String)
5CopyLoc[0](Arg0: &Collection)
6Call object::id<Collection>(&Collection): ID
7StLoc[1](loc0: ID)
8MoveLoc[2](loc1: &mut String)
9ImmBorrowLoc[1](loc0: ID)
10Call object::id_to_address(&ID): address
11Call address::to_string(address): String
12Call string::append(&mut String, String)
13LdConst[64](vector<u8>: "att..)
14Call string::utf8(vector<u8>): String
15LdConst[65](vector<u8>: "ind..)
16Call string::utf8(vector<u8>): String
17LdConst[66](vector<u8>: "col..)
18Call string::utf8(vector<u8>): String
19LdConst[67](vector<u8>: "col..)
20Call string::utf8(vector<u8>): String
21LdConst[68](vector<u8>: "col..)
22Call string::utf8(vector<u8>): String
23LdConst[69](vector<u8>: "col..)
24Call string::utf8(vector<u8>): String
25VecPack(18, 6)
26LdConst[70](vector<u8>: "{at..)
27Call string::utf8(vector<u8>): String
28LdConst[71](vector<u8>: "{in..)
29Call string::utf8(vector<u8>): String
30LdConst[0](vector<u8>: "MOR..)
31Call string::utf8(vector<u8>): String
32LdConst[1](vector<u8>: "666..)
33Call string::utf8(vector<u8>): String
34MoveLoc[0](Arg0: &Collection)
35ImmBorrowField[26](Collection.media_base: String)
36ReadRef
37LdConst[7](vector<u8>: "tok..)
38Call media_url(String, vector<u8>): String
39MoveLoc[3](loc2: String)
40VecPack(18, 6)
41Ret
}
media_url(Arg0: String, Arg1: vector<u8>): String {
L2: loc0: String
B0:
0MoveLoc[0](Arg0: String)
1StLoc[2](loc0: String)
2MutBorrowLoc[2](loc0: String)
3MoveLoc[1](Arg1: vector<u8>)
4Call string::utf8(vector<u8>): String
5Call string::append(&mut String, String)
6MoveLoc[2](loc0: String)
7Ret
}
configure_media_internal(Arg0: &mut Collection, Arg1: &mut Display<Mortem>, Arg2: String) {
L3: loc0: String
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[49](Collection.media_frozen: bool)
2ReadRef
3Not
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[1](Arg1: &mut Display<Mortem>)
7Pop
8MoveLoc[0](Arg0: &mut Collection)
9Pop
10LdConst[42](u64: 120)
11Abort
B3:
12CopyLoc[1](Arg1: &mut Display<Mortem>)
13FreezeRef
14Call object::id<Display<Mortem>>(&Display<Mortem>): ID
15CopyLoc[0](Arg0: &mut Collection)
16ImmBorrowField[27](Collection.display: ID)
17ReadRef
18Eq
19BrFalse(21)
B4:
20Branch(27)
B5:
21MoveLoc[1](Arg1: &mut Display<Mortem>)
22Pop
23MoveLoc[0](Arg0: &mut Collection)
24Pop
25LdConst[38](u64: 116)
26Abort
B6:
27ImmBorrowLoc[2](Arg2: String)
28Call valid_base(&String): bool
29BrFalse(31)
B7:
30Branch(37)
B8:
31MoveLoc[1](Arg1: &mut Display<Mortem>)
32Pop
33MoveLoc[0](Arg0: &mut Collection)
34Pop
35LdConst[42](u64: 120)
36Abort
B9:
37CopyLoc[2](Arg2: String)
38LdConst[6](vector<u8>: "tok..)
39Call media_url(String, vector<u8>): String
40StLoc[3](loc0: String)
41CopyLoc[1](Arg1: &mut Display<Mortem>)
42LdConst[58](vector<u8>: "ima..)
43Call string::utf8(vector<u8>): String
44CopyLoc[3](loc0: String)
45Call display::edit<Mortem>(&mut Display<Mortem>, String, String)
46CopyLoc[1](Arg1: &mut Display<Mortem>)
47LdConst[59](vector<u8>: "thu..)
48Call string::utf8(vector<u8>): String
49MoveLoc[3](loc0: String)
50Call display::edit<Mortem>(&mut Display<Mortem>, String, String)
51MoveLoc[1](Arg1: &mut Display<Mortem>)
52Call display::update_version<Mortem>(&mut Display<Mortem>)
53CopyLoc[2](Arg2: String)
54CopyLoc[0](Arg0: &mut Collection)
55MutBorrowField[26](Collection.media_base: String)
56WriteRef
57CopyLoc[0](Arg0: &mut Collection)
58LdU8(5)
59Call changed(&mut Collection, u8)
60MoveLoc[0](Arg0: &mut Collection)
61FreezeRef
62Call object::id<Collection>(&Collection): ID
63MoveLoc[2](Arg2: String)
64Pack[21](MediaConfigured)
65Call event::emit<MediaConfigured>(MediaConfigured)
66Ret
}
valid_base(Arg0: &String): bool {
L1: loc0: bool
L2: loc1: String
L3: loc2: &String
L4: loc3: &vector<u8>
L5: loc4: u64
L6: loc5: vector<u8>
B0:
0CopyLoc[0](Arg0: &String)
1Call string::as_bytes(&String): &vector<u8>
2StLoc[4](loc3: &vector<u8>)
3LdConst[72](vector<u8>: "htt..)
4StLoc[6](loc5: vector<u8>)
5CopyLoc[4](loc3: &vector<u8>)
6VecLen(17)
7ImmBorrowLoc[6](loc5: vector<u8>)
8VecLen(17)
9LdU64(1)
10Add
11Le
12BrFalse(16)
B1:
13LdTrue
14StLoc[1](loc0: bool)
15Branch(26)
B2:
16CopyLoc[4](loc3: &vector<u8>)
17CopyLoc[4](loc3: &vector<u8>)
18VecLen(17)
19LdU64(1)
20Sub
21VecImmBorrow(17)
22ReadRef
23LdU8(47)
24Neq
25StLoc[1](loc0: bool)
B3:
26MoveLoc[1](loc0: bool)
27BrFalse(34)
B4:
28MoveLoc[4](loc3: &vector<u8>)
29Pop
30MoveLoc[0](Arg0: &String)
31Pop
32LdFalse
33Ret
B5:
34LdU64(0)
35StLoc[5](loc4: u64)
B6:
36CopyLoc[5](loc4: u64)
37ImmBorrowLoc[6](loc5: vector<u8>)
38VecLen(17)
39Lt
40BrFalse(63)
B7:
41CopyLoc[4](loc3: &vector<u8>)
42CopyLoc[5](loc4: u64)
43VecImmBorrow(17)
44ReadRef
45ImmBorrowLoc[6](loc5: vector<u8>)
46CopyLoc[5](loc4: u64)
47VecImmBorrow(17)
48ReadRef
49Neq
50BrFalse(58)
B8:
51Branch(52)
B9:
52MoveLoc[4](loc3: &vector<u8>)
53Pop
54MoveLoc[0](Arg0: &String)
55Pop
56LdFalse
57Ret
B10:
58MoveLoc[5](loc4: u64)
59LdU64(1)
60Add
61StLoc[5](loc4: u64)
62Branch(36)
B11:
63MoveLoc[0](Arg0: &String)
64StLoc[3](loc2: &String)
65LdConst[73](vector<u8>: ".in..)
66Call string::utf8(vector<u8>): String
67StLoc[2](loc1: String)
68MoveLoc[3](loc2: &String)
69ImmBorrowLoc[2](loc1: String)
70Call string::index_of(&String, &String): u64
71MoveLoc[4](loc3: &vector<u8>)
72VecLen(17)
73Eq
74Ret
}
media_ready(Arg0: &Collection): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[26](Collection.media_base: String)
2Call valid_base(&String): bool
3Ret
}
copy_v1(Arg0: &Display<Mortem>, Arg1: &mut Display<Mortem>, Arg2: &DisplayCap<Mortem>) {
L3: loc0: &VecMap<String, String>
L4: loc1: u64
L5: loc2: &String
L6: loc3: &String
B0:
0MoveLoc[0](Arg0: &Display<Mortem>)
1Call display::fields<Mortem>(&Display<Mortem>): &VecMap<String, String>
2StLoc[3](loc0: &VecMap<String, String>)
3LdU64(0)
4StLoc[4](loc1: u64)
B1:
5CopyLoc[4](loc1: u64)
6CopyLoc[3](loc0: &VecMap<String, String>)
7Call vec_map::length<String, String>(&VecMap<String, String>): u64
8Lt
9BrFalse(28)
B2:
10Branch(11)
B3:
11CopyLoc[3](loc0: &VecMap<String, String>)
12CopyLoc[4](loc1: u64)
13Call vec_map::get_entry_by_idx<String, String>(&VecMap<String, String>, u64): &String * &String
14StLoc[6](loc3: &String)
15StLoc[5](loc2: &String)
16CopyLoc[1](Arg1: &mut Display<Mortem>)
17CopyLoc[2](Arg2: &DisplayCap<Mortem>)
18MoveLoc[5](loc2: &String)
19ReadRef
20MoveLoc[6](loc3: &String)
21ReadRef
22Call display_registry::set<Mortem>(&mut Display<Mortem>, &DisplayCap<Mortem>, String, String)
23MoveLoc[4](loc1: u64)
24LdU64(1)
25Add
26StLoc[4](loc1: u64)
27Branch(5)
B4:
28MoveLoc[1](Arg1: &mut Display<Mortem>)
29Pop
30MoveLoc[3](loc0: &VecMap<String, String>)
31Pop
32MoveLoc[2](Arg2: &DisplayCap<Mortem>)
33Pop
34Ret
}
rebuild_v2(Arg0: &Collection, Arg1: &Display<Mortem>, Arg2: &mut Display<Mortem>, Arg3: Option<String>) {
L4: loc0: bool
L5: loc1: String
L6: loc2: &DisplayCap<Mortem>
L7: loc3: String
L8: loc4: u64
L9: loc5: &String
L10: loc6: VecMap<String, String>
L11: loc7: String
L12: loc8: &String
B0:
0CopyLoc[1](Arg1: &Display<Mortem>)
1Call object::id<Display<Mortem>>(&Display<Mortem>): ID
2CopyLoc[0](Arg0: &Collection)
3ImmBorrowField[27](Collection.display: ID)
4ReadRef
5Eq
6BrFalse(8)
B1:
7Branch(16)
B2:
8MoveLoc[2](Arg2: &mut Display<Mortem>)
9Pop
10MoveLoc[1](Arg1: &Display<Mortem>)
11Pop
12MoveLoc[0](Arg0: &Collection)
13Pop
14LdConst[38](u64: 116)
15Abort
B3:
16CopyLoc[0](Arg0: &Collection)
17Call has_display_v2(&Collection): bool
18BrFalse(20)
B4:
19Branch(28)
B5:
20MoveLoc[2](Arg2: &mut Display<Mortem>)
21Pop
22MoveLoc[1](Arg1: &Display<Mortem>)
23Pop
24MoveLoc[0](Arg0: &Collection)
25Pop
26LdConst[36](u64: 114)
27Abort
B6:
28MoveLoc[0](Arg0: &Collection)
29ImmBorrowField[28](Collection.id: UID)
30LdFalse
31Pack[3](DisplayCapKey)
32Call dynamic_field::borrow<DisplayCapKey, DisplayCap<Mortem>>(&UID, DisplayCapKey): &DisplayCap<Mortem>
33StLoc[6](loc2: &DisplayCap<Mortem>)
34CopyLoc[2](Arg2: &mut Display<Mortem>)
35FreezeRef
36Call display_registry::cap_id<Mortem>(&Display<Mortem>): Option<ID>
37CopyLoc[6](loc2: &DisplayCap<Mortem>)
38Call object::id<DisplayCap<Mortem>>(&DisplayCap<Mortem>): ID
39Call option::some<ID>(ID): Option<ID>
40Eq
41BrFalse(43)
B7:
42Branch(51)
B8:
43MoveLoc[2](Arg2: &mut Display<Mortem>)
44Pop
45MoveLoc[1](Arg1: &Display<Mortem>)
46Pop
47MoveLoc[6](loc2: &DisplayCap<Mortem>)
48Pop
49LdConst[37](u64: 115)
50Abort
B9:
51CopyLoc[2](Arg2: &mut Display<Mortem>)
52FreezeRef
53Call display_registry::fields<Mortem>(&Display<Mortem>): &VecMap<String, String>
54ReadRef
55StLoc[10](loc6: VecMap<String, String>)
56CopyLoc[1](Arg1: &Display<Mortem>)
57CopyLoc[2](Arg2: &mut Display<Mortem>)
58CopyLoc[6](loc2: &DisplayCap<Mortem>)
59Call copy_v1(&Display<Mortem>, &mut Display<Mortem>, &DisplayCap<Mortem>)
60LdConst[68](vector<u8>: "col..)
61Call string::utf8(vector<u8>): String
62StLoc[7](loc3: String)
63LdU64(0)
64StLoc[8](loc4: u64)
B10:
65CopyLoc[8](loc4: u64)
66ImmBorrowLoc[10](loc6: VecMap<String, String>)
67Call vec_map::length<String, String>(&VecMap<String, String>): u64
68Lt
69BrFalse(122)
B11:
70ImmBorrowLoc[10](loc6: VecMap<String, String>)
71CopyLoc[8](loc4: u64)
72Call vec_map::get_entry_by_idx<String, String>(&VecMap<String, String>, u64): &String * &String
73StLoc[12](loc8: &String)
74StLoc[9](loc5: &String)
75CopyLoc[1](Arg1: &Display<Mortem>)
76Call display::fields<Mortem>(&Display<Mortem>): &VecMap<String, String>
77CopyLoc[9](loc5: &String)
78Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
79Not
80BrFalse(113)
B12:
81CopyLoc[9](loc5: &String)
82ReadRef
83CopyLoc[7](loc3: String)
84Eq
85BrFalse(90)
B13:
86ImmBorrowLoc[3](Arg3: Option<String>)
87Call option::is_some<String>(&Option<String>): bool
88StLoc[4](loc0: bool)
89Branch(92)
B14:
90LdFalse
91StLoc[4](loc0: bool)
B15:
92MoveLoc[4](loc0: bool)
93BrFalse(101)
B16:
94MoveLoc[12](loc8: &String)
95Pop
96ImmBorrowLoc[3](Arg3: Option<String>)
97Call option::borrow<String>(&Option<String>): &String
98ReadRef
99StLoc[5](loc1: String)
100Branch(104)
B17:
101MoveLoc[12](loc8: &String)
102ReadRef
103StLoc[5](loc1: String)
B18:
104MoveLoc[5](loc1: String)
105StLoc[11](loc7: String)
106CopyLoc[2](Arg2: &mut Display<Mortem>)
107CopyLoc[6](loc2: &DisplayCap<Mortem>)
108MoveLoc[9](loc5: &String)
109ReadRef
110MoveLoc[11](loc7: String)
111Call display_registry::set<Mortem>(&mut Display<Mortem>, &DisplayCap<Mortem>, String, String)
112Branch(117)
B19:
113MoveLoc[12](loc8: &String)
114Pop
115MoveLoc[9](loc5: &String)
116Pop
B20:
117MoveLoc[8](loc4: u64)
118LdU64(1)
119Add
120StLoc[8](loc4: u64)
121Branch(65)
B21:
122MoveLoc[2](Arg2: &mut Display<Mortem>)
123Pop
124MoveLoc[1](Arg1: &Display<Mortem>)
125Pop
126MoveLoc[6](loc2: &DisplayCap<Mortem>)
127Pop
128Ret
}
assert_admin(Arg0: &AdminCap, Arg1: &Collection) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1ImmBorrowField[31](AdminCap.collection: ID)
2ReadRef
3MoveLoc[1](Arg1: &Collection)
4Call object::id<Collection>(&Collection): ID
5Eq
6BrFalse(8)
B1:
7Branch(10)
B2:
8LdConst[31](u64: 109)
9Abort
B3:
10Ret
}
check_version(Arg0: &Collection) {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[32](Collection.version: u64)
2ReadRef
3LdConst[21](u64: 1)
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[22](u64: 100)
8Abort
B3:
9Ret
}
changed(Arg0: &mut Collection, Arg1: u8) {
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[50](Collection.revision: u64)
2ReadRef
3LdU64(1)
4Add
5CopyLoc[0](Arg0: &mut Collection)
6MutBorrowField[50](Collection.revision: u64)
7WriteRef
8CopyLoc[0](Arg0: &mut Collection)
9FreezeRef
10Call object::id<Collection>(&Collection): ID
11MoveLoc[0](Arg0: &mut Collection)
12ImmBorrowField[50](Collection.revision: u64)
13ReadRef
14MoveLoc[1](Arg1: u8)
15Pack[14](ConfigUpdated)
16Call event::emit<ConfigUpdated>(ConfigUpdated)
17Ret
}
public supply(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[5](Collection.supply: u64)
2ReadRef
3Ret
}
public minted(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[4](Collection.minted: u64)
2ReadRef
3Ret
}
public mint_open(Arg0: &Collection): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[0](Collection.mint_open: bool)
2ReadRef
3Ret
}
public public_start_ms(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[1](Collection.public_start_ms: u64)
2ReadRef
3Ret
}
public price_now(Arg0: &Collection, Arg1: &Clock): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1MoveLoc[1](Arg1: &Clock)
2Call clock::timestamp_ms(&Clock): u64
3Call price_at(&Collection, u64): u64
4Ret
}
public price_for(Arg0: &Collection, Arg1: &Clock, Arg2: u64): u64 {
B0:
0CopyLoc[0](Arg0: &Collection)
1MoveLoc[0](Arg0: &Collection)
2MoveLoc[1](Arg1: &Clock)
3Call clock::timestamp_ms(&Clock): u64
4Call price_at(&Collection, u64): u64
5MoveLoc[2](Arg2: u64)
6Call unit_price(&Collection, u64, u64): u64
7Ret
}
public minted_by(Arg0: &Collection, Arg1: address): u64 {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: &Collection)
1ImmBorrowField[6](Collection.minted_by: Table<address, u64>)
2CopyLoc[1](Arg1: address)
3Call table::contains<address, u64>(&Table<address, u64>, address): bool
4BrFalse(12)
B1:
5MoveLoc[0](Arg0: &Collection)
6ImmBorrowField[6](Collection.minted_by: Table<address, u64>)
7MoveLoc[1](Arg1: address)
8Call table::borrow<address, u64>(&Table<address, u64>, address): &u64
9ReadRef
10StLoc[2](loc0: u64)
11Branch(16)
B2:
12MoveLoc[0](Arg0: &Collection)
13Pop
14LdU64(0)
15StLoc[2](loc0: u64)
B3:
16MoveLoc[2](loc0: u64)
17Ret
}
public has_display_v2(Arg0: &Collection): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[28](Collection.id: UID)
2LdFalse
3Pack[3](DisplayCapKey)
4Call dynamic_field::exists<DisplayCapKey>(&UID, DisplayCapKey): bool
5Ret
}
public grave_number_of(Arg0: &Mortem): u64 {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[42](Mortem.number: u64)
2ReadRef
3Ret
}
public grave_index_of(Arg0: &Mortem): u64 {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[46](Mortem.index: u64)
2ReadRef
3Ret
}
public grave_luck_of(Arg0: &Mortem): u8 {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[43](Mortem.luck: u8)
2ReadRef
3Ret
}
public is_risen(Arg0: &Mortem): bool {
B0:
0MoveLoc[0](Arg0: &Mortem)
1ImmBorrowField[44](Mortem.metadata_version: u64)
2ReadRef
3LdU64(1)
4Ge
5Ret
}
Constants [
0 => vector<u8>: "MORTEM" // interpreted as UTF8 string
1 => vector<u8>: "666 graves on Sui. You don't buy a skull, you buy a grave: on the night of the Rising every stone cracks open and gives back a hand-drawn pixel skull by PulseSinister." // interpreted as UTF8 string
2 => u64: 666
3 => u16: 300
4 => u64: 50000000
5 => vector<u8>: "https://media.mortem.invalid/" // interpreted as UTF8 string
6 => vector<u8>: "tokens/{index}.webp" // interpreted as UTF8 string
7 => vector<u8>: "tokens/0.webp" // interpreted as UTF8 string
8 => vector<u8>: "https://mortem.alienz.tech/" // interpreted as UTF8 string
9 => vector<u8>: "PulseSinister & Sudcero" // interpreted as UTF8 string
10 => vector<u8>: "{name} #{number}" // interpreted as UTF8 string
11 => vector<u8>: "MORTEM Grave" // interpreted as UTF8 string
12 => vector<u8>: "A sealed MORTEM grave. Something waits under the stone. On the night of the Rising it cracks open and gives back a hand-drawn pixel skull; the luck carved on it may call a rarer one." // interpreted as UTF8 string
13 => u8: 13
14 => u8: 50
15 => u64: 10
16 => u64: 5
17 => u64: 50
18 => u16: 1000
19 => u64: 10000
20 => u64: 18446744073709551615
21 => u64: 1
22 => u64: 100
23 => u64: 101
24 => u64: 102
25 => u64: 103
26 => u64: 104
27 => u64: 105
28 => u64: 106
29 => u64: 107
30 => u64: 108
31 => u64: 109
32 => u64: 110
33 => u64: 111
34 => u64: 112
35 => u64: 113
36 => u64: 114
37 => u64: 115
38 => u64: 116
39 => u64: 117
40 => u64: 118
41 => u64: 119
42 => u64: 120
43 => u64: 121
44 => u64: 122
45 => u64: 123
46 => u64: 124
47 => u64: 125
48 => u64: 126
49 => vector<u8>: "{number}" // interpreted as UTF8 string
50 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
51 => vector<u16>: 00
52 => vector<u8>: "" // interpreted as UTF8 string
53 => vector<u8>: "Luck" // interpreted as UTF8 string
54 => vector<u8>: "%" // interpreted as UTF8 string
55 => address: 0x000000000000000000000000000000000000000000000000000000000000000d
56 => vector<u8>: "name" // interpreted as UTF8 string
57 => vector<u8>: "description" // interpreted as UTF8 string
58 => vector<u8>: "image_url" // interpreted as UTF8 string
59 => vector<u8>: "thumbnail_url" // interpreted as UTF8 string
60 => vector<u8>: "project_url" // interpreted as UTF8 string
61 => vector<u8>: "creator" // interpreted as UTF8 string
62 => vector<u8>: "number" // interpreted as UTF8 string
63 => vector<u8>: "0x" // interpreted as UTF8 string
64 => vector<u8>: "attributes" // interpreted as UTF8 string
65 => vector<u8>: "index" // interpreted as UTF8 string
66 => vector<u8>: "collection_name" // interpreted as UTF8 string
67 => vector<u8>: "collection_description" // interpreted as UTF8 string
68 => vector<u8>: "collection_cover_url" // interpreted as UTF8 string
69 => vector<u8>: "collection_id" // interpreted as UTF8 string
70 => vector<u8>: "{attributes:json}" // interpreted as UTF8 string
71 => vector<u8>: "{index}" // interpreted as UTF8 string
72 => vector<u8>: "https://" // interpreted as UTF8 string
73 => vector<u8>: ".invalid" // interpreted as UTF8 string
]
}