collection
Module0xa124…24ca
- Move path
- 0xee47…c7fe::collection
- Functions
- 170113 public, 11 entry
- Structs
- 41
- Friend modules
- None
collection
Bytecode9534 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module ee4752a0e4e8d236aecfc3e0dec4d5c69dd92cfe7ecc49631adb4938cb21c7fe.collection {
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::config;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool;
use 1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::position;
use ee4752a0e4e8d236aecfc3e0dec4d5c69dd92cfe7ecc49631adb4938cb21c7fe::legacy;
use ee4752a0e4e8d236aecfc3e0dec4d5c69dd92cfe7ecc49631adb4938cb21c7fe::terms;
use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::kiosk_lock_rule;
use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::personal_kiosk;
use 434b5bd8f6a7b05fede0ff46c6e511d71ea326ed38056e3bcd681d2d7c2a7879::royalty_rule;
use 12d73de9a6bc3cb658ec9dc0fe7de2662be1cea5c76c092fcc3606048cdbac27::lp_burn;
use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
use 0000000000000000000000000000000000000000000000000000000000000001::internal;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::address;
use 0000000000000000000000000000000000000000000000000000000000000002::balance;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::coin;
use 0000000000000000000000000000000000000000000000000000000000000002::display;
use 0000000000000000000000000000000000000000000000000000000000000002::display_registry;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_object_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;
use 0000000000000000000000000000000000000000000000000000000000000002::versioned;
use 0000000000000000000000000000000000000000000000000000000000000003::staking_pool;
use 0000000000000000000000000000000000000000000000000000000000000003::sui_system;
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 LegacyStateKey has copy, drop, store {
dummy_field: bool
}
struct ConfigKey has copy, drop, store {
dummy_field: bool
}
struct PositionPoolKey has copy, drop, store {
position: u64
}
struct SeedCap has key {
id: UID,
collection: ID
}
struct ItemData has store {
attributes: VecMap<String, String>,
filler: VecMap<String, String>,
pad: vector<u8>
}
struct Collection has key {
id: UID,
config: ID,
version: u64,
name: String,
supply: u64,
minted: u64,
burned: u64,
price: u64,
stake_amount: u64,
lp_amount: u64,
fee_wallet: address,
royalty_wallet: address,
validator: address,
swap_pool: ID,
lp_pool: ID,
vault: ID,
policy: ID,
graveyard: ID,
graveyard_cap: KioskOwnerCap,
policy_cap: TransferPolicyCap<KingFizh>,
mint_open: bool,
holder_start_ms: u64,
public_start_ms: u64,
min_holder_balance: u64,
registry: Table<u64, ItemData>,
seeded: u64,
pool: vector<u16>,
drawn: u64,
reservations: Table<u64, address>,
reserved_total: u64,
moved: Table<u64, u64>,
items: Table<u64, ID>
}
struct Vault<phantom Ty0> has key {
id: UID,
version: u64,
collection: ID,
proofs: Table<u64, CetusLPBurnProof>,
positions: u64,
live: u64,
pot_a: Balance<Ty0>,
pot_b: Balance<SUI>,
acc_a: u128,
acc_b: u128,
sweep_fee_bps: u64,
sweep_open: bool,
swept_a: u64,
swept_b: u64,
paid_a: u64,
paid_b: u64
}
struct KingFizh has store, key {
id: UID,
number: u64,
index: u64,
attributes: VecMap<String, String>,
filler: VecMap<String, String>,
media: String,
vault: ID,
position: u64,
stake: Option<StakedSui>,
principal: u64,
validator: address,
status: String,
debt_a: u128,
debt_b: u128,
minted_epoch: u64,
burned_epoch: u64,
pad: vector<u8>
}
struct CollectionCreated has copy, drop {
collection: ID,
policy: ID,
graveyard: ID,
supply: u64,
price: u64
}
struct VaultCreated has copy, drop {
collection: ID,
vault: ID
}
struct SeedCapIssued has copy, drop {
collection: ID,
to: address
}
struct Seeded has copy, drop {
collection: ID,
count: u64,
seeded: u64
}
struct Reserved has copy, drop {
collection: ID,
index: u64,
minter: address
}
struct LaunchReservationKey has copy, drop, store {
index: u64
}
struct Minted has copy, drop {
item: ID,
number: u64,
index: u64,
minter: address,
principal: u64,
validator: address,
position: u64,
reserved: bool
}
struct PositionLocked has copy, drop {
vault: ID,
position: u64,
ones: u64,
minter: address,
liquidity: u128,
swap_in: u64,
lp_sui: u64,
lp_a: u64,
fee: u64
}
struct Harvested has copy, drop {
item: ID,
number: u64,
index: u64,
reward: u64,
validator: address,
holder: address
}
struct Collected has copy, drop {
item: ID,
number: u64,
index: u64,
amount_a: u64,
amount_b: u64,
holder: address
}
struct Swept has copy, drop {
vault: ID,
caller: address,
positions: u64,
amount_a: u64,
amount_b: u64,
caller_a: u64,
caller_b: u64,
live: u64
}
struct Burned has copy, drop {
item: ID,
number: u64,
index: u64,
holder: address,
principal: u64,
staking_out: u64,
pot_a: u64,
pot_b: u64,
royalty: u64,
live: u64
}
struct ValidatorSet has copy, drop {
collection: ID,
from: address,
to: address
}
struct PoolsSet has copy, drop {
collection: ID,
swap_from: ID,
swap_to: ID,
lp_from: ID,
lp_to: ID
}
struct FeeWalletSet has copy, drop {
collection: ID,
from: address,
to: address
}
struct RoyaltyWalletSet has copy, drop {
collection: ID,
from: address,
to: address
}
struct ScheduleSet has copy, drop {
collection: ID,
holder_start_ms: u64,
public_start_ms: u64,
min_holder_balance: u64
}
struct MintOpenSet has copy, drop {
collection: ID,
open: bool
}
struct SweepSet has copy, drop {
vault: ID,
open: bool,
fee_bps: u64
}
struct RoyaltySet has copy, drop {
collection: ID,
bps: u16,
min: u64
}
struct RoyaltiesDistributed has copy, drop {
collection: ID,
policy: ID,
total: u64,
willie: u64,
king: u64
}
struct LegacyMigrated has copy, drop {
old: ID,
item: ID,
index: u64,
holder: address,
price: u64,
vip: bool
}
struct Migrated has copy, drop {
object: ID,
from: u64,
to: u64
}
struct AdminTransferred has copy, drop {
to: address
}
struct Config has store, key {
id: UID,
collection: ID,
code_version: u64,
revision: u64,
upgrade_cap: Option<ID>,
values: Versioned
}
struct SettingsV1 has store {
public_mint: Allocation,
migration: Allocation,
vip_migration: Allocation,
treasury_wallet: address,
hive_wallet: address,
subsidy_wallet: address,
willie_wallet: address,
royalty_willie_bps: u16,
royalty_bps: u16,
validator: address,
swap_pool: ID,
lp_pool: ID,
min_king_tokens: u64,
holder_start_ms: u64,
public_start_ms: u64,
early_access_ms: u64,
migration_duration_ms: u64,
max_per_tx: u64,
emergency_pauses: u64
}
struct ConfigCreated has copy, drop {
config: ID,
collection: ID,
version: u64
}
struct ConfigUpdated has copy, drop {
config: ID,
revision: u64,
section: u8
}
struct ProtocolUpgraded has copy, drop {
collection: ID,
vault: ID,
config: ID,
from: u64,
to: u64,
package: ID
}
init(Arg0: COLLECTION, Arg1: &mut TxContext) {
L2: loc0: bool
L3: loc1: bool
L4: loc2: Collection
L5: loc3: ID
L6: loc4: UID
L7: loc5: Config
L8: loc6: ID
L9: loc7: Display<KingFizh>
L10: loc8: address
L11: loc9: Kiosk
L12: loc10: KioskOwnerCap
L13: loc11: String
L14: loc12: State
L15: loc13: String
L16: loc14: TransferPolicy<KingFizh>
L17: loc15: TransferPolicyCap<KingFizh>
L18: loc16: Publisher
B0:
0LdConst[3](u64: 2000..)
1LdConst[15](u64: 1000..)
2Ge
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[1](Arg1: &mut TxContext)
6Pop
7LdConst[54](u64: 123)
8Abort
B3:
9LdConst[4](u64: 1500..)
10LdU64(0)
11Gt
12BrFalse(20)
B4:
13LdConst[3](u64: 2000..)
14LdConst[4](u64: 1500..)
15Add
16LdConst[2](u64: 8000..)
17Le
18StLoc[2](loc0: bool)
19Branch(22)
B5:
20LdFalse
21StLoc[2](loc0: bool)
B6:
22MoveLoc[2](loc0: bool)
23BrFalse(25)
B7:
24Branch(29)
B8:
25MoveLoc[1](Arg1: &mut TxContext)
26Pop
27LdConst[54](u64: 123)
28Abort
B9:
29LdConst[1](u64: 2100)
30LdU64(1)
31Ge
32BrFalse(38)
B10:
33LdConst[1](u64: 2100)
34LdU64(65535)
35Le
36StLoc[3](loc1: bool)
37Branch(40)
B11:
38LdFalse
39StLoc[3](loc1: bool)
B12:
40MoveLoc[3](loc1: bool)
41BrFalse(43)
B13:
42Branch(47)
B14:
43MoveLoc[1](Arg1: &mut TxContext)
44Pop
45LdConst[53](u64: 122)
46Abort
B15:
47CopyLoc[1](Arg1: &mut TxContext)
48FreezeRef
49Call tx_context::sender(&TxContext): address
50StLoc[10](loc8: address)
51MoveLoc[0](Arg0: COLLECTION)
52CopyLoc[1](Arg1: &mut TxContext)
53Call package::claim<COLLECTION>(COLLECTION, &mut TxContext): Publisher
54StLoc[18](loc16: Publisher)
55LdConst[7](vector<u8>: "htt..)
56Call string::utf8(vector<u8>): String
57StLoc[13](loc11: String)
58MutBorrowLoc[13](loc11: String)
59LdConst[80](vector<u8>: "{me..)
60Call string::utf8(vector<u8>): String
61Call string::append(&mut String, String)
62MutBorrowLoc[13](loc11: String)
63LdConst[8](vector<u8>: "web..)
64Call string::utf8(vector<u8>): String
65Call string::append(&mut String, String)
66LdConst[9](vector<u8>: "htt..)
67Call string::utf8(vector<u8>): String
68StLoc[15](loc13: String)
69MutBorrowLoc[15](loc13: String)
70LdConst[81](vector<u8>: "pie..)
71Call string::utf8(vector<u8>): String
72Call string::append(&mut String, String)
73ImmBorrowLoc[18](loc16: Publisher)
74LdConst[82](vector<u8>: "nam..)
75Call string::utf8(vector<u8>): String
76LdConst[83](vector<u8>: "des..)
77Call string::utf8(vector<u8>): String
78LdConst[84](vector<u8>: "ima..)
79Call string::utf8(vector<u8>): String
80LdConst[85](vector<u8>: "thu..)
81Call string::utf8(vector<u8>): String
82LdConst[86](vector<u8>: "lin..)
83Call string::utf8(vector<u8>): String
84LdConst[87](vector<u8>: "pro..)
85Call string::utf8(vector<u8>): String
86LdConst[88](vector<u8>: "cre..)
87Call string::utf8(vector<u8>): String
88LdConst[89](vector<u8>: "num..)
89Call string::utf8(vector<u8>): String
90LdConst[90](vector<u8>: "sta..)
91Call string::utf8(vector<u8>): String
92LdConst[91](vector<u8>: "pri..)
93Call string::utf8(vector<u8>): String
94LdConst[92](vector<u8>: "val..)
95Call string::utf8(vector<u8>): String
96VecPack(25, 11)
97LdConst[11](vector<u8>: "Kin..)
98Call string::utf8(vector<u8>): String
99LdConst[0](vector<u8>: "Kin..)
100Call string::utf8(vector<u8>): String
101CopyLoc[13](loc11: String)
102MoveLoc[13](loc11: String)
103MoveLoc[15](loc13: String)
104LdConst[9](vector<u8>: "htt..)
105Call string::utf8(vector<u8>): String
106LdConst[10](vector<u8>: "Ali..)
107Call string::utf8(vector<u8>): String
108LdConst[93](vector<u8>: "{nu..)
109Call string::utf8(vector<u8>): String
110LdConst[94](vector<u8>: "{st..)
111Call string::utf8(vector<u8>): String
112LdConst[95](vector<u8>: "{pr..)
113Call string::utf8(vector<u8>): String
114LdConst[96](vector<u8>: "{va..)
115Call string::utf8(vector<u8>): String
116VecPack(25, 11)
117CopyLoc[1](Arg1: &mut TxContext)
118Call display::new_with_fields<KingFizh>(&Publisher, vector<String>, vector<String>, &mut TxContext): Display<KingFizh>
119StLoc[9](loc7: Display<KingFizh>)
120MutBorrowLoc[9](loc7: Display<KingFizh>)
121Call display::update_version<KingFizh>(&mut Display<KingFizh>)
122ImmBorrowLoc[18](loc16: Publisher)
123CopyLoc[1](Arg1: &mut TxContext)
124Call transfer_policy::new<KingFizh>(&Publisher, &mut TxContext): TransferPolicy<KingFizh> * TransferPolicyCap<KingFizh>
125StLoc[17](loc15: TransferPolicyCap<KingFizh>)
126StLoc[16](loc14: TransferPolicy<KingFizh>)
127MutBorrowLoc[16](loc14: TransferPolicy<KingFizh>)
128ImmBorrowLoc[17](loc15: TransferPolicyCap<KingFizh>)
129LdConst[5](u16: 500)
130LdConst[6](u64: 0)
131Call royalty_rule::add<KingFizh>(&mut TransferPolicy<KingFizh>, &TransferPolicyCap<KingFizh>, u16, u64)
132MutBorrowLoc[16](loc14: TransferPolicy<KingFizh>)
133ImmBorrowLoc[17](loc15: TransferPolicyCap<KingFizh>)
134Call kiosk_lock_rule::add<KingFizh>(&mut TransferPolicy<KingFizh>, &TransferPolicyCap<KingFizh>)
135CopyLoc[1](Arg1: &mut TxContext)
136Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap
137StLoc[12](loc10: KioskOwnerCap)
138StLoc[11](loc9: Kiosk)
139CopyLoc[1](Arg1: &mut TxContext)
140Call object::new(&mut TxContext): UID
141StLoc[6](loc4: UID)
142ImmBorrowLoc[6](loc4: UID)
143Call object::uid_to_inner(&UID): ID
144StLoc[5](loc3: ID)
145MutBorrowLoc[11](loc9: Kiosk)
146ImmBorrowLoc[12](loc10: KioskOwnerCap)
147ImmBorrowLoc[5](loc3: ID)
148Call object::id_to_address(&ID): address
149Call kiosk::set_owner_custom(&mut Kiosk, &KioskOwnerCap, address)
150MutBorrowLoc[6](loc4: UID)
151LdFalse
152Pack[2](PublisherKey)
153MoveLoc[18](loc16: Publisher)
154Call dynamic_field::add<PublisherKey, Publisher>(&mut UID, PublisherKey, Publisher)
155CopyLoc[5](loc3: ID)
156ImmBorrowLoc[9](loc7: Display<KingFizh>)
157Call object::id<Display<KingFizh>>(&Display<KingFizh>): ID
158CopyLoc[1](Arg1: &mut TxContext)
159Call legacy::new(ID, ID, &mut TxContext): State
160StLoc[14](loc12: State)
161MutBorrowLoc[6](loc4: UID)
162LdFalse
163Pack[4](LegacyStateKey)
164MoveLoc[14](loc12: State)
165Call dynamic_field::add<LegacyStateKey, State>(&mut UID, LegacyStateKey, State)
166CopyLoc[1](Arg1: &mut TxContext)
167Call object::new(&mut TxContext): UID
168CopyLoc[5](loc3: ID)
169LdConst[13](u64: 1)
170LdU64(0)
171Call option::none<ID>(): Option<ID>
172LdU64(1)
173LdU8(0)
174Call terms::default_allocation(u8): Allocation
175LdU8(1)
176Call terms::default_allocation(u8): Allocation
177LdU8(2)
178Call terms::default_allocation(u8): Allocation
179Call terms::king(): address
180Call terms::hive(): address
181Call terms::subsidy(): address
182Call terms::willie(): address
183LdU16(3000)
184LdConst[5](u16: 500)
185LdConst[97](address: 0x00..)
186LdConst[97](address: 0x00..)
187Call object::id_from_address(address): ID
188LdConst[97](address: 0x00..)
189Call object::id_from_address(address): ID
190LdU64(3000000)
191LdConst[26](u64: 1844..)
192LdConst[26](u64: 1844..)
193Call terms::early_access_ms(): u64
194Call terms::migration_duration_ms(): u64
195LdConst[12](u64: 25)
196LdU64(0)
197Pack[37](SettingsV1)
198CopyLoc[1](Arg1: &mut TxContext)
199Call versioned::create<SettingsV1>(u64, SettingsV1, &mut TxContext): Versioned
200Pack[36](Config)
201StLoc[7](loc5: Config)
202ImmBorrowLoc[7](loc5: Config)
203Call object::id<Config>(&Config): ID
204StLoc[8](loc6: ID)
205CopyLoc[8](loc6: ID)
206CopyLoc[5](loc3: ID)
207LdConst[13](u64: 1)
208Pack[38](ConfigCreated)
209Call event::emit<ConfigCreated>(ConfigCreated)
210MutBorrowLoc[6](loc4: UID)
211LdFalse
212Pack[5](ConfigKey)
213MoveLoc[7](loc5: Config)
214Call dynamic_object_field::add<ConfigKey, Config>(&mut UID, ConfigKey, Config)
215MoveLoc[6](loc4: UID)
216MoveLoc[8](loc6: ID)
217LdConst[13](u64: 1)
218LdConst[0](vector<u8>: "Kin..)
219Call string::utf8(vector<u8>): String
220LdConst[1](u64: 2100)
221LdU64(0)
222LdU64(0)
223LdConst[2](u64: 8000..)
224LdConst[3](u64: 2000..)
225LdConst[4](u64: 1500..)
226LdConst[97](address: 0x00..)
227LdConst[97](address: 0x00..)
228LdConst[97](address: 0x00..)
229LdConst[97](address: 0x00..)
230Call object::id_from_address(address): ID
231LdConst[97](address: 0x00..)
232Call object::id_from_address(address): ID
233LdConst[97](address: 0x00..)
234Call object::id_from_address(address): ID
235ImmBorrowLoc[16](loc14: TransferPolicy<KingFizh>)
236Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
237ImmBorrowLoc[11](loc9: Kiosk)
238Call object::id<Kiosk>(&Kiosk): ID
239MoveLoc[12](loc10: KioskOwnerCap)
240MoveLoc[17](loc15: TransferPolicyCap<KingFizh>)
241LdFalse
242LdConst[26](u64: 1844..)
243LdConst[26](u64: 1844..)
244LdConst[26](u64: 1844..)
245CopyLoc[1](Arg1: &mut TxContext)
246Call table::new<u64, ItemData>(&mut TxContext): Table<u64, ItemData>
247LdU64(0)
248LdConst[98](vector<u16>: 00)
249LdU64(0)
250CopyLoc[1](Arg1: &mut TxContext)
251Call table::new<u64, address>(&mut TxContext): Table<u64, address>
252LdU64(0)
253CopyLoc[1](Arg1: &mut TxContext)
254Call table::new<u64, u64>(&mut TxContext): Table<u64, u64>
255CopyLoc[1](Arg1: &mut TxContext)
256Call table::new<u64, ID>(&mut TxContext): Table<u64, ID>
257Pack[9](Collection)
258StLoc[4](loc2: Collection)
259CopyLoc[5](loc3: ID)
260ImmBorrowLoc[16](loc14: TransferPolicy<KingFizh>)
261Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
262ImmBorrowLoc[11](loc9: Kiosk)
263Call object::id<Kiosk>(&Kiosk): ID
264LdConst[1](u64: 2100)
265LdConst[2](u64: 8000..)
266Pack[12](CollectionCreated)
267Call event::emit<CollectionCreated>(CollectionCreated)
268MoveLoc[16](loc14: TransferPolicy<KingFizh>)
269Call transfer::public_share_object<TransferPolicy<KingFizh>>(TransferPolicy<KingFizh>)
270MoveLoc[11](loc9: Kiosk)
271Call transfer::public_share_object<Kiosk>(Kiosk)
272MoveLoc[4](loc2: Collection)
273Call transfer::share_object<Collection>(Collection)
274MoveLoc[9](loc7: Display<KingFizh>)
275CopyLoc[10](loc8: address)
276Call transfer::public_transfer<Display<KingFizh>>(Display<KingFizh>, address)
277CopyLoc[1](Arg1: &mut TxContext)
278Call object::new(&mut TxContext): UID
279CopyLoc[5](loc3: ID)
280Pack[1](AdminCap)
281CopyLoc[10](loc8: address)
282Call transfer::transfer<AdminCap>(AdminCap, address)
283CopyLoc[5](loc3: ID)
284CopyLoc[10](loc8: address)
285Pack[14](SeedCapIssued)
286Call event::emit<SeedCapIssued>(SeedCapIssued)
287MoveLoc[1](Arg1: &mut TxContext)
288Call object::new(&mut TxContext): UID
289MoveLoc[5](loc3: ID)
290Pack[7](SeedCap)
291MoveLoc[10](loc8: address)
292Call transfer::transfer<SeedCap>(SeedCap, address)
293Ret
}
public issue_seed_cap(Arg0: &AdminCap, Arg1: &Collection, Arg2: address, Arg3: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &Collection)
2Call assert_admin(&AdminCap, &Collection)
3CopyLoc[1](Arg1: &Collection)
4Call check_collection(&Collection)
5CopyLoc[1](Arg1: &Collection)
6Call object::id<Collection>(&Collection): ID
7CopyLoc[2](Arg2: address)
8Pack[14](SeedCapIssued)
9Call event::emit<SeedCapIssued>(SeedCapIssued)
10MoveLoc[3](Arg3: &mut TxContext)
11Call object::new(&mut TxContext): UID
12MoveLoc[1](Arg1: &Collection)
13Call object::id<Collection>(&Collection): ID
14Pack[7](SeedCap)
15MoveLoc[2](Arg2: address)
16Call transfer::transfer<SeedCap>(SeedCap, address)
17Ret
}
public destroy_seed_cap(Arg0: SeedCap) {
B0:
0MoveLoc[0](Arg0: SeedCap)
1Unpack[7](SeedCap)
2Pop
3Call object::delete(UID)
4Ret
}
public seed_batch(Arg0: &SeedCap, Arg1: &mut Collection, Arg2: vector<u64>, Arg3: vector<u64>, Arg4: vector<vector<u8>>, Arg5: vector<vector<u8>>) {
L6: loc0: bool
L7: loc1: u64
L8: loc2: VecMap<String, String>
L9: loc3: u64
L10: loc4: u64
L11: loc5: VecMap<String, String>
L12: loc6: u64
L13: loc7: u64
L14: loc8: u64
L15: loc9: u64
L16: loc10: u64
L17: loc11: vector<u8>
B0:
0CopyLoc[1](Arg1: &mut Collection)
1FreezeRef
2Call check_collection(&Collection)
3MoveLoc[0](Arg0: &SeedCap)
4ImmBorrowField[0](SeedCap.collection: ID)
5ReadRef
6CopyLoc[1](Arg1: &mut Collection)
7FreezeRef
8Call object::id<Collection>(&Collection): ID
9Eq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[1](Arg1: &mut Collection)
13Pop
14LdConst[63](u64: 133)
15Abort
B3:
16ImmBorrowLoc[2](Arg2: vector<u64>)
17VecLen(7)
18StLoc[14](loc8: u64)
19ImmBorrowLoc[3](Arg3: vector<u64>)
20VecLen(7)
21CopyLoc[14](loc8: u64)
22Eq
23BrFalse(25)
B4:
24Branch(29)
B5:
25MoveLoc[1](Arg1: &mut Collection)
26Pop
27LdConst[31](u64: 127)
28Abort
B6:
29ImmBorrowLoc[4](Arg4: vector<vector<u8>>)
30VecLen(8)
31ImmBorrowLoc[5](Arg5: vector<vector<u8>>)
32VecLen(8)
33Eq
34BrFalse(36)
B7:
35Branch(40)
B8:
36MoveLoc[1](Arg1: &mut Collection)
37Pop
38LdConst[31](u64: 127)
39Abort
B9:
40LdU64(0)
41StLoc[16](loc10: u64)
42LdU64(0)
43StLoc[15](loc9: u64)
B10:
44CopyLoc[16](loc10: u64)
45CopyLoc[14](loc8: u64)
46Lt
47BrFalse(182)
B11:
48ImmBorrowLoc[2](Arg2: vector<u64>)
49CopyLoc[16](loc10: u64)
50VecImmBorrow(7)
51ReadRef
52StLoc[13](loc7: u64)
53ImmBorrowLoc[3](Arg3: vector<u64>)
54CopyLoc[16](loc10: u64)
55VecImmBorrow(7)
56ReadRef
57StLoc[10](loc4: u64)
58CopyLoc[13](loc7: u64)
59LdU64(1)
60Ge
61BrFalse(69)
B12:
62CopyLoc[13](loc7: u64)
63CopyLoc[1](Arg1: &mut Collection)
64ImmBorrowField[1](Collection.supply: u64)
65ReadRef
66Le
67StLoc[6](loc0: bool)
68Branch(72)
B13:
69LdFalse
70StLoc[6](loc0: bool)
71Branch(72)
B14:
72MoveLoc[6](loc0: bool)
73BrFalse(75)
B15:
74Branch(79)
B16:
75MoveLoc[1](Arg1: &mut Collection)
76Pop
77LdConst[53](u64: 122)
78Abort
B17:
79CopyLoc[1](Arg1: &mut Collection)
80ImmBorrowField[2](Collection.registry: Table<u64, ItemData>)
81CopyLoc[13](loc7: u64)
82Call table::contains<u64, ItemData>(&Table<u64, ItemData>, u64): bool
83Not
84BrFalse(86)
B18:
85Branch(90)
B19:
86MoveLoc[1](Arg1: &mut Collection)
87Pop
88LdConst[55](u64: 124)
89Abort
B20:
90CopyLoc[13](loc7: u64)
91CopyLoc[1](Arg1: &mut Collection)
92ImmBorrowField[3](Collection.seeded: u64)
93ReadRef
94LdU64(1)
95Add
96Eq
97BrFalse(99)
B21:
98Branch(103)
B22:
99MoveLoc[1](Arg1: &mut Collection)
100Pop
101LdConst[64](u64: 134)
102Abort
B23:
103CopyLoc[10](loc4: u64)
104LdConst[29](u64: 15)
105Le
106BrFalse(108)
B24:
107Branch(112)
B25:
108MoveLoc[1](Arg1: &mut Collection)
109Pop
110LdConst[58](u64: 128)
111Abort
B26:
112ImmBorrowLoc[4](Arg4: vector<vector<u8>>)
113ImmBorrowLoc[5](Arg5: vector<vector<u8>>)
114CopyLoc[15](loc9: u64)
115CopyLoc[10](loc4: u64)
116Call build_attributes(&vector<vector<u8>>, &vector<vector<u8>>, u64, u64): VecMap<String, String> * u64
117StLoc[9](loc3: u64)
118StLoc[8](loc2: VecMap<String, String>)
119CopyLoc[10](loc4: u64)
120LdConst[30](u64: 3)
121Lt
122BrFalse(128)
B27:
123LdConst[29](u64: 15)
124CopyLoc[10](loc4: u64)
125Sub
126StLoc[7](loc1: u64)
127Branch(130)
B28:
128LdU64(0)
129StLoc[7](loc1: u64)
B29:
130MoveLoc[7](loc1: u64)
131Call build_filler(u64): VecMap<String, String> * u64
132StLoc[12](loc6: u64)
133StLoc[11](loc5: VecMap<String, String>)
134CopyLoc[9](loc3: u64)
135CopyLoc[12](loc6: u64)
136Add
137LdConst[28](u64: 272)
138Le
139BrFalse(141)
B30:
140Branch(145)
B31:
141MoveLoc[1](Arg1: &mut Collection)
142Pop
143LdConst[58](u64: 128)
144Abort
B32:
145LdConst[27](u64: 400)
146MoveLoc[9](loc3: u64)
147Sub
148MoveLoc[12](loc6: u64)
149Sub
150Call zeros(u64): vector<u8>
151StLoc[17](loc11: vector<u8>)
152CopyLoc[1](Arg1: &mut Collection)
153MutBorrowField[2](Collection.registry: Table<u64, ItemData>)
154CopyLoc[13](loc7: u64)
155MoveLoc[8](loc2: VecMap<String, String>)
156MoveLoc[11](loc5: VecMap<String, String>)
157MoveLoc[17](loc11: vector<u8>)
158Pack[8](ItemData)
159Call table::add<u64, ItemData>(&mut Table<u64, ItemData>, u64, ItemData)
160CopyLoc[1](Arg1: &mut Collection)
161MutBorrowField[4](Collection.pool: vector<u16>)
162MoveLoc[13](loc7: u64)
163CastU16
164VecPushBack(173)
165CopyLoc[1](Arg1: &mut Collection)
166ImmBorrowField[3](Collection.seeded: u64)
167ReadRef
168LdU64(1)
169Add
170CopyLoc[1](Arg1: &mut Collection)
171MutBorrowField[3](Collection.seeded: u64)
172WriteRef
173MoveLoc[15](loc9: u64)
174MoveLoc[10](loc4: u64)
175Add
176StLoc[15](loc9: u64)
177MoveLoc[16](loc10: u64)
178LdU64(1)
179Add
180StLoc[16](loc10: u64)
181Branch(44)
B33:
182MoveLoc[15](loc9: u64)
183ImmBorrowLoc[4](Arg4: vector<vector<u8>>)
184VecLen(8)
185Eq
186BrFalse(188)
B34:
187Branch(192)
B35:
188MoveLoc[1](Arg1: &mut Collection)
189Pop
190LdConst[31](u64: 127)
191Abort
B36:
192CopyLoc[1](Arg1: &mut Collection)
193FreezeRef
194Call object::id<Collection>(&Collection): ID
195MoveLoc[14](loc8: u64)
196MoveLoc[1](Arg1: &mut Collection)
197ImmBorrowField[3](Collection.seeded: u64)
198ReadRef
199Pack[15](Seeded)
200Call event::emit<Seeded>(Seeded)
201Ret
}
build_attributes(Arg0: &vector<vector<u8>>, Arg1: &vector<vector<u8>>, Arg2: u64, Arg3: u64): VecMap<String, String> * u64 {
L4: loc0: bool
L5: loc1: VecMap<String, String>
L6: loc2: u64
L7: loc3: u64
L8: loc4: vector<u8>
L9: loc5: String
L10: loc6: vector<u8>
B0:
0CopyLoc[3](Arg3: u64)
1LdU64(128)
2Lt
3BrFalse(5)
B1:
4Branch(11)
B2:
5MoveLoc[1](Arg1: &vector<vector<u8>>)
6Pop
7MoveLoc[0](Arg0: &vector<vector<u8>>)
8Pop
9LdConst[58](u64: 128)
10Abort
B3:
11Call vec_map::empty<String, String>(): VecMap<String, String>
12StLoc[5](loc1: VecMap<String, String>)
13LdU64(1)
14StLoc[6](loc2: u64)
15LdU64(0)
16StLoc[7](loc3: u64)
B4:
17CopyLoc[7](loc3: u64)
18CopyLoc[3](Arg3: u64)
19Lt
20BrFalse(93)
B5:
21CopyLoc[0](Arg0: &vector<vector<u8>>)
22CopyLoc[2](Arg2: u64)
23CopyLoc[7](loc3: u64)
24Add
25VecImmBorrow(8)
26ReadRef
27StLoc[8](loc4: vector<u8>)
28CopyLoc[1](Arg1: &vector<vector<u8>>)
29CopyLoc[2](Arg2: u64)
30CopyLoc[7](loc3: u64)
31Add
32VecImmBorrow(8)
33ReadRef
34StLoc[10](loc6: vector<u8>)
35ImmBorrowLoc[8](loc4: vector<u8>)
36VecLen(83)
37LdConst[31](u64: 127)
38Le
39BrFalse(47)
B6:
40Branch(41)
B7:
41ImmBorrowLoc[10](loc6: vector<u8>)
42VecLen(83)
43LdConst[31](u64: 127)
44Le
45StLoc[4](loc0: bool)
46Branch(49)
B8:
47LdFalse
48StLoc[4](loc0: bool)
B9:
49MoveLoc[4](loc0: bool)
50BrFalse(52)
B10:
51Branch(58)
B11:
52MoveLoc[1](Arg1: &vector<vector<u8>>)
53Pop
54MoveLoc[0](Arg0: &vector<vector<u8>>)
55Pop
56LdConst[58](u64: 128)
57Abort
B12:
58MoveLoc[6](loc2: u64)
59LdU64(2)
60Add
61ImmBorrowLoc[8](loc4: vector<u8>)
62VecLen(83)
63Add
64ImmBorrowLoc[10](loc6: vector<u8>)
65VecLen(83)
66Add
67StLoc[6](loc2: u64)
68MoveLoc[8](loc4: vector<u8>)
69Call string::utf8(vector<u8>): String
70StLoc[9](loc5: String)
71ImmBorrowLoc[5](loc1: VecMap<String, String>)
72ImmBorrowLoc[9](loc5: String)
73Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
74Not
75BrFalse(77)
B13:
76Branch(83)
B14:
77MoveLoc[1](Arg1: &vector<vector<u8>>)
78Pop
79MoveLoc[0](Arg0: &vector<vector<u8>>)
80Pop
81LdConst[57](u64: 126)
82Abort
B15:
83MutBorrowLoc[5](loc1: VecMap<String, String>)
84MoveLoc[9](loc5: String)
85MoveLoc[10](loc6: vector<u8>)
86Call string::utf8(vector<u8>): String
87Call vec_map::insert<String, String>(&mut VecMap<String, String>, String, String)
88MoveLoc[7](loc3: u64)
89LdU64(1)
90Add
91StLoc[7](loc3: u64)
92Branch(17)
B16:
93MoveLoc[1](Arg1: &vector<vector<u8>>)
94Pop
95MoveLoc[0](Arg0: &vector<vector<u8>>)
96Pop
97MoveLoc[5](loc1: VecMap<String, String>)
98MoveLoc[6](loc2: u64)
99Ret
}
build_filler(Arg0: u64): VecMap<String, String> * u64 {
L1: loc0: u64
L2: loc1: VecMap<String, String>
B0:
0Call vec_map::empty<String, String>(): VecMap<String, String>
1StLoc[2](loc1: VecMap<String, String>)
2LdU64(0)
3StLoc[1](loc0: u64)
B1:
4CopyLoc[1](loc0: u64)
5CopyLoc[0](Arg0: u64)
6Lt
7BrFalse(24)
B2:
8Branch(9)
B3:
9MutBorrowLoc[2](loc1: VecMap<String, String>)
10LdU8(48)
11CopyLoc[1](loc0: u64)
12CastU8
13Add
14VecPack(83, 1)
15Call string::utf8(vector<u8>): String
16LdConst[99](vector<u8>: "" /..)
17Call string::utf8(vector<u8>): String
18Call vec_map::insert<String, String>(&mut VecMap<String, String>, String, String)
19MoveLoc[1](loc0: u64)
20LdU64(1)
21Add
22StLoc[1](loc0: u64)
23Branch(4)
B4:
24MoveLoc[2](loc1: VecMap<String, String>)
25LdU64(1)
26LdU64(3)
27MoveLoc[0](Arg0: u64)
28Mul
29Add
30Ret
}
zeros(Arg0: u64): vector<u8> {
L1: loc0: u64
L2: loc1: vector<u8>
B0:
0LdConst[99](vector<u8>: "" /..)
1StLoc[2](loc1: vector<u8>)
2LdU64(0)
3StLoc[1](loc0: u64)
B1:
4CopyLoc[1](loc0: u64)
5CopyLoc[0](Arg0: u64)
6Lt
7BrFalse(17)
B2:
8Branch(9)
B3:
9MutBorrowLoc[2](loc1: vector<u8>)
10LdU8(0)
11VecPushBack(83)
12MoveLoc[1](loc0: u64)
13LdU64(1)
14Add
15StLoc[1](loc0: u64)
16Branch(4)
B4:
17MoveLoc[2](loc1: vector<u8>)
18Ret
}
public reserve(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: address) {
L4: loc0: bool
L5: loc1: bool
L6: loc2: 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_collection(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8ImmBorrowField[3](Collection.seeded: u64)
9ReadRef
10CopyLoc[1](Arg1: &mut Collection)
11ImmBorrowField[1](Collection.supply: u64)
12ReadRef
13Eq
14BrFalse(16)
B1:
15Branch(20)
B2:
16MoveLoc[1](Arg1: &mut Collection)
17Pop
18LdConst[56](u64: 125)
19Abort
B3:
20CopyLoc[1](Arg1: &mut Collection)
21ImmBorrowField[5](Collection.minted: u64)
22ReadRef
23LdU64(0)
24Eq
25BrFalse(33)
B4:
26CopyLoc[1](Arg1: &mut Collection)
27FreezeRef
28Call legacy_state(&Collection): &State
29Call legacy::frozen(&State): bool
30Not
31StLoc[4](loc0: bool)
32Branch(35)
B5:
33LdFalse
34StLoc[4](loc0: bool)
B6:
35MoveLoc[4](loc0: bool)
36BrFalse(38)
B7:
37Branch(42)
B8:
38MoveLoc[1](Arg1: &mut Collection)
39Pop
40LdConst[61](u64: 131)
41Abort
B9:
42CopyLoc[1](Arg1: &mut Collection)
43ImmBorrowField[6](Collection.mint_open: bool)
44ReadRef
45Not
46BrFalse(54)
B10:
47CopyLoc[1](Arg1: &mut Collection)
48ImmBorrowField[7](Collection.reserved_total: u64)
49ReadRef
50LdConst[19](u64: 2)
51Lt
52StLoc[5](loc1: bool)
53Branch(56)
B11:
54LdFalse
55StLoc[5](loc1: bool)
B12:
56MoveLoc[5](loc1: bool)
57BrFalse(59)
B13:
58Branch(63)
B14:
59MoveLoc[1](Arg1: &mut Collection)
60Pop
61LdConst[61](u64: 131)
62Abort
B15:
63CopyLoc[2](Arg2: u64)
64LdU64(1)
65Ge
66BrFalse(74)
B16:
67CopyLoc[2](Arg2: u64)
68CopyLoc[1](Arg1: &mut Collection)
69ImmBorrowField[1](Collection.supply: u64)
70ReadRef
71Le
72StLoc[6](loc2: bool)
73Branch(76)
B17:
74LdFalse
75StLoc[6](loc2: bool)
B18:
76MoveLoc[6](loc2: bool)
77BrFalse(79)
B19:
78Branch(83)
B20:
79MoveLoc[1](Arg1: &mut Collection)
80Pop
81LdConst[53](u64: 122)
82Abort
B21:
83CopyLoc[1](Arg1: &mut Collection)
84ImmBorrowField[8](Collection.reservations: Table<u64, address>)
85CopyLoc[2](Arg2: u64)
86Call table::contains<u64, address>(&Table<u64, address>, u64): bool
87Not
88BrFalse(90)
B22:
89Branch(94)
B23:
90MoveLoc[1](Arg1: &mut Collection)
91Pop
92LdConst[62](u64: 132)
93Abort
B24:
94CopyLoc[3](Arg3: address)
95LdConst[97](address: 0x00..)
96Neq
97BrFalse(99)
B25:
98Branch(103)
B26:
99MoveLoc[1](Arg1: &mut Collection)
100Pop
101LdConst[53](u64: 122)
102Abort
B27:
103CopyLoc[1](Arg1: &mut Collection)
104CopyLoc[2](Arg2: u64)
105Call remove_available(&mut Collection, u64)
106CopyLoc[1](Arg1: &mut Collection)
107ImmBorrowField[9](Collection.drawn: u64)
108ReadRef
109LdU64(1)
110Add
111CopyLoc[1](Arg1: &mut Collection)
112MutBorrowField[9](Collection.drawn: u64)
113WriteRef
114CopyLoc[1](Arg1: &mut Collection)
115ImmBorrowField[7](Collection.reserved_total: u64)
116ReadRef
117LdU64(1)
118Add
119CopyLoc[1](Arg1: &mut Collection)
120MutBorrowField[7](Collection.reserved_total: u64)
121WriteRef
122CopyLoc[1](Arg1: &mut Collection)
123MutBorrowField[8](Collection.reservations: Table<u64, address>)
124CopyLoc[2](Arg2: u64)
125CopyLoc[3](Arg3: address)
126Call table::add<u64, address>(&mut Table<u64, address>, u64, address)
127MoveLoc[1](Arg1: &mut Collection)
128FreezeRef
129Call object::id<Collection>(&Collection): ID
130MoveLoc[2](Arg2: u64)
131MoveLoc[3](Arg3: address)
132Pack[16](Reserved)
133Call event::emit<Reserved>(Reserved)
134Ret
}
public reserve_after_launch(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<u64>, Arg3: vector<address>) {
L4: loc0: bool
L5: loc1: bool
L6: loc2: u64
L7: loc3: u64
L8: loc4: address
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8ImmBorrowField[3](Collection.seeded: u64)
9ReadRef
10CopyLoc[1](Arg1: &mut Collection)
11ImmBorrowField[1](Collection.supply: u64)
12ReadRef
13Eq
14BrFalse(16)
B1:
15Branch(20)
B2:
16MoveLoc[1](Arg1: &mut Collection)
17Pop
18LdConst[56](u64: 125)
19Abort
B3:
20ImmBorrowLoc[2](Arg2: vector<u64>)
21VecLen(7)
22LdU64(0)
23Gt
24BrFalse(40)
B4:
25ImmBorrowLoc[2](Arg2: vector<u64>)
26VecLen(7)
27LdU64(50)
28Le
29BrFalse(37)
B5:
30ImmBorrowLoc[2](Arg2: vector<u64>)
31VecLen(7)
32ImmBorrowLoc[3](Arg3: vector<address>)
33VecLen(118)
34Eq
35StLoc[4](loc0: bool)
36Branch(42)
B6:
37LdFalse
38StLoc[4](loc0: bool)
39Branch(42)
B7:
40LdFalse
41StLoc[4](loc0: bool)
B8:
42MoveLoc[4](loc0: bool)
43BrFalse(45)
B9:
44Branch(49)
B10:
45MoveLoc[1](Arg1: &mut Collection)
46Pop
47LdConst[47](u64: 116)
48Abort
B11:
49LdU64(0)
50StLoc[6](loc2: u64)
B12:
51CopyLoc[6](loc2: u64)
52ImmBorrowLoc[2](Arg2: vector<u64>)
53VecLen(7)
54Lt
55BrFalse(158)
B13:
56ImmBorrowLoc[2](Arg2: vector<u64>)
57CopyLoc[6](loc2: u64)
58VecImmBorrow(7)
59ReadRef
60ImmBorrowLoc[3](Arg3: vector<address>)
61CopyLoc[6](loc2: u64)
62VecImmBorrow(118)
63ReadRef
64StLoc[8](loc4: address)
65StLoc[7](loc3: u64)
66CopyLoc[7](loc3: u64)
67LdU64(1)
68Ge
69BrFalse(84)
B14:
70CopyLoc[7](loc3: u64)
71CopyLoc[1](Arg1: &mut Collection)
72ImmBorrowField[1](Collection.supply: u64)
73ReadRef
74Le
75BrFalse(81)
B15:
76CopyLoc[8](loc4: address)
77LdConst[97](address: 0x00..)
78Neq
79StLoc[5](loc1: bool)
80Branch(86)
B16:
81LdFalse
82StLoc[5](loc1: bool)
83Branch(86)
B17:
84LdFalse
85StLoc[5](loc1: bool)
B18:
86MoveLoc[5](loc1: bool)
87BrFalse(89)
B19:
88Branch(93)
B20:
89MoveLoc[1](Arg1: &mut Collection)
90Pop
91LdConst[53](u64: 122)
92Abort
B21:
93CopyLoc[1](Arg1: &mut Collection)
94ImmBorrowField[8](Collection.reservations: Table<u64, address>)
95CopyLoc[7](loc3: u64)
96Call table::contains<u64, address>(&Table<u64, address>, u64): bool
97Not
98BrFalse(100)
B22:
99Branch(104)
B23:
100MoveLoc[1](Arg1: &mut Collection)
101Pop
102LdConst[62](u64: 132)
103Abort
B24:
104CopyLoc[1](Arg1: &mut Collection)
105FreezeRef
106Call legacy_state(&Collection): &State
107CopyLoc[7](loc3: u64)
108Call legacy::is_reserved(&State, u64): bool
109Not
110BrFalse(112)
B25:
111Branch(116)
B26:
112MoveLoc[1](Arg1: &mut Collection)
113Pop
114LdConst[53](u64: 122)
115Abort
B27:
116CopyLoc[1](Arg1: &mut Collection)
117CopyLoc[7](loc3: u64)
118Call remove_available(&mut Collection, u64)
119CopyLoc[1](Arg1: &mut Collection)
120ImmBorrowField[9](Collection.drawn: u64)
121ReadRef
122LdU64(1)
123Add
124CopyLoc[1](Arg1: &mut Collection)
125MutBorrowField[9](Collection.drawn: u64)
126WriteRef
127CopyLoc[1](Arg1: &mut Collection)
128ImmBorrowField[7](Collection.reserved_total: u64)
129ReadRef
130LdU64(1)
131Add
132CopyLoc[1](Arg1: &mut Collection)
133MutBorrowField[7](Collection.reserved_total: u64)
134WriteRef
135CopyLoc[1](Arg1: &mut Collection)
136MutBorrowField[8](Collection.reservations: Table<u64, address>)
137CopyLoc[7](loc3: u64)
138CopyLoc[8](loc4: address)
139Call table::add<u64, address>(&mut Table<u64, address>, u64, address)
140CopyLoc[1](Arg1: &mut Collection)
141MutBorrowField[10](Collection.id: UID)
142CopyLoc[7](loc3: u64)
143Pack[17](LaunchReservationKey)
144CopyLoc[8](loc4: address)
145Call dynamic_field::add<LaunchReservationKey, address>(&mut UID, LaunchReservationKey, address)
146CopyLoc[1](Arg1: &mut Collection)
147FreezeRef
148Call object::id<Collection>(&Collection): ID
149MoveLoc[7](loc3: u64)
150MoveLoc[8](loc4: address)
151Pack[16](Reserved)
152Call event::emit<Reserved>(Reserved)
153MoveLoc[6](loc2: u64)
154LdU64(1)
155Add
156StLoc[6](loc2: u64)
157Branch(51)
B28:
158MoveLoc[1](Arg1: &mut Collection)
159Pop
160Ret
}
public mint_launch_reserved<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: &mut Kiosk, Arg5: &KioskOwnerCap, Arg6: Coin<SUI>, Arg7: u64, Arg8: u64, Arg9: u64, Arg10: &Clock, Arg11: &mut TxContext) {
L12: loc0: bool
L13: loc1: KingFizh
L14: loc2: u64
L15: loc3: StakedSui
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[9](Arg9: u64)
3Call assert_revision(&Collection, u64)
4CopyLoc[1](Arg1: &mut Vault<Ty0>)
5FreezeRef
6Call check_vault<Ty0>(&Vault<Ty0>)
7CopyLoc[0](Arg0: &mut Collection)
8ImmBorrowField[6](Collection.mint_open: bool)
9ReadRef
10BrFalse(12)
B1:
11Branch(30)
B2:
12MoveLoc[1](Arg1: &mut Vault<Ty0>)
13Pop
14MoveLoc[2](Arg2: &mut SuiSystemState)
15Pop
16MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
17Pop
18MoveLoc[5](Arg5: &KioskOwnerCap)
19Pop
20MoveLoc[4](Arg4: &mut Kiosk)
21Pop
22MoveLoc[11](Arg11: &mut TxContext)
23Pop
24MoveLoc[0](Arg0: &mut Collection)
25Pop
26MoveLoc[10](Arg10: &Clock)
27Pop
28LdConst[32](u64: 101)
29Abort
B3:
30CopyLoc[0](Arg0: &mut Collection)
31FreezeRef
32LdU8(0)
33Call assert_action(&Collection, u8)
34CopyLoc[0](Arg0: &mut Collection)
35FreezeRef
36Call assert_configured(&Collection)
37CopyLoc[1](Arg1: &mut Vault<Ty0>)
38ImmBorrowFieldGeneric[0](Vault.collection: ID)
39ReadRef
40CopyLoc[0](Arg0: &mut Collection)
41FreezeRef
42Call object::id<Collection>(&Collection): ID
43Eq
44BrFalse(54)
B4:
45CopyLoc[1](Arg1: &mut Vault<Ty0>)
46FreezeRef
47Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
48CopyLoc[0](Arg0: &mut Collection)
49ImmBorrowField[12](Collection.vault: ID)
50ReadRef
51Eq
52StLoc[12](loc0: bool)
53Branch(56)
B5:
54LdFalse
55StLoc[12](loc0: bool)
B6:
56MoveLoc[12](loc0: bool)
57BrFalse(59)
B7:
58Branch(77)
B8:
59MoveLoc[1](Arg1: &mut Vault<Ty0>)
60Pop
61MoveLoc[2](Arg2: &mut SuiSystemState)
62Pop
63MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
64Pop
65MoveLoc[5](Arg5: &KioskOwnerCap)
66Pop
67MoveLoc[4](Arg4: &mut Kiosk)
68Pop
69MoveLoc[11](Arg11: &mut TxContext)
70Pop
71MoveLoc[0](Arg0: &mut Collection)
72Pop
73MoveLoc[10](Arg10: &Clock)
74Pop
75LdConst[41](u64: 110)
76Abort
B9:
77CopyLoc[3](Arg3: &TransferPolicy<KingFizh>)
78Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
79CopyLoc[0](Arg0: &mut Collection)
80ImmBorrowField[13](Collection.policy: ID)
81ReadRef
82Eq
83BrFalse(85)
B10:
84Branch(103)
B11:
85MoveLoc[1](Arg1: &mut Vault<Ty0>)
86Pop
87MoveLoc[2](Arg2: &mut SuiSystemState)
88Pop
89MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
90Pop
91MoveLoc[5](Arg5: &KioskOwnerCap)
92Pop
93MoveLoc[4](Arg4: &mut Kiosk)
94Pop
95MoveLoc[11](Arg11: &mut TxContext)
96Pop
97MoveLoc[0](Arg0: &mut Collection)
98Pop
99MoveLoc[10](Arg10: &Clock)
100Pop
101LdConst[49](u64: 118)
102Abort
B12:
103MoveLoc[10](Arg10: &Clock)
104Call clock::timestamp_ms(&Clock): u64
105CopyLoc[0](Arg0: &mut Collection)
106ImmBorrowField[14](Collection.holder_start_ms: u64)
107ReadRef
108Ge
109BrFalse(111)
B13:
110Branch(127)
B14:
111MoveLoc[1](Arg1: &mut Vault<Ty0>)
112Pop
113MoveLoc[2](Arg2: &mut SuiSystemState)
114Pop
115MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
116Pop
117MoveLoc[5](Arg5: &KioskOwnerCap)
118Pop
119MoveLoc[4](Arg4: &mut Kiosk)
120Pop
121MoveLoc[11](Arg11: &mut TxContext)
122Pop
123MoveLoc[0](Arg0: &mut Collection)
124Pop
125LdConst[65](u64: 135)
126Abort
B15:
127CopyLoc[0](Arg0: &mut Collection)
128ImmBorrowField[10](Collection.id: UID)
129CopyLoc[7](Arg7: u64)
130Pack[17](LaunchReservationKey)
131Call dynamic_field::exists<LaunchReservationKey>(&UID, LaunchReservationKey): bool
132BrFalse(134)
B16:
133Branch(150)
B17:
134MoveLoc[1](Arg1: &mut Vault<Ty0>)
135Pop
136MoveLoc[2](Arg2: &mut SuiSystemState)
137Pop
138MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
139Pop
140MoveLoc[5](Arg5: &KioskOwnerCap)
141Pop
142MoveLoc[4](Arg4: &mut Kiosk)
143Pop
144MoveLoc[11](Arg11: &mut TxContext)
145Pop
146MoveLoc[0](Arg0: &mut Collection)
147Pop
148LdConst[59](u64: 129)
149Abort
B18:
150CopyLoc[0](Arg0: &mut Collection)
151ImmBorrowField[8](Collection.reservations: Table<u64, address>)
152CopyLoc[7](Arg7: u64)
153Call table::borrow<u64, address>(&Table<u64, address>, u64): &address
154ReadRef
155CopyLoc[11](Arg11: &mut TxContext)
156FreezeRef
157Call tx_context::sender(&TxContext): address
158Eq
159BrFalse(161)
B19:
160Branch(177)
B20:
161MoveLoc[1](Arg1: &mut Vault<Ty0>)
162Pop
163MoveLoc[2](Arg2: &mut SuiSystemState)
164Pop
165MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
166Pop
167MoveLoc[5](Arg5: &KioskOwnerCap)
168Pop
169MoveLoc[4](Arg4: &mut Kiosk)
170Pop
171MoveLoc[11](Arg11: &mut TxContext)
172Pop
173MoveLoc[0](Arg0: &mut Collection)
174Pop
175LdConst[60](u64: 130)
176Abort
B21:
177CopyLoc[0](Arg0: &mut Collection)
178ImmBorrowField[15](Collection.stake_amount: u64)
179ReadRef
180StLoc[14](loc2: u64)
181CopyLoc[14](loc2: u64)
182MoveLoc[8](Arg8: u64)
183Le
184BrFalse(186)
B22:
185Branch(202)
B23:
186MoveLoc[1](Arg1: &mut Vault<Ty0>)
187Pop
188MoveLoc[2](Arg2: &mut SuiSystemState)
189Pop
190MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
191Pop
192MoveLoc[5](Arg5: &KioskOwnerCap)
193Pop
194MoveLoc[4](Arg4: &mut Kiosk)
195Pop
196MoveLoc[11](Arg11: &mut TxContext)
197Pop
198MoveLoc[0](Arg0: &mut Collection)
199Pop
200LdConst[35](u64: 104)
201Abort
B24:
202ImmBorrowLoc[6](Arg6: Coin<SUI>)
203Call coin::value<SUI>(&Coin<SUI>): u64
204CopyLoc[14](loc2: u64)
205Ge
206BrFalse(208)
B25:
207Branch(224)
B26:
208MoveLoc[1](Arg1: &mut Vault<Ty0>)
209Pop
210MoveLoc[2](Arg2: &mut SuiSystemState)
211Pop
212MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
213Pop
214MoveLoc[5](Arg5: &KioskOwnerCap)
215Pop
216MoveLoc[4](Arg4: &mut Kiosk)
217Pop
218MoveLoc[11](Arg11: &mut TxContext)
219Pop
220MoveLoc[0](Arg0: &mut Collection)
221Pop
222LdConst[34](u64: 103)
223Abort
B27:
224CopyLoc[0](Arg0: &mut Collection)
225MutBorrowField[8](Collection.reservations: Table<u64, address>)
226CopyLoc[7](Arg7: u64)
227Call table::remove<u64, address>(&mut Table<u64, address>, u64): address
228Pop
229CopyLoc[0](Arg0: &mut Collection)
230MutBorrowField[10](Collection.id: UID)
231CopyLoc[7](Arg7: u64)
232Pack[17](LaunchReservationKey)
233Call dynamic_field::remove<LaunchReservationKey, address>(&mut UID, LaunchReservationKey): address
234Pop
235MoveLoc[2](Arg2: &mut SuiSystemState)
236MutBorrowLoc[6](Arg6: Coin<SUI>)
237MoveLoc[14](loc2: u64)
238CopyLoc[11](Arg11: &mut TxContext)
239Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>
240CopyLoc[0](Arg0: &mut Collection)
241ImmBorrowField[16](Collection.validator: address)
242ReadRef
243CopyLoc[11](Arg11: &mut TxContext)
244Call sui_system::request_add_stake_non_entry(&mut SuiSystemState, Coin<SUI>, address, &mut TxContext): StakedSui
245StLoc[15](loc3: StakedSui)
246MoveLoc[0](Arg0: &mut Collection)
247MoveLoc[1](Arg1: &mut Vault<Ty0>)
248MoveLoc[15](loc3: StakedSui)
249MoveLoc[7](Arg7: u64)
250LdConst[26](u64: 1844..)
251LdTrue
252CopyLoc[11](Arg11: &mut TxContext)
253Call forge<Ty0>(&mut Collection, &mut Vault<Ty0>, StakedSui, u64, u64, bool, &mut TxContext): KingFizh
254StLoc[13](loc1: KingFizh)
255MoveLoc[4](Arg4: &mut Kiosk)
256MoveLoc[5](Arg5: &KioskOwnerCap)
257MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
258MoveLoc[13](loc1: KingFizh)
259Call kiosk::lock<KingFizh>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<KingFizh>, KingFizh)
260ImmBorrowLoc[6](Arg6: Coin<SUI>)
261Call coin::value<SUI>(&Coin<SUI>): u64
262LdU64(0)
263Eq
264BrFalse(270)
B28:
265MoveLoc[11](Arg11: &mut TxContext)
266Pop
267MoveLoc[6](Arg6: Coin<SUI>)
268Call coin::destroy_zero<SUI>(Coin<SUI>)
269Branch(275)
B29:
270MoveLoc[6](Arg6: Coin<SUI>)
271MoveLoc[11](Arg11: &mut TxContext)
272FreezeRef
273Call tx_context::sender(&TxContext): address
274Call send_sui(Coin<SUI>, address)
B30:
275Ret
}
remove_available(Arg0: &mut Collection, Arg1: u64) {
L2: loc0: u64
L3: loc1: bool
L4: loc2: u64
L5: loc3: u64
L6: loc4: u64
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[17](Collection.moved: Table<u64, u64>)
2CopyLoc[1](Arg1: u64)
3Call table::contains<u64, u64>(&Table<u64, u64>, u64): bool
4BrFalse(11)
B1:
5CopyLoc[0](Arg0: &mut Collection)
6MutBorrowField[17](Collection.moved: Table<u64, u64>)
7CopyLoc[1](Arg1: u64)
8Call table::remove<u64, u64>(&mut Table<u64, u64>, u64): u64
9StLoc[2](loc0: u64)
10Branch(15)
B2:
11CopyLoc[1](Arg1: u64)
12LdU64(1)
13Sub
14StLoc[2](loc0: u64)
B3:
15MoveLoc[2](loc0: u64)
16StLoc[6](loc4: u64)
17CopyLoc[6](loc4: u64)
18CopyLoc[0](Arg0: &mut Collection)
19ImmBorrowField[4](Collection.pool: vector<u16>)
20VecLen(173)
21Lt
22BrFalse(33)
B4:
23CopyLoc[0](Arg0: &mut Collection)
24ImmBorrowField[4](Collection.pool: vector<u16>)
25CopyLoc[6](loc4: u64)
26VecImmBorrow(173)
27ReadRef
28CastU64
29MoveLoc[1](Arg1: u64)
30Eq
31StLoc[3](loc1: bool)
32Branch(35)
B5:
33LdFalse
34StLoc[3](loc1: bool)
B6:
35MoveLoc[3](loc1: bool)
36BrFalse(38)
B7:
37Branch(42)
B8:
38MoveLoc[0](Arg0: &mut Collection)
39Pop
40LdConst[53](u64: 122)
41Abort
B9:
42CopyLoc[0](Arg0: &mut Collection)
43ImmBorrowField[4](Collection.pool: vector<u16>)
44VecLen(173)
45LdU64(1)
46Sub
47StLoc[4](loc2: u64)
48CopyLoc[6](loc4: u64)
49CopyLoc[4](loc2: u64)
50Neq
51BrFalse(76)
B10:
52CopyLoc[0](Arg0: &mut Collection)
53ImmBorrowField[4](Collection.pool: vector<u16>)
54MoveLoc[4](loc2: u64)
55VecImmBorrow(173)
56ReadRef
57CastU64
58StLoc[5](loc3: u64)
59CopyLoc[0](Arg0: &mut Collection)
60ImmBorrowField[17](Collection.moved: Table<u64, u64>)
61CopyLoc[5](loc3: u64)
62Call table::contains<u64, u64>(&Table<u64, u64>, u64): bool
63BrFalse(71)
B11:
64CopyLoc[6](loc4: u64)
65CopyLoc[0](Arg0: &mut Collection)
66MutBorrowField[17](Collection.moved: Table<u64, u64>)
67MoveLoc[5](loc3: u64)
68Call table::borrow_mut<u64, u64>(&mut Table<u64, u64>, u64): &mut u64
69WriteRef
70Branch(76)
B12:
71CopyLoc[0](Arg0: &mut Collection)
72MutBorrowField[17](Collection.moved: Table<u64, u64>)
73MoveLoc[5](loc3: u64)
74CopyLoc[6](loc4: u64)
75Call table::add<u64, u64>(&mut Table<u64, u64>, u64, u64)
B13:
76MoveLoc[0](Arg0: &mut Collection)
77MutBorrowField[4](Collection.pool: vector<u16>)
78MoveLoc[6](loc4: u64)
79Call vector::swap_remove<u16>(&mut vector<u16>, u64): u16
80Pop
81Ret
}
legacy_state(Arg0: &Collection): &State {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[10](Collection.id: UID)
2LdFalse
3Pack[4](LegacyStateKey)
4Call dynamic_field::borrow<LegacyStateKey, State>(&UID, LegacyStateKey): &State
5Ret
}
legacy_state_mut(Arg0: &mut Collection): &mut State {
B0:
0MoveLoc[0](Arg0: &mut Collection)
1MutBorrowField[10](Collection.id: UID)
2LdFalse
3Pack[4](LegacyStateKey)
4Call dynamic_field::borrow_mut<LegacyStateKey, State>(&mut UID, LegacyStateKey): &mut State
5Ret
}
assert_king<Ty0>() {
B0:
0Call type_name::with_defining_ids<Ty0>(): TypeName
1Call type_name::into_string(TypeName): String
2Call ascii::into_bytes(String): vector<u8>
3LdConst[100](vector<u8>: "5fa..)
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[36](u64: 105)
8Abort
B3:
9Ret
}
public set_king_metadata<Ty0>(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &CoinMetadata<Ty0>) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7Call assert_king<Ty0>()
8MoveLoc[1](Arg1: &mut Collection)
9Call legacy_state_mut(&mut Collection): &mut State
10MoveLoc[2](Arg2: &CoinMetadata<Ty0>)
11Call coin::get_decimals<Ty0>(&CoinMetadata<Ty0>): u8
12Call legacy::set_king_decimals(&mut State, u8)
13Ret
}
public configure_media(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut Display<KingFizh>, 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_collection(&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<KingFizh>)
14Pop
15MoveLoc[1](Arg1: &mut Collection)
16Pop
17LdConst[75](u64: 146)
18Abort
B3:
19MoveLoc[1](Arg1: &mut Collection)
20MoveLoc[2](Arg2: &mut Display<KingFizh>)
21MoveLoc[3](Arg3: String)
22Call configure_media_internal(&mut Collection, &mut Display<KingFizh>, String)
23Ret
}
configure_media_internal(Arg0: &mut Collection, Arg1: &mut Display<KingFizh>, Arg2: String) {
L3: loc0: bool
L4: loc1: String
L5: loc2: &String
L6: loc3: bool
L7: loc4: String
L8: loc5: String
L9: loc6: &mut Display<KingFizh>
L10: loc7: &vector<u8>
L11: loc8: VecMap<String, String>
L12: loc9: u64
L13: loc10: String
L14: loc11: &String
L15: loc12: vector<u8>
L16: loc13: &String
B0:
0ImmBorrowLoc[2](Arg2: String)
1Call string::as_bytes(&String): &vector<u8>
2StLoc[10](loc7: &vector<u8>)
3CopyLoc[10](loc7: &vector<u8>)
4VecLen(83)
5LdU64(8)
6Gt
7BrFalse(19)
B1:
8CopyLoc[10](loc7: &vector<u8>)
9CopyLoc[10](loc7: &vector<u8>)
10VecLen(83)
11LdU64(1)
12Sub
13VecImmBorrow(83)
14ReadRef
15LdU8(47)
16Eq
17StLoc[3](loc0: bool)
18Branch(21)
B2:
19LdFalse
20StLoc[3](loc0: bool)
B3:
21MoveLoc[3](loc0: bool)
22BrFalse(24)
B4:
23Branch(32)
B5:
24MoveLoc[1](Arg1: &mut Display<KingFizh>)
25Pop
26MoveLoc[0](Arg0: &mut Collection)
27Pop
28MoveLoc[10](loc7: &vector<u8>)
29Pop
30LdConst[40](u64: 109)
31Abort
B6:
32LdConst[101](vector<u8>: "htt..)
33StLoc[15](loc12: vector<u8>)
34LdU64(0)
35StLoc[12](loc9: u64)
B7:
36CopyLoc[12](loc9: u64)
37ImmBorrowLoc[15](loc12: vector<u8>)
38VecLen(83)
39Lt
40BrFalse(65)
B8:
41CopyLoc[10](loc7: &vector<u8>)
42CopyLoc[12](loc9: u64)
43VecImmBorrow(83)
44ReadRef
45ImmBorrowLoc[15](loc12: vector<u8>)
46CopyLoc[12](loc9: u64)
47VecImmBorrow(83)
48ReadRef
49Eq
50BrFalse(52)
B9:
51Branch(60)
B10:
52MoveLoc[1](Arg1: &mut Display<KingFizh>)
53Pop
54MoveLoc[0](Arg0: &mut Collection)
55Pop
56MoveLoc[10](loc7: &vector<u8>)
57Pop
58LdConst[40](u64: 109)
59Abort
B11:
60MoveLoc[12](loc9: u64)
61LdU64(1)
62Add
63StLoc[12](loc9: u64)
64Branch(36)
B12:
65ImmBorrowLoc[2](Arg2: String)
66StLoc[5](loc2: &String)
67LdConst[102](vector<u8>: ".in..)
68Call string::utf8(vector<u8>): String
69StLoc[4](loc1: String)
70MoveLoc[5](loc2: &String)
71ImmBorrowLoc[4](loc1: String)
72Call string::index_of(&String, &String): u64
73MoveLoc[10](loc7: &vector<u8>)
74VecLen(83)
75Eq
76BrFalse(78)
B13:
77Branch(84)
B14:
78MoveLoc[1](Arg1: &mut Display<KingFizh>)
79Pop
80MoveLoc[0](Arg0: &mut Collection)
81Pop
82LdConst[40](u64: 109)
83Abort
B15:
84MoveLoc[0](Arg0: &mut Collection)
85Call legacy_state_mut(&mut Collection): &mut State
86CopyLoc[1](Arg1: &mut Display<KingFizh>)
87FreezeRef
88Call object::id<Display<KingFizh>>(&Display<KingFizh>): ID
89Call legacy::confirm_media(&mut State, ID)
90MoveLoc[2](Arg2: String)
91StLoc[13](loc10: String)
92MutBorrowLoc[13](loc10: String)
93LdConst[103](vector<u8>: "{me..)
94Call string::utf8(vector<u8>): String
95Call string::append(&mut String, String)
96CopyLoc[1](Arg1: &mut Display<KingFizh>)
97FreezeRef
98Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
99ReadRef
100StLoc[11](loc8: VecMap<String, String>)
101LdU64(0)
102StLoc[12](loc9: u64)
B16:
103CopyLoc[12](loc9: u64)
104ImmBorrowLoc[11](loc8: VecMap<String, String>)
105Call vec_map::length<String, String>(&VecMap<String, String>): u64
106Lt
107BrFalse(155)
B17:
108ImmBorrowLoc[11](loc8: VecMap<String, String>)
109CopyLoc[12](loc9: u64)
110Call vec_map::get_entry_by_idx<String, String>(&VecMap<String, String>, u64): &String * &String
111StLoc[16](loc13: &String)
112StLoc[14](loc11: &String)
113CopyLoc[1](Arg1: &mut Display<KingFizh>)
114StLoc[9](loc6: &mut Display<KingFizh>)
115CopyLoc[14](loc11: &String)
116ReadRef
117StLoc[8](loc5: String)
118CopyLoc[14](loc11: &String)
119ReadRef
120LdConst[84](vector<u8>: "ima..)
121Call string::utf8(vector<u8>): String
122Eq
123BrFalse(129)
B18:
124MoveLoc[14](loc11: &String)
125Pop
126LdTrue
127StLoc[6](loc3: bool)
128Branch(136)
B19:
129MoveLoc[14](loc11: &String)
130ReadRef
131LdConst[85](vector<u8>: "thu..)
132Call string::utf8(vector<u8>): String
133Eq
134StLoc[6](loc3: bool)
135Branch(136)
B20:
136MoveLoc[6](loc3: bool)
137BrFalse(143)
B21:
138MoveLoc[16](loc13: &String)
139Pop
140CopyLoc[13](loc10: String)
141StLoc[7](loc4: String)
142Branch(146)
B22:
143MoveLoc[16](loc13: &String)
144ReadRef
145StLoc[7](loc4: String)
B23:
146MoveLoc[9](loc6: &mut Display<KingFizh>)
147MoveLoc[8](loc5: String)
148MoveLoc[7](loc4: String)
149Call display::edit<KingFizh>(&mut Display<KingFizh>, String, String)
150MoveLoc[12](loc9: u64)
151LdU64(1)
152Add
153StLoc[12](loc9: u64)
154Branch(103)
B24:
155MoveLoc[1](Arg1: &mut Display<KingFizh>)
156Call display::update_version<KingFizh>(&mut Display<KingFizh>)
157Ret
}
public create_display_v2(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut DisplayRegistry, Arg3: &Display<KingFizh>, Arg4: vector<String>, Arg5: vector<String>, Arg6: &mut TxContext) {
L7: loc0: ID
L8: loc1: bool
L9: loc2: DisplayCap<KingFizh>
L10: loc3: u64
L11: loc4: vector<String>
L12: loc5: Display<KingFizh>
L13: loc6: 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_collection(&Collection)
7CopyLoc[2](Arg2: &mut DisplayRegistry)
8FreezeRef
9Call object::id<DisplayRegistry>(&DisplayRegistry): ID
10StLoc[7](loc0: ID)
11ImmBorrowLoc[7](loc0: ID)
12Call object::id_to_address(&ID): address
13LdConst[104](address: 0x00..)
14Eq
15BrFalse(17)
B1:
16Branch(27)
B2:
17MoveLoc[3](Arg3: &Display<KingFizh>)
18Pop
19MoveLoc[2](Arg2: &mut DisplayRegistry)
20Pop
21MoveLoc[6](Arg6: &mut TxContext)
22Pop
23MoveLoc[1](Arg1: &mut Collection)
24Pop
25LdConst[73](u64: 144)
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<KingFizh>)
34Pop
35MoveLoc[2](Arg2: &mut DisplayRegistry)
36Pop
37MoveLoc[6](Arg6: &mut TxContext)
38Pop
39MoveLoc[1](Arg1: &mut Collection)
40Pop
41LdConst[73](u64: 144)
42Abort
B6:
43CopyLoc[1](Arg1: &mut Collection)
44FreezeRef
45Call legacy_state(&Collection): &State
46CopyLoc[3](Arg3: &Display<KingFizh>)
47Call object::id<Display<KingFizh>>(&Display<KingFizh>): ID
48Call legacy::assert_media_ready(&State, ID)
49CopyLoc[3](Arg3: &Display<KingFizh>)
50Call assert_v1_fields(&Display<KingFizh>)
51CopyLoc[1](Arg1: &mut Collection)
52FreezeRef
53CopyLoc[3](Arg3: &Display<KingFizh>)
54Call display_v2_extras(&Collection, &Display<KingFizh>): vector<String> * vector<String>
55StLoc[13](loc6: vector<String>)
56StLoc[11](loc4: vector<String>)
57MoveLoc[4](Arg4: vector<String>)
58CopyLoc[11](loc4: vector<String>)
59Eq
60BrFalse(66)
B7:
61MoveLoc[5](Arg5: vector<String>)
62CopyLoc[13](loc6: vector<String>)
63Eq
64StLoc[8](loc1: bool)
65Branch(68)
B8:
66LdFalse
67StLoc[8](loc1: bool)
B9:
68MoveLoc[8](loc1: bool)
69BrFalse(71)
B10:
70Branch(81)
B11:
71MoveLoc[3](Arg3: &Display<KingFizh>)
72Pop
73MoveLoc[2](Arg2: &mut DisplayRegistry)
74Pop
75MoveLoc[6](Arg6: &mut TxContext)
76Pop
77MoveLoc[1](Arg1: &mut Collection)
78Pop
79LdConst[74](u64: 145)
80Abort
B12:
81MoveLoc[2](Arg2: &mut DisplayRegistry)
82Call internal::permit<KingFizh>(): Permit<KingFizh>
83MoveLoc[6](Arg6: &mut TxContext)
84Call display_registry::new<KingFizh>(&mut DisplayRegistry, Permit<KingFizh>, &mut TxContext): Display<KingFizh> * DisplayCap<KingFizh>
85StLoc[9](loc2: DisplayCap<KingFizh>)
86StLoc[12](loc5: Display<KingFizh>)
87CopyLoc[3](Arg3: &Display<KingFizh>)
88MutBorrowLoc[12](loc5: Display<KingFizh>)
89ImmBorrowLoc[9](loc2: DisplayCap<KingFizh>)
90Call copy_display_fields(&Display<KingFizh>, &mut Display<KingFizh>, &DisplayCap<KingFizh>)
91LdU64(0)
92StLoc[10](loc3: u64)
B13:
93CopyLoc[10](loc3: u64)
94ImmBorrowLoc[11](loc4: vector<String>)
95VecLen(25)
96Lt
97BrFalse(129)
B14:
98CopyLoc[3](Arg3: &Display<KingFizh>)
99Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
100ImmBorrowLoc[11](loc4: vector<String>)
101CopyLoc[10](loc3: u64)
102VecImmBorrow(25)
103Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
104Not
105BrFalse(107)
B15:
106Branch(113)
B16:
107MoveLoc[3](Arg3: &Display<KingFizh>)
108Pop
109MoveLoc[1](Arg1: &mut Collection)
110Pop
111LdConst[74](u64: 145)
112Abort
B17:
113MutBorrowLoc[12](loc5: Display<KingFizh>)
114ImmBorrowLoc[9](loc2: DisplayCap<KingFizh>)
115ImmBorrowLoc[11](loc4: vector<String>)
116CopyLoc[10](loc3: u64)
117VecImmBorrow(25)
118ReadRef
119ImmBorrowLoc[13](loc6: vector<String>)
120CopyLoc[10](loc3: u64)
121VecImmBorrow(25)
122ReadRef
123Call display_registry::set<KingFizh>(&mut Display<KingFizh>, &DisplayCap<KingFizh>, String, String)
124MoveLoc[10](loc3: u64)
125LdU64(1)
126Add
127StLoc[10](loc3: u64)
128Branch(93)
B18:
129MoveLoc[3](Arg3: &Display<KingFizh>)
130Pop
131MoveLoc[12](loc5: Display<KingFizh>)
132Call display_registry::share<KingFizh>(Display<KingFizh>)
133MoveLoc[1](Arg1: &mut Collection)
134MutBorrowField[10](Collection.id: UID)
135LdFalse
136Pack[3](DisplayCapKey)
137MoveLoc[9](loc2: DisplayCap<KingFizh>)
138Call dynamic_field::add<DisplayCapKey, DisplayCap<KingFizh>>(&mut UID, DisplayCapKey, DisplayCap<KingFizh>)
139Ret
}
public has_display_v2(Arg0: &Collection): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[10](Collection.id: UID)
2LdFalse
3Pack[3](DisplayCapKey)
4Call dynamic_field::exists<DisplayCapKey>(&UID, DisplayCapKey): bool
5Ret
}
public display_v2_extras(Arg0: &Collection, Arg1: &Display<KingFizh>): vector<String> * vector<String> {
L2: loc0: ID
L3: loc1: &mut String
L4: loc2: String
B0:
0CopyLoc[0](Arg0: &Collection)
1Call legacy_state(&Collection): &State
2CopyLoc[1](Arg1: &Display<KingFizh>)
3Call object::id<Display<KingFizh>>(&Display<KingFizh>): ID
4Call legacy::assert_media_ready(&State, ID)
5LdConst[105](vector<u8>: "0x"..)
6Call string::utf8(vector<u8>): String
7StLoc[4](loc2: String)
8MutBorrowLoc[4](loc2: String)
9StLoc[3](loc1: &mut String)
10MoveLoc[0](Arg0: &Collection)
11Call object::id<Collection>(&Collection): ID
12StLoc[2](loc0: ID)
13MoveLoc[3](loc1: &mut String)
14ImmBorrowLoc[2](loc0: ID)
15Call object::id_to_address(&ID): address
16Call address::to_string(address): String
17Call string::append(&mut String, String)
18LdConst[106](vector<u8>: "att..)
19Call string::utf8(vector<u8>): String
20LdConst[107](vector<u8>: "ind..)
21Call string::utf8(vector<u8>): String
22LdConst[108](vector<u8>: "col..)
23Call string::utf8(vector<u8>): String
24LdConst[109](vector<u8>: "col..)
25Call string::utf8(vector<u8>): String
26LdConst[110](vector<u8>: "col..)
27Call string::utf8(vector<u8>): String
28LdConst[111](vector<u8>: "col..)
29Call string::utf8(vector<u8>): String
30VecPack(25, 6)
31LdConst[112](vector<u8>: "{at..)
32Call string::utf8(vector<u8>): String
33LdConst[113](vector<u8>: "{in..)
34Call string::utf8(vector<u8>): String
35LdConst[0](vector<u8>: "Kin..)
36Call string::utf8(vector<u8>): String
37LdConst[0](vector<u8>: "Kin..)
38Call string::utf8(vector<u8>): String
39MoveLoc[1](Arg1: &Display<KingFizh>)
40Call display_cover(&Display<KingFizh>): String
41MoveLoc[4](loc2: String)
42VecPack(25, 6)
43Ret
}
display_cover(Arg0: &Display<KingFizh>): String {
L1: loc0: String
L2: loc1: &VecMap<String, String>
L3: loc2: u64
L4: loc3: &vector<u8>
L5: loc4: String
L6: loc5: &String
L7: loc6: vector<u8>
B0:
0MoveLoc[0](Arg0: &Display<KingFizh>)
1Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
2StLoc[2](loc1: &VecMap<String, String>)
3LdConst[84](vector<u8>: "ima..)
4Call string::utf8(vector<u8>): String
5StLoc[1](loc0: String)
6MoveLoc[2](loc1: &VecMap<String, String>)
7ImmBorrowLoc[1](loc0: String)
8Call vec_map::get<String, String>(&VecMap<String, String>, &String): &String
9StLoc[6](loc5: &String)
10LdConst[103](vector<u8>: "{me..)
11StLoc[7](loc6: vector<u8>)
12CopyLoc[6](loc5: &String)
13Call string::as_bytes(&String): &vector<u8>
14StLoc[4](loc3: &vector<u8>)
15CopyLoc[4](loc3: &vector<u8>)
16VecLen(83)
17ImmBorrowLoc[7](loc6: vector<u8>)
18VecLen(83)
19Ge
20BrFalse(22)
B1:
21Branch(28)
B2:
22MoveLoc[6](loc5: &String)
23Pop
24MoveLoc[4](loc3: &vector<u8>)
25Pop
26LdConst[74](u64: 145)
27Abort
B3:
28CopyLoc[4](loc3: &vector<u8>)
29VecLen(83)
30ImmBorrowLoc[7](loc6: vector<u8>)
31VecLen(83)
32Sub
33StLoc[3](loc2: u64)
34CopyLoc[6](loc5: &String)
35CopyLoc[3](loc2: u64)
36MoveLoc[4](loc3: &vector<u8>)
37VecLen(83)
38Call string::substring(&String, u64, u64): String
39MoveLoc[7](loc6: vector<u8>)
40Call string::utf8(vector<u8>): String
41Eq
42BrFalse(44)
B4:
43Branch(48)
B5:
44MoveLoc[6](loc5: &String)
45Pop
46LdConst[74](u64: 145)
47Abort
B6:
48MoveLoc[6](loc5: &String)
49LdU64(0)
50MoveLoc[3](loc2: u64)
51Call string::substring(&String, u64, u64): String
52StLoc[5](loc4: String)
53MutBorrowLoc[5](loc4: String)
54LdConst[114](vector<u8>: "tok..)
55Call string::utf8(vector<u8>): String
56Call string::append(&mut String, String)
57MoveLoc[5](loc4: String)
58Ret
}
assert_v1_fields(Arg0: &Display<KingFizh>) {
L1: loc0: &VecMap<String, String>
L2: loc1: u64
L3: loc2: vector<String>
B0:
0LdConst[82](vector<u8>: "nam..)
1Call string::utf8(vector<u8>): String
2LdConst[83](vector<u8>: "des..)
3Call string::utf8(vector<u8>): String
4LdConst[84](vector<u8>: "ima..)
5Call string::utf8(vector<u8>): String
6LdConst[85](vector<u8>: "thu..)
7Call string::utf8(vector<u8>): String
8LdConst[86](vector<u8>: "lin..)
9Call string::utf8(vector<u8>): String
10LdConst[87](vector<u8>: "pro..)
11Call string::utf8(vector<u8>): String
12LdConst[88](vector<u8>: "cre..)
13Call string::utf8(vector<u8>): String
14LdConst[89](vector<u8>: "num..)
15Call string::utf8(vector<u8>): String
16LdConst[90](vector<u8>: "sta..)
17Call string::utf8(vector<u8>): String
18LdConst[91](vector<u8>: "pri..)
19Call string::utf8(vector<u8>): String
20LdConst[92](vector<u8>: "val..)
21Call string::utf8(vector<u8>): String
22VecPack(25, 11)
23StLoc[3](loc2: vector<String>)
24MoveLoc[0](Arg0: &Display<KingFizh>)
25Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
26StLoc[1](loc0: &VecMap<String, String>)
27CopyLoc[1](loc0: &VecMap<String, String>)
28Call vec_map::length<String, String>(&VecMap<String, String>): u64
29ImmBorrowLoc[3](loc2: vector<String>)
30VecLen(25)
31Eq
32BrFalse(34)
B1:
33Branch(38)
B2:
34MoveLoc[1](loc0: &VecMap<String, String>)
35Pop
36LdConst[74](u64: 145)
37Abort
B3:
38LdU64(0)
39StLoc[2](loc1: u64)
B4:
40CopyLoc[2](loc1: u64)
41ImmBorrowLoc[3](loc2: vector<String>)
42VecLen(25)
43Lt
44BrFalse(66)
B5:
45CopyLoc[1](loc0: &VecMap<String, String>)
46CopyLoc[2](loc1: u64)
47Call vec_map::get_entry_by_idx<String, String>(&VecMap<String, String>, u64): &String * &String
48Pop
49ReadRef
50ImmBorrowLoc[3](loc2: vector<String>)
51CopyLoc[2](loc1: u64)
52VecImmBorrow(25)
53ReadRef
54Eq
55BrFalse(57)
B6:
56Branch(61)
B7:
57MoveLoc[1](loc0: &VecMap<String, String>)
58Pop
59LdConst[74](u64: 145)
60Abort
B8:
61MoveLoc[2](loc1: u64)
62LdU64(1)
63Add
64StLoc[2](loc1: u64)
65Branch(40)
B9:
66CopyLoc[1](loc0: &VecMap<String, String>)
67ImmBorrowLoc[3](loc2: vector<String>)
68LdU64(0)
69VecImmBorrow(25)
70Call vec_map::get<String, String>(&VecMap<String, String>, &String): &String
71ReadRef
72LdConst[11](vector<u8>: "Kin..)
73Call string::utf8(vector<u8>): String
74Eq
75BrFalse(77)
B10:
76Branch(81)
B11:
77MoveLoc[1](loc0: &VecMap<String, String>)
78Pop
79LdConst[74](u64: 145)
80Abort
B12:
81CopyLoc[1](loc0: &VecMap<String, String>)
82ImmBorrowLoc[3](loc2: vector<String>)
83LdU64(1)
84VecImmBorrow(25)
85Call vec_map::get<String, String>(&VecMap<String, String>, &String): &String
86ReadRef
87LdConst[0](vector<u8>: "Kin..)
88Call string::utf8(vector<u8>): String
89Eq
90BrFalse(92)
B13:
91Branch(96)
B14:
92MoveLoc[1](loc0: &VecMap<String, String>)
93Pop
94LdConst[74](u64: 145)
95Abort
B15:
96CopyLoc[1](loc0: &VecMap<String, String>)
97ImmBorrowLoc[3](loc2: vector<String>)
98LdU64(2)
99VecImmBorrow(25)
100Call vec_map::get<String, String>(&VecMap<String, String>, &String): &String
101ReadRef
102MoveLoc[1](loc0: &VecMap<String, String>)
103ImmBorrowLoc[3](loc2: vector<String>)
104LdU64(3)
105VecImmBorrow(25)
106Call vec_map::get<String, String>(&VecMap<String, String>, &String): &String
107ReadRef
108Eq
109BrFalse(111)
B16:
110Branch(113)
B17:
111LdConst[74](u64: 145)
112Abort
B18:
113Ret
}
copy_display_fields(Arg0: &Display<KingFizh>, Arg1: &mut Display<KingFizh>, Arg2: &DisplayCap<KingFizh>) {
L3: loc0: VecMap<String, String>
L4: loc1: u64
L5: loc2: &String
L6: loc3: &String
L7: loc4: &String
L8: loc5: &String
B0:
0CopyLoc[1](Arg1: &mut Display<KingFizh>)
1FreezeRef
2Call display_registry::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
3ReadRef
4StLoc[3](loc0: VecMap<String, String>)
5LdU64(0)
6StLoc[4](loc1: u64)
B1:
7CopyLoc[4](loc1: u64)
8CopyLoc[0](Arg0: &Display<KingFizh>)
9Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
10Call vec_map::length<String, String>(&VecMap<String, String>): u64
11Lt
12BrFalse(32)
B2:
13Branch(14)
B3:
14CopyLoc[0](Arg0: &Display<KingFizh>)
15Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
16CopyLoc[4](loc1: u64)
17Call vec_map::get_entry_by_idx<String, String>(&VecMap<String, String>, u64): &String * &String
18StLoc[7](loc4: &String)
19StLoc[5](loc2: &String)
20CopyLoc[1](Arg1: &mut Display<KingFizh>)
21CopyLoc[2](Arg2: &DisplayCap<KingFizh>)
22MoveLoc[5](loc2: &String)
23ReadRef
24MoveLoc[7](loc4: &String)
25ReadRef
26Call display_registry::set<KingFizh>(&mut Display<KingFizh>, &DisplayCap<KingFizh>, String, String)
27MoveLoc[4](loc1: u64)
28LdU64(1)
29Add
30StLoc[4](loc1: u64)
31Branch(7)
B4:
32LdU64(0)
33StLoc[4](loc1: u64)
B5:
34CopyLoc[4](loc1: u64)
35ImmBorrowLoc[3](loc0: VecMap<String, String>)
36Call vec_map::length<String, String>(&VecMap<String, String>): u64
37Lt
38BrFalse(68)
B6:
39Branch(40)
B7:
40ImmBorrowLoc[3](loc0: VecMap<String, String>)
41CopyLoc[4](loc1: u64)
42Call vec_map::get_entry_by_idx<String, String>(&VecMap<String, String>, u64): &String * &String
43StLoc[8](loc5: &String)
44StLoc[6](loc3: &String)
45CopyLoc[0](Arg0: &Display<KingFizh>)
46Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
47CopyLoc[6](loc3: &String)
48Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
49Not
50BrFalse(59)
B8:
51CopyLoc[1](Arg1: &mut Display<KingFizh>)
52CopyLoc[2](Arg2: &DisplayCap<KingFizh>)
53MoveLoc[6](loc3: &String)
54ReadRef
55MoveLoc[8](loc5: &String)
56ReadRef
57Call display_registry::set<KingFizh>(&mut Display<KingFizh>, &DisplayCap<KingFizh>, String, String)
58Branch(63)
B9:
59MoveLoc[8](loc5: &String)
60Pop
61MoveLoc[6](loc3: &String)
62Pop
B10:
63MoveLoc[4](loc1: u64)
64LdU64(1)
65Add
66StLoc[4](loc1: u64)
67Branch(34)
B11:
68MoveLoc[1](Arg1: &mut Display<KingFizh>)
69Pop
70MoveLoc[0](Arg0: &Display<KingFizh>)
71Pop
72MoveLoc[2](Arg2: &DisplayCap<KingFizh>)
73Pop
74Ret
}
public sync_display_v2(Arg0: &AdminCap, Arg1: &Collection, Arg2: &Display<KingFizh>, Arg3: &mut Display<KingFizh>) {
L4: loc0: &DisplayCap<KingFizh>
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &Collection)
2Call assert_admin(&AdminCap, &Collection)
3CopyLoc[1](Arg1: &Collection)
4Call check_collection(&Collection)
5CopyLoc[1](Arg1: &Collection)
6Call legacy_state(&Collection): &State
7CopyLoc[2](Arg2: &Display<KingFizh>)
8Call object::id<Display<KingFizh>>(&Display<KingFizh>): ID
9Call legacy::assert_media_ready(&State, ID)
10CopyLoc[2](Arg2: &Display<KingFizh>)
11Call assert_v1_fields(&Display<KingFizh>)
12CopyLoc[1](Arg1: &Collection)
13Call has_display_v2(&Collection): bool
14BrFalse(16)
B1:
15Branch(24)
B2:
16MoveLoc[3](Arg3: &mut Display<KingFizh>)
17Pop
18MoveLoc[2](Arg2: &Display<KingFizh>)
19Pop
20MoveLoc[1](Arg1: &Collection)
21Pop
22LdConst[72](u64: 143)
23Abort
B3:
24MoveLoc[1](Arg1: &Collection)
25ImmBorrowField[10](Collection.id: UID)
26LdFalse
27Pack[3](DisplayCapKey)
28Call dynamic_field::borrow<DisplayCapKey, DisplayCap<KingFizh>>(&UID, DisplayCapKey): &DisplayCap<KingFizh>
29StLoc[4](loc0: &DisplayCap<KingFizh>)
30CopyLoc[3](Arg3: &mut Display<KingFizh>)
31FreezeRef
32Call display_registry::cap_id<KingFizh>(&Display<KingFizh>): Option<ID>
33CopyLoc[4](loc0: &DisplayCap<KingFizh>)
34Call object::id<DisplayCap<KingFizh>>(&DisplayCap<KingFizh>): ID
35Call option::some<ID>(ID): Option<ID>
36Eq
37BrFalse(39)
B4:
38Branch(47)
B5:
39MoveLoc[3](Arg3: &mut Display<KingFizh>)
40Pop
41MoveLoc[2](Arg2: &Display<KingFizh>)
42Pop
43MoveLoc[4](loc0: &DisplayCap<KingFizh>)
44Pop
45LdConst[73](u64: 144)
46Abort
B6:
47MoveLoc[2](Arg2: &Display<KingFizh>)
48MoveLoc[3](Arg3: &mut Display<KingFizh>)
49MoveLoc[4](loc0: &DisplayCap<KingFizh>)
50Call copy_display_fields(&Display<KingFizh>, &mut Display<KingFizh>, &DisplayCap<KingFizh>)
51Ret
}
public configure_media_and_sync(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut Display<KingFizh>, Arg3: &mut Display<KingFizh>, Arg4: String) {
L5: loc0: bool
L6: loc1: String
L7: loc2: String
L8: loc3: &DisplayCap<KingFizh>
L9: loc4: &mut Display<KingFizh>
L10: loc5: &DisplayCap<KingFizh>
L11: loc6: &String
L12: loc7: u64
L13: loc8: String
L14: loc9: String
L15: loc10: VecMap<String, String>
L16: loc11: &String
B0:
0CopyLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7CopyLoc[2](Arg2: &mut Display<KingFizh>)
8FreezeRef
9Call display_cover(&Display<KingFizh>): String
10StLoc[14](loc9: String)
11CopyLoc[3](Arg3: &mut Display<KingFizh>)
12FreezeRef
13Call display_registry::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
14ReadRef
15StLoc[15](loc10: VecMap<String, String>)
16CopyLoc[1](Arg1: &mut Collection)
17CopyLoc[2](Arg2: &mut Display<KingFizh>)
18MoveLoc[4](Arg4: String)
19Call configure_media_internal(&mut Collection, &mut Display<KingFizh>, String)
20MoveLoc[0](Arg0: &AdminCap)
21CopyLoc[1](Arg1: &mut Collection)
22FreezeRef
23CopyLoc[2](Arg2: &mut Display<KingFizh>)
24FreezeRef
25CopyLoc[3](Arg3: &mut Display<KingFizh>)
26Call sync_display_v2(&AdminCap, &Collection, &Display<KingFizh>, &mut Display<KingFizh>)
27MoveLoc[1](Arg1: &mut Collection)
28ImmBorrowField[10](Collection.id: UID)
29LdFalse
30Pack[3](DisplayCapKey)
31Call dynamic_field::borrow<DisplayCapKey, DisplayCap<KingFizh>>(&UID, DisplayCapKey): &DisplayCap<KingFizh>
32StLoc[10](loc5: &DisplayCap<KingFizh>)
33LdConst[110](vector<u8>: "col..)
34Call string::utf8(vector<u8>): String
35StLoc[13](loc8: String)
36CopyLoc[3](Arg3: &mut Display<KingFizh>)
37FreezeRef
38Call display_registry::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
39ImmBorrowLoc[13](loc8: String)
40Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
41BrFalse(52)
B1:
42CopyLoc[3](Arg3: &mut Display<KingFizh>)
43FreezeRef
44Call display_registry::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
45ImmBorrowLoc[13](loc8: String)
46Call vec_map::get<String, String>(&VecMap<String, String>, &String): &String
47ReadRef
48MoveLoc[14](loc9: String)
49Eq
50StLoc[5](loc0: bool)
51Branch(54)
B2:
52LdFalse
53StLoc[5](loc0: bool)
B3:
54MoveLoc[5](loc0: bool)
55BrFalse(120)
B4:
56LdU64(0)
57StLoc[12](loc7: u64)
B5:
58CopyLoc[12](loc7: u64)
59ImmBorrowLoc[15](loc10: VecMap<String, String>)
60Call vec_map::length<String, String>(&VecMap<String, String>): u64
61Lt
62BrFalse(113)
B6:
63Branch(64)
B7:
64ImmBorrowLoc[15](loc10: VecMap<String, String>)
65CopyLoc[12](loc7: u64)
66Call vec_map::get_entry_by_idx<String, String>(&VecMap<String, String>, u64): &String * &String
67StLoc[16](loc11: &String)
68StLoc[11](loc6: &String)
69CopyLoc[2](Arg2: &mut Display<KingFizh>)
70FreezeRef
71Call display::fields<KingFizh>(&Display<KingFizh>): &VecMap<String, String>
72CopyLoc[11](loc6: &String)
73Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
74Not
75BrFalse(104)
B8:
76CopyLoc[3](Arg3: &mut Display<KingFizh>)
77StLoc[9](loc4: &mut Display<KingFizh>)
78CopyLoc[10](loc5: &DisplayCap<KingFizh>)
79StLoc[8](loc3: &DisplayCap<KingFizh>)
80CopyLoc[11](loc6: &String)
81ReadRef
82StLoc[7](loc2: String)
83MoveLoc[11](loc6: &String)
84ReadRef
85CopyLoc[13](loc8: String)
86Eq
87BrFalse(95)
B9:
88MoveLoc[16](loc11: &String)
89Pop
90CopyLoc[2](Arg2: &mut Display<KingFizh>)
91FreezeRef
92Call display_cover(&Display<KingFizh>): String
93StLoc[6](loc1: String)
94Branch(98)
B10:
95MoveLoc[16](loc11: &String)
96ReadRef
97StLoc[6](loc1: String)
B11:
98MoveLoc[9](loc4: &mut Display<KingFizh>)
99MoveLoc[8](loc3: &DisplayCap<KingFizh>)
100MoveLoc[7](loc2: String)
101MoveLoc[6](loc1: String)
102Call display_registry::set<KingFizh>(&mut Display<KingFizh>, &DisplayCap<KingFizh>, String, String)
103Branch(108)
B12:
104MoveLoc[16](loc11: &String)
105Pop
106MoveLoc[11](loc6: &String)
107Pop
B13:
108MoveLoc[12](loc7: u64)
109LdU64(1)
110Add
111StLoc[12](loc7: u64)
112Branch(58)
B14:
113MoveLoc[3](Arg3: &mut Display<KingFizh>)
114Pop
115MoveLoc[2](Arg2: &mut Display<KingFizh>)
116Pop
117MoveLoc[10](loc5: &DisplayCap<KingFizh>)
118Pop
119Branch(126)
B15:
120MoveLoc[3](Arg3: &mut Display<KingFizh>)
121Pop
122MoveLoc[2](Arg2: &mut Display<KingFizh>)
123Pop
124MoveLoc[10](loc5: &DisplayCap<KingFizh>)
125Pop
B16:
126Ret
}
public configure_legacy_layout(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<u8>, Arg3: u8, Arg4: vector<u8>) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7MoveLoc[1](Arg1: &mut Collection)
8Call legacy_state_mut(&mut Collection): &mut State
9MoveLoc[2](Arg2: vector<u8>)
10MoveLoc[3](Arg3: u8)
11MoveLoc[4](Arg4: vector<u8>)
12Call legacy::configure_layout(&mut State, vector<u8>, u8, vector<u8>)
13Ret
}
public set_vip_batch(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<address>, Arg3: 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_collection(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8Call legacy_state_mut(&mut Collection): &mut State
9MoveLoc[2](Arg2: vector<address>)
10MoveLoc[3](Arg3: bool)
11Call legacy::set_vip(&mut State, vector<address>, bool)
12MoveLoc[1](Arg1: &mut Collection)
13LdU8(7)
14Call config_changed(&mut Collection, u8)
15Ret
}
public reserve_legacy_batch(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<u64>) {
L3: loc0: u64
L4: loc1: bool
L5: loc2: bool
L6: loc3: bool
L7: loc4: u64
L8: loc5: u64
L9: loc6: u64
L10: loc7: vector<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_collection(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8ImmBorrowField[3](Collection.seeded: u64)
9ReadRef
10CopyLoc[1](Arg1: &mut Collection)
11ImmBorrowField[1](Collection.supply: u64)
12ReadRef
13Eq
14BrFalse(30)
B1:
15CopyLoc[1](Arg1: &mut Collection)
16ImmBorrowField[6](Collection.mint_open: bool)
17ReadRef
18Not
19BrFalse(27)
B2:
20CopyLoc[1](Arg1: &mut Collection)
21ImmBorrowField[5](Collection.minted: u64)
22ReadRef
23LdU64(0)
24Eq
25StLoc[4](loc1: bool)
26Branch(32)
B3:
27LdFalse
28StLoc[4](loc1: bool)
29Branch(32)
B4:
30LdFalse
31StLoc[4](loc1: bool)
B5:
32MoveLoc[4](loc1: bool)
33BrFalse(35)
B6:
34Branch(39)
B7:
35MoveLoc[1](Arg1: &mut Collection)
36Pop
37LdConst[61](u64: 131)
38Abort
B8:
39ImmBorrowLoc[2](Arg2: vector<u64>)
40VecLen(7)
41LdU64(0)
42Gt
43BrFalse(50)
B9:
44ImmBorrowLoc[2](Arg2: vector<u64>)
45VecLen(7)
46LdU64(100)
47Le
48StLoc[5](loc2: bool)
49Branch(52)
B10:
50LdFalse
51StLoc[5](loc2: bool)
B11:
52MoveLoc[5](loc2: bool)
53BrFalse(55)
B12:
54Branch(59)
B13:
55MoveLoc[1](Arg1: &mut Collection)
56Pop
57LdConst[47](u64: 116)
58Abort
B14:
59MoveLoc[2](Arg2: vector<u64>)
60StLoc[10](loc7: vector<u64>)
61MutBorrowLoc[10](loc7: vector<u64>)
62Call vector::reverse<u64>(&mut vector<u64>)
63ImmBorrowLoc[10](loc7: vector<u64>)
64VecLen(7)
65StLoc[3](loc0: u64)
66LdU64(0)
67StLoc[7](loc4: u64)
68MoveLoc[3](loc0: u64)
69StLoc[9](loc6: u64)
B15:
70CopyLoc[7](loc4: u64)
71CopyLoc[9](loc6: u64)
72Lt
73BrFalse(128)
B16:
74CopyLoc[7](loc4: u64)
75Pop
76MutBorrowLoc[10](loc7: vector<u64>)
77VecPopBack(7)
78StLoc[8](loc5: u64)
79CopyLoc[8](loc5: u64)
80LdU64(0)
81Gt
82BrFalse(99)
B17:
83CopyLoc[8](loc5: u64)
84CopyLoc[1](Arg1: &mut Collection)
85ImmBorrowField[1](Collection.supply: u64)
86ReadRef
87Le
88BrFalse(96)
B18:
89CopyLoc[1](Arg1: &mut Collection)
90ImmBorrowField[8](Collection.reservations: Table<u64, address>)
91CopyLoc[8](loc5: u64)
92Call table::contains<u64, address>(&Table<u64, address>, u64): bool
93Not
94StLoc[6](loc3: bool)
95Branch(101)
B19:
96LdFalse
97StLoc[6](loc3: bool)
98Branch(101)
B20:
99LdFalse
100StLoc[6](loc3: bool)
B21:
101MoveLoc[6](loc3: bool)
102BrFalse(104)
B22:
103Branch(108)
B23:
104MoveLoc[1](Arg1: &mut Collection)
105Pop
106LdConst[53](u64: 122)
107Abort
B24:
108CopyLoc[1](Arg1: &mut Collection)
109Call legacy_state_mut(&mut Collection): &mut State
110CopyLoc[8](loc5: u64)
111Call legacy::reserve(&mut State, u64)
112CopyLoc[1](Arg1: &mut Collection)
113MoveLoc[8](loc5: u64)
114Call remove_available(&mut Collection, u64)
115CopyLoc[1](Arg1: &mut Collection)
116ImmBorrowField[9](Collection.drawn: u64)
117ReadRef
118LdU64(1)
119Add
120CopyLoc[1](Arg1: &mut Collection)
121MutBorrowField[9](Collection.drawn: u64)
122WriteRef
123MoveLoc[7](loc4: u64)
124LdU64(1)
125Add
126StLoc[7](loc4: u64)
127Branch(70)
B25:
128MoveLoc[1](Arg1: &mut Collection)
129Pop
130MoveLoc[10](loc7: vector<u64>)
131VecUnpack(7, 0)
132Ret
}
public seal_legacy_inventory(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4MoveLoc[1](Arg1: &mut Collection)
5Call legacy_state_mut(&mut Collection): &mut State
6MoveLoc[2](Arg2: u64)
7Call legacy::seal_inventory(&mut State, u64)
8Ret
}
public bind_legacy_batch(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<ID>, Arg3: vector<u64>) {
L4: loc0: bool
L5: loc1: 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_collection(&Collection)
7ImmBorrowLoc[2](Arg2: vector<ID>)
8VecLen(35)
9LdU64(0)
10Gt
11BrFalse(27)
B1:
12ImmBorrowLoc[2](Arg2: vector<ID>)
13VecLen(35)
14LdU64(100)
15Le
16BrFalse(24)
B2:
17ImmBorrowLoc[2](Arg2: vector<ID>)
18VecLen(35)
19ImmBorrowLoc[3](Arg3: vector<u64>)
20VecLen(7)
21Eq
22StLoc[4](loc0: bool)
23Branch(29)
B3:
24LdFalse
25StLoc[4](loc0: bool)
26Branch(29)
B4:
27LdFalse
28StLoc[4](loc0: bool)
B5:
29MoveLoc[4](loc0: bool)
30BrFalse(32)
B6:
31Branch(36)
B7:
32MoveLoc[1](Arg1: &mut Collection)
33Pop
34LdConst[47](u64: 116)
35Abort
B8:
36LdU64(0)
37StLoc[5](loc1: u64)
B9:
38CopyLoc[5](loc1: u64)
39ImmBorrowLoc[2](Arg2: vector<ID>)
40VecLen(35)
41Lt
42BrFalse(59)
B10:
43CopyLoc[1](Arg1: &mut Collection)
44Call legacy_state_mut(&mut Collection): &mut State
45ImmBorrowLoc[2](Arg2: vector<ID>)
46CopyLoc[5](loc1: u64)
47VecImmBorrow(35)
48ReadRef
49ImmBorrowLoc[3](Arg3: vector<u64>)
50CopyLoc[5](loc1: u64)
51VecImmBorrow(7)
52ReadRef
53Call legacy::bind_identity(&mut State, ID, u64)
54MoveLoc[5](loc1: u64)
55LdU64(1)
56Add
57StLoc[5](loc1: u64)
58Branch(38)
B11:
59MoveLoc[1](Arg1: &mut Collection)
60Pop
61Ret
}
public release_expired_legacy(Arg0: &mut Collection, Arg1: vector<u64>, Arg2: &Clock) {
L3: loc0: u64
L4: loc1: bool
L5: loc2: u64
L6: loc3: u64
L7: loc4: u64
L8: loc5: u64
L9: loc6: u64
L10: loc7: vector<u64>
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2Call check_collection(&Collection)
3ImmBorrowLoc[1](Arg1: vector<u64>)
4VecLen(7)
5LdU64(0)
6Gt
7BrFalse(14)
B1:
8ImmBorrowLoc[1](Arg1: vector<u64>)
9VecLen(7)
10LdU64(100)
11Le
12StLoc[4](loc1: bool)
13Branch(16)
B2:
14LdFalse
15StLoc[4](loc1: bool)
B3:
16MoveLoc[4](loc1: bool)
17BrFalse(19)
B4:
18Branch(25)
B5:
19MoveLoc[2](Arg2: &Clock)
20Pop
21MoveLoc[0](Arg0: &mut Collection)
22Pop
23LdConst[47](u64: 116)
24Abort
B6:
25CopyLoc[0](Arg0: &mut Collection)
26ImmBorrowField[18](Collection.public_start_ms: u64)
27ReadRef
28StLoc[8](loc5: u64)
29MoveLoc[1](Arg1: vector<u64>)
30StLoc[10](loc7: vector<u64>)
31MutBorrowLoc[10](loc7: vector<u64>)
32Call vector::reverse<u64>(&mut vector<u64>)
33ImmBorrowLoc[10](loc7: vector<u64>)
34VecLen(7)
35StLoc[3](loc0: u64)
36LdU64(0)
37StLoc[6](loc3: u64)
38MoveLoc[3](loc0: u64)
39StLoc[9](loc6: u64)
B7:
40CopyLoc[6](loc3: u64)
41CopyLoc[9](loc6: u64)
42Lt
43BrFalse(94)
B8:
44CopyLoc[6](loc3: u64)
45Pop
46MutBorrowLoc[10](loc7: vector<u64>)
47VecPopBack(7)
48StLoc[7](loc4: u64)
49CopyLoc[0](Arg0: &mut Collection)
50FreezeRef
51Call settings(&Collection): &SettingsV1
52ImmBorrowField[19](SettingsV1.migration_duration_ms: u64)
53ReadRef
54StLoc[5](loc2: u64)
55CopyLoc[0](Arg0: &mut Collection)
56Call legacy_state_mut(&mut Collection): &mut State
57CopyLoc[7](loc4: u64)
58CopyLoc[2](Arg2: &Clock)
59Call clock::timestamp_ms(&Clock): u64
60CopyLoc[8](loc5: u64)
61MoveLoc[5](loc2: u64)
62Call legacy::release_window(&mut State, u64, u64, u64, u64)
63CopyLoc[0](Arg0: &mut Collection)
64ImmBorrowField[20](Collection.items: Table<u64, ID>)
65CopyLoc[7](loc4: u64)
66Call table::contains<u64, ID>(&Table<u64, ID>, u64): bool
67Not
68BrFalse(70)
B9:
69Branch(76)
B10:
70MoveLoc[2](Arg2: &Clock)
71Pop
72MoveLoc[0](Arg0: &mut Collection)
73Pop
74LdConst[44](u64: 113)
75Abort
B11:
76CopyLoc[0](Arg0: &mut Collection)
77MutBorrowField[4](Collection.pool: vector<u16>)
78MoveLoc[7](loc4: u64)
79CastU16
80VecPushBack(173)
81CopyLoc[0](Arg0: &mut Collection)
82ImmBorrowField[9](Collection.drawn: u64)
83ReadRef
84LdU64(1)
85Sub
86CopyLoc[0](Arg0: &mut Collection)
87MutBorrowField[9](Collection.drawn: u64)
88WriteRef
89MoveLoc[6](loc3: u64)
90LdU64(1)
91Add
92StLoc[6](loc3: u64)
93Branch(40)
B12:
94MoveLoc[2](Arg2: &Clock)
95Pop
96MoveLoc[0](Arg0: &mut Collection)
97Pop
98MoveLoc[10](loc7: vector<u64>)
99VecUnpack(7, 0)
100Ret
}
public legacy_reserved_count(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1Call legacy_state(&Collection): &State
2Call legacy::reserved_count(&State): u64
3Ret
}
public legacy_archive(Arg0: &Collection): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1Call legacy_state(&Collection): &State
2Call legacy::archive_id(&State): ID
3Ret
}
public is_vip(Arg0: &Collection, Arg1: address): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1Call legacy_state(&Collection): &State
2MoveLoc[1](Arg1: address)
3Call legacy::is_vip(&State, address): bool
4Ret
}
public migration_reserved(Arg0: &Collection, Arg1: u64): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1Call legacy_state(&Collection): &State
2MoveLoc[1](Arg1: u64)
3Call legacy::is_reserved(&State, u64): bool
4Ret
}
public migration_end_ms(Arg0: &Collection): u64 {
B0:
0CopyLoc[0](Arg0: &Collection)
1ImmBorrowField[18](Collection.public_start_ms: u64)
2ReadRef
3MoveLoc[0](Arg0: &Collection)
4Call settings(&Collection): &SettingsV1
5ImmBorrowField[19](SettingsV1.migration_duration_ms: u64)
6ReadRef
7Add
8Ret
}
public migration_price_for_wallet(Arg0: &Collection, Arg1: address): u64 {
L2: loc0: u8
L3: loc1: &Collection
L4: loc2: Allocation
B0:
0CopyLoc[0](Arg0: &Collection)
1StLoc[3](loc1: &Collection)
2MoveLoc[0](Arg0: &Collection)
3MoveLoc[1](Arg1: address)
4Call is_vip(&Collection, address): bool
5BrFalse(9)
B1:
6LdU8(2)
7StLoc[2](loc0: u8)
8Branch(11)
B2:
9LdU8(1)
10StLoc[2](loc0: u8)
B3:
11MoveLoc[3](loc1: &Collection)
12MoveLoc[2](loc0: u8)
13Call route_allocation(&Collection, u8): Allocation
14StLoc[4](loc2: Allocation)
15ImmBorrowLoc[4](loc2: Allocation)
16Call terms::allocation_price(&Allocation): u64
17Ret
}
public migrated_legacy(Arg0: &Collection, Arg1: ID): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1Call legacy_state(&Collection): &State
2MoveLoc[1](Arg1: ID)
3Call legacy::has_migrated(&State, ID): bool
4Ret
}
public create_vault<Ty0>(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4Call assert_king<Ty0>()
5MoveLoc[1](Arg1: &mut Collection)
6MoveLoc[2](Arg2: &mut TxContext)
7Call create_vault_internal<Ty0>(&mut Collection, &mut TxContext)
8Ret
}
create_vault_internal<Ty0>(Arg0: &mut Collection, Arg1: &mut TxContext) {
L2: loc0: UID
L3: loc1: ID
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2Call check_collection(&Collection)
3CopyLoc[0](Arg0: &mut Collection)
4ImmBorrowField[12](Collection.vault: ID)
5ReadRef
6LdConst[97](address: 0x00..)
7Call object::id_from_address(address): ID
8Eq
9BrFalse(11)
B1:
10Branch(17)
B2:
11MoveLoc[1](Arg1: &mut TxContext)
12Pop
13MoveLoc[0](Arg0: &mut Collection)
14Pop
15LdConst[50](u64: 119)
16Abort
B3:
17CopyLoc[1](Arg1: &mut TxContext)
18Call object::new(&mut TxContext): UID
19StLoc[2](loc0: UID)
20ImmBorrowLoc[2](loc0: UID)
21Call object::uid_to_inner(&UID): ID
22StLoc[3](loc1: ID)
23CopyLoc[3](loc1: ID)
24CopyLoc[0](Arg0: &mut Collection)
25MutBorrowField[12](Collection.vault: ID)
26WriteRef
27CopyLoc[0](Arg0: &mut Collection)
28FreezeRef
29Call object::id<Collection>(&Collection): ID
30MoveLoc[3](loc1: ID)
31Pack[13](VaultCreated)
32Call event::emit<VaultCreated>(VaultCreated)
33MoveLoc[2](loc0: UID)
34LdConst[13](u64: 1)
35MoveLoc[0](Arg0: &mut Collection)
36FreezeRef
37Call object::id<Collection>(&Collection): ID
38MoveLoc[1](Arg1: &mut TxContext)
39Call table::new<u64, CetusLPBurnProof>(&mut TxContext): Table<u64, CetusLPBurnProof>
40LdU64(0)
41LdU64(0)
42Call balance::zero<Ty0>(): Balance<Ty0>
43Call balance::zero<SUI>(): Balance<SUI>
44LdU128(0)
45LdU128(0)
46LdConst[17](u64: 100)
47LdTrue
48LdU64(0)
49LdU64(0)
50LdU64(0)
51LdU64(0)
52PackGeneric[0](Vault<Ty0>)
53Call transfer::share_object<Vault<Ty0>>(Vault<Ty0>)
54Ret
}
public set_validator(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: address) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7CopyLoc[2](Arg2: address)
8LdConst[97](address: 0x00..)
9Neq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[1](Arg1: &mut Collection)
13Pop
14LdConst[54](u64: 123)
15Abort
B3:
16CopyLoc[1](Arg1: &mut Collection)
17FreezeRef
18Call object::id<Collection>(&Collection): ID
19CopyLoc[1](Arg1: &mut Collection)
20ImmBorrowField[16](Collection.validator: address)
21ReadRef
22CopyLoc[2](Arg2: address)
23Pack[24](ValidatorSet)
24Call event::emit<ValidatorSet>(ValidatorSet)
25CopyLoc[2](Arg2: address)
26CopyLoc[1](Arg1: &mut Collection)
27MutBorrowField[16](Collection.validator: address)
28WriteRef
29MoveLoc[2](Arg2: address)
30CopyLoc[1](Arg1: &mut Collection)
31Call settings_mut(&mut Collection): &mut SettingsV1
32MutBorrowField[21](SettingsV1.validator: address)
33WriteRef
34MoveLoc[1](Arg1: &mut Collection)
35LdU8(2)
36Call config_changed(&mut Collection, u8)
37Ret
}
public set_pools(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: ID, Arg3: ID) {
L4: loc0: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[2](Arg2: ID)
5CopyLoc[3](Arg3: ID)
6Eq
7BrFalse(14)
B1:
8ImmBorrowLoc[2](Arg2: ID)
9Call object::id_to_address(&ID): address
10LdConst[97](address: 0x00..)
11Neq
12StLoc[4](loc0: bool)
13Branch(16)
B2:
14LdFalse
15StLoc[4](loc0: bool)
B3:
16MoveLoc[4](loc0: bool)
17BrFalse(19)
B4:
18Branch(23)
B5:
19MoveLoc[1](Arg1: &mut Collection)
20Pop
21LdConst[36](u64: 105)
22Abort
B6:
23MoveLoc[1](Arg1: &mut Collection)
24MoveLoc[2](Arg2: ID)
25MoveLoc[3](Arg3: ID)
26Call set_pools_internal(&mut Collection, ID, ID)
27Ret
}
set_pools_internal(Arg0: &mut Collection, Arg1: ID, Arg2: ID) {
L3: loc0: &mut SettingsV1
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2Call check_collection(&Collection)
3CopyLoc[0](Arg0: &mut Collection)
4FreezeRef
5Call object::id<Collection>(&Collection): ID
6CopyLoc[0](Arg0: &mut Collection)
7ImmBorrowField[22](Collection.swap_pool: ID)
8ReadRef
9CopyLoc[1](Arg1: ID)
10CopyLoc[0](Arg0: &mut Collection)
11ImmBorrowField[23](Collection.lp_pool: ID)
12ReadRef
13CopyLoc[2](Arg2: ID)
14Pack[25](PoolsSet)
15Call event::emit<PoolsSet>(PoolsSet)
16CopyLoc[1](Arg1: ID)
17CopyLoc[0](Arg0: &mut Collection)
18MutBorrowField[22](Collection.swap_pool: ID)
19WriteRef
20CopyLoc[2](Arg2: ID)
21CopyLoc[0](Arg0: &mut Collection)
22MutBorrowField[23](Collection.lp_pool: ID)
23WriteRef
24CopyLoc[0](Arg0: &mut Collection)
25Call settings_mut(&mut Collection): &mut SettingsV1
26StLoc[3](loc0: &mut SettingsV1)
27MoveLoc[1](Arg1: ID)
28CopyLoc[3](loc0: &mut SettingsV1)
29MutBorrowField[24](SettingsV1.swap_pool: ID)
30WriteRef
31MoveLoc[2](Arg2: ID)
32MoveLoc[3](loc0: &mut SettingsV1)
33MutBorrowField[25](SettingsV1.lp_pool: ID)
34WriteRef
35MoveLoc[0](Arg0: &mut Collection)
36LdU8(3)
37Call config_changed(&mut Collection, u8)
38Ret
}
public set_fee_wallet(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: address) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7CopyLoc[2](Arg2: address)
8LdConst[97](address: 0x00..)
9Neq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[1](Arg1: &mut Collection)
13Pop
14LdConst[54](u64: 123)
15Abort
B3:
16CopyLoc[1](Arg1: &mut Collection)
17FreezeRef
18Call object::id<Collection>(&Collection): ID
19CopyLoc[1](Arg1: &mut Collection)
20ImmBorrowField[26](Collection.fee_wallet: address)
21ReadRef
22CopyLoc[2](Arg2: address)
23Pack[26](FeeWalletSet)
24Call event::emit<FeeWalletSet>(FeeWalletSet)
25CopyLoc[2](Arg2: address)
26CopyLoc[1](Arg1: &mut Collection)
27MutBorrowField[26](Collection.fee_wallet: address)
28WriteRef
29MoveLoc[2](Arg2: address)
30CopyLoc[1](Arg1: &mut Collection)
31Call settings_mut(&mut Collection): &mut SettingsV1
32MutBorrowField[27](SettingsV1.hive_wallet: address)
33WriteRef
34MoveLoc[1](Arg1: &mut Collection)
35LdU8(1)
36Call config_changed(&mut Collection, u8)
37Ret
}
public set_royalty_wallet(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: address) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7CopyLoc[2](Arg2: address)
8LdConst[97](address: 0x00..)
9Neq
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[1](Arg1: &mut Collection)
13Pop
14LdConst[54](u64: 123)
15Abort
B3:
16CopyLoc[1](Arg1: &mut Collection)
17FreezeRef
18Call object::id<Collection>(&Collection): ID
19CopyLoc[1](Arg1: &mut Collection)
20ImmBorrowField[28](Collection.royalty_wallet: address)
21ReadRef
22CopyLoc[2](Arg2: address)
23Pack[27](RoyaltyWalletSet)
24Call event::emit<RoyaltyWalletSet>(RoyaltyWalletSet)
25CopyLoc[2](Arg2: address)
26CopyLoc[1](Arg1: &mut Collection)
27MutBorrowField[28](Collection.royalty_wallet: address)
28WriteRef
29MoveLoc[2](Arg2: address)
30CopyLoc[1](Arg1: &mut Collection)
31Call settings_mut(&mut Collection): &mut SettingsV1
32MutBorrowField[29](SettingsV1.treasury_wallet: address)
33WriteRef
34MoveLoc[1](Arg1: &mut Collection)
35LdU8(1)
36Call config_changed(&mut Collection, u8)
37Ret
}
public set_schedule(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: u64, 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_collection(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8ImmBorrowField[6](Collection.mint_open: bool)
9ReadRef
10Not
11BrFalse(19)
B1:
12CopyLoc[1](Arg1: &mut Collection)
13ImmBorrowField[5](Collection.minted: u64)
14ReadRef
15LdU64(0)
16Eq
17StLoc[5](loc0: bool)
18Branch(21)
B2:
19LdFalse
20StLoc[5](loc0: bool)
B3:
21MoveLoc[5](loc0: bool)
22BrFalse(24)
B4:
23Branch(28)
B5:
24MoveLoc[1](Arg1: &mut Collection)
25Pop
26LdConst[61](u64: 131)
27Abort
B6:
28CopyLoc[2](Arg2: u64)
29CopyLoc[1](Arg1: &mut Collection)
30FreezeRef
31Call settings(&Collection): &SettingsV1
32ImmBorrowField[30](SettingsV1.early_access_ms: u64)
33ReadRef
34Add
35CopyLoc[3](Arg3: u64)
36Eq
37BrFalse(39)
B7:
38Branch(43)
B8:
39MoveLoc[1](Arg1: &mut Collection)
40Pop
41LdConst[67](u64: 137)
42Abort
B9:
43CopyLoc[4](Arg4: u64)
44CopyLoc[1](Arg1: &mut Collection)
45FreezeRef
46Call legacy_state(&Collection): &State
47CopyLoc[1](Arg1: &mut Collection)
48FreezeRef
49Call settings(&Collection): &SettingsV1
50ImmBorrowField[31](SettingsV1.min_king_tokens: u64)
51ReadRef
52Call legacy::minimum_king_for(&State, u64): u64
53Eq
54BrFalse(56)
B10:
55Branch(60)
B11:
56MoveLoc[1](Arg1: &mut Collection)
57Pop
58LdConst[67](u64: 137)
59Abort
B12:
60MoveLoc[1](Arg1: &mut Collection)
61MoveLoc[2](Arg2: u64)
62MoveLoc[3](Arg3: u64)
63MoveLoc[4](Arg4: u64)
64Call set_schedule_internal(&mut Collection, u64, u64, u64)
65Ret
}
set_schedule_internal(Arg0: &mut Collection, Arg1: u64, Arg2: u64, Arg3: u64) {
L4: loc0: bool
L5: loc1: &mut SettingsV1
B0:
0CopyLoc[1](Arg1: u64)
1CopyLoc[2](Arg2: u64)
2Le
3BrFalse(9)
B1:
4CopyLoc[3](Arg3: u64)
5LdU64(0)
6Gt
7StLoc[4](loc0: bool)
8Branch(11)
B2:
9LdFalse
10StLoc[4](loc0: bool)
B3:
11MoveLoc[4](loc0: bool)
12BrFalse(14)
B4:
13Branch(18)
B5:
14MoveLoc[0](Arg0: &mut Collection)
15Pop
16LdConst[67](u64: 137)
17Abort
B6:
18CopyLoc[1](Arg1: u64)
19CopyLoc[0](Arg0: &mut Collection)
20MutBorrowField[14](Collection.holder_start_ms: u64)
21WriteRef
22CopyLoc[2](Arg2: u64)
23CopyLoc[0](Arg0: &mut Collection)
24MutBorrowField[18](Collection.public_start_ms: u64)
25WriteRef
26CopyLoc[3](Arg3: u64)
27CopyLoc[0](Arg0: &mut Collection)
28MutBorrowField[32](Collection.min_holder_balance: u64)
29WriteRef
30CopyLoc[0](Arg0: &mut Collection)
31Call settings_mut(&mut Collection): &mut SettingsV1
32StLoc[5](loc1: &mut SettingsV1)
33CopyLoc[1](Arg1: u64)
34CopyLoc[5](loc1: &mut SettingsV1)
35MutBorrowField[33](SettingsV1.holder_start_ms: u64)
36WriteRef
37CopyLoc[2](Arg2: u64)
38MoveLoc[5](loc1: &mut SettingsV1)
39MutBorrowField[34](SettingsV1.public_start_ms: u64)
40WriteRef
41CopyLoc[0](Arg0: &mut Collection)
42LdU8(5)
43Call config_changed(&mut Collection, u8)
44MoveLoc[0](Arg0: &mut Collection)
45FreezeRef
46Call object::id<Collection>(&Collection): ID
47MoveLoc[1](Arg1: u64)
48MoveLoc[2](Arg2: u64)
49MoveLoc[3](Arg3: u64)
50Pack[28](ScheduleSet)
51Call event::emit<ScheduleSet>(ScheduleSet)
52Ret
}
public set_mint_open(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: 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_collection(&Collection)
7CopyLoc[2](Arg2: bool)
8BrFalse(54)
B1:
9CopyLoc[1](Arg1: &mut Collection)
10FreezeRef
11Call assert_configured(&Collection)
12CopyLoc[1](Arg1: &mut Collection)
13ImmBorrowField[3](Collection.seeded: u64)
14ReadRef
15CopyLoc[1](Arg1: &mut Collection)
16ImmBorrowField[1](Collection.supply: u64)
17ReadRef
18Eq
19BrFalse(21)
B2:
20Branch(25)
B3:
21MoveLoc[1](Arg1: &mut Collection)
22Pop
23LdConst[56](u64: 125)
24Abort
B4:
25CopyLoc[1](Arg1: &mut Collection)
26ImmBorrowField[18](Collection.public_start_ms: u64)
27ReadRef
28LdConst[26](u64: 1844..)
29Neq
30BrFalse(32)
B5:
31Branch(36)
B6:
32MoveLoc[1](Arg1: &mut Collection)
33Pop
34LdConst[67](u64: 137)
35Abort
B7:
36CopyLoc[1](Arg1: &mut Collection)
37FreezeRef
38Call has_display_v2(&Collection): bool
39BrFalse(41)
B8:
40Branch(45)
B9:
41MoveLoc[1](Arg1: &mut Collection)
42Pop
43LdConst[72](u64: 143)
44Abort
B10:
45CopyLoc[1](Arg1: &mut Collection)
46FreezeRef
47Call legacy_state(&Collection): &State
48Call legacy::frozen(&State): bool
49Not
50BrFalse(54)
B11:
51CopyLoc[1](Arg1: &mut Collection)
52Call legacy_state_mut(&mut Collection): &mut State
53Call legacy::seal_configuration(&mut State)
B12:
54CopyLoc[2](Arg2: bool)
55CopyLoc[1](Arg1: &mut Collection)
56MutBorrowField[6](Collection.mint_open: bool)
57WriteRef
58MoveLoc[1](Arg1: &mut Collection)
59FreezeRef
60Call object::id<Collection>(&Collection): ID
61MoveLoc[2](Arg2: bool)
62Pack[29](MintOpenSet)
63Call event::emit<MintOpenSet>(MintOpenSet)
64Ret
}
public set_sweep<Ty0>(Arg0: &AdminCap, Arg1: &Collection, Arg2: &mut Vault<Ty0>, Arg3: bool, Arg4: u64) {
L5: loc0: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &Collection)
2Call assert_admin(&AdminCap, &Collection)
3CopyLoc[1](Arg1: &Collection)
4Call check_collection(&Collection)
5CopyLoc[2](Arg2: &mut Vault<Ty0>)
6FreezeRef
7Call check_vault<Ty0>(&Vault<Ty0>)
8CopyLoc[2](Arg2: &mut Vault<Ty0>)
9ImmBorrowFieldGeneric[0](Vault.collection: ID)
10ReadRef
11CopyLoc[1](Arg1: &Collection)
12Call object::id<Collection>(&Collection): ID
13Eq
14BrFalse(24)
B1:
15CopyLoc[2](Arg2: &mut Vault<Ty0>)
16FreezeRef
17Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
18MoveLoc[1](Arg1: &Collection)
19ImmBorrowField[12](Collection.vault: ID)
20ReadRef
21Eq
22StLoc[5](loc0: bool)
23Branch(28)
B2:
24MoveLoc[1](Arg1: &Collection)
25Pop
26LdFalse
27StLoc[5](loc0: bool)
B3:
28MoveLoc[5](loc0: bool)
29BrFalse(31)
B4:
30Branch(35)
B5:
31MoveLoc[2](Arg2: &mut Vault<Ty0>)
32Pop
33LdConst[41](u64: 110)
34Abort
B6:
35CopyLoc[4](Arg4: u64)
36LdConst[16](u64: 1000)
37Le
38BrFalse(40)
B7:
39Branch(44)
B8:
40MoveLoc[2](Arg2: &mut Vault<Ty0>)
41Pop
42LdConst[51](u64: 120)
43Abort
B9:
44CopyLoc[3](Arg3: bool)
45CopyLoc[2](Arg2: &mut Vault<Ty0>)
46MutBorrowFieldGeneric[1](Vault.sweep_open: bool)
47WriteRef
48CopyLoc[4](Arg4: u64)
49CopyLoc[2](Arg2: &mut Vault<Ty0>)
50MutBorrowFieldGeneric[2](Vault.sweep_fee_bps: u64)
51WriteRef
52MoveLoc[2](Arg2: &mut Vault<Ty0>)
53FreezeRef
54Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
55MoveLoc[3](Arg3: bool)
56MoveLoc[4](Arg4: u64)
57Pack[30](SweepSet)
58Call event::emit<SweepSet>(SweepSet)
59Ret
}
public distribute(Arg0: &Collection, Arg1: &mut TransferPolicy<KingFizh>, Arg2: &mut TxContext) {
L3: loc0: &SettingsV1
L4: loc1: Coin<SUI>
L5: loc2: u64
L6: loc3: u64
L7: loc4: u64
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2CopyLoc[1](Arg1: &mut TransferPolicy<KingFizh>)
3FreezeRef
4Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
5CopyLoc[0](Arg0: &Collection)
6ImmBorrowField[13](Collection.policy: ID)
7ReadRef
8Eq
9BrFalse(11)
B1:
10Branch(19)
B2:
11MoveLoc[1](Arg1: &mut TransferPolicy<KingFizh>)
12Pop
13MoveLoc[2](Arg2: &mut TxContext)
14Pop
15MoveLoc[0](Arg0: &Collection)
16Pop
17LdConst[49](u64: 118)
18Abort
B3:
19CopyLoc[0](Arg0: &Collection)
20LdU8(6)
21Call assert_action(&Collection, u8)
22CopyLoc[1](Arg1: &mut TransferPolicy<KingFizh>)
23CopyLoc[0](Arg0: &Collection)
24ImmBorrowField[37](Collection.policy_cap: TransferPolicyCap<KingFizh>)
25Call option::none<u64>(): Option<u64>
26CopyLoc[2](Arg2: &mut TxContext)
27Call transfer_policy::withdraw<KingFizh>(&mut TransferPolicy<KingFizh>, &TransferPolicyCap<KingFizh>, Option<u64>, &mut TxContext): Coin<SUI>
28StLoc[4](loc1: Coin<SUI>)
29ImmBorrowLoc[4](loc1: Coin<SUI>)
30Call coin::value<SUI>(&Coin<SUI>): u64
31StLoc[6](loc3: u64)
32CopyLoc[6](loc3: u64)
33LdU64(0)
34Gt
35BrFalse(37)
B4:
36Branch(45)
B5:
37MoveLoc[1](Arg1: &mut TransferPolicy<KingFizh>)
38Pop
39MoveLoc[2](Arg2: &mut TxContext)
40Pop
41MoveLoc[0](Arg0: &Collection)
42Pop
43LdConst[68](u64: 138)
44Abort
B6:
45CopyLoc[0](Arg0: &Collection)
46Call settings(&Collection): &SettingsV1
47StLoc[3](loc0: &SettingsV1)
48MoveLoc[4](loc1: Coin<SUI>)
49CopyLoc[3](loc0: &SettingsV1)
50ImmBorrowField[38](SettingsV1.royalty_willie_bps: u16)
51ReadRef
52CopyLoc[3](loc0: &SettingsV1)
53ImmBorrowField[39](SettingsV1.willie_wallet: address)
54ReadRef
55MoveLoc[3](loc0: &SettingsV1)
56ImmBorrowField[29](SettingsV1.treasury_wallet: address)
57ReadRef
58MoveLoc[2](Arg2: &mut TxContext)
59Call terms::distribute_configured(Coin<SUI>, u16, address, address, &mut TxContext): u64 * u64
60StLoc[5](loc2: u64)
61StLoc[7](loc4: u64)
62MoveLoc[0](Arg0: &Collection)
63Call object::id<Collection>(&Collection): ID
64MoveLoc[1](Arg1: &mut TransferPolicy<KingFizh>)
65FreezeRef
66Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
67MoveLoc[6](loc3: u64)
68MoveLoc[7](loc4: u64)
69MoveLoc[5](loc2: u64)
70Pack[32](RoyaltiesDistributed)
71Call event::emit<RoyaltiesDistributed>(RoyaltiesDistributed)
72Ret
}
public withdraw_royalties(Arg0: &Collection, Arg1: &mut TransferPolicy<KingFizh>, Arg2: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: &Collection)
1MoveLoc[1](Arg1: &mut TransferPolicy<KingFizh>)
2MoveLoc[2](Arg2: &mut TxContext)
3Call distribute(&Collection, &mut TransferPolicy<KingFizh>, &mut TxContext)
4Ret
}
public set_royalty(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut TransferPolicy<KingFizh>, 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_collection(&Collection)
7CopyLoc[3](Arg3: u16)
8LdU16(0)
9Gt
10BrFalse(23)
B1:
11CopyLoc[3](Arg3: u16)
12LdU16(1000)
13Le
14BrFalse(20)
B2:
15CopyLoc[4](Arg4: u64)
16LdU64(0)
17Eq
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(34)
B7:
28MoveLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
29Pop
30MoveLoc[1](Arg1: &mut Collection)
31Pop
32LdConst[70](u64: 141)
33Abort
B8:
34CopyLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
35FreezeRef
36Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
37CopyLoc[1](Arg1: &mut Collection)
38ImmBorrowField[13](Collection.policy: ID)
39ReadRef
40Eq
41BrFalse(43)
B9:
42Branch(49)
B10:
43MoveLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
44Pop
45MoveLoc[1](Arg1: &mut Collection)
46Pop
47LdConst[49](u64: 118)
48Abort
B11:
49CopyLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
50CopyLoc[1](Arg1: &mut Collection)
51ImmBorrowField[37](Collection.policy_cap: TransferPolicyCap<KingFizh>)
52Call transfer_policy::remove_rule<KingFizh, Rule, Config>(&mut TransferPolicy<KingFizh>, &TransferPolicyCap<KingFizh>)
53MoveLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
54CopyLoc[1](Arg1: &mut Collection)
55ImmBorrowField[37](Collection.policy_cap: TransferPolicyCap<KingFizh>)
56CopyLoc[3](Arg3: u16)
57CopyLoc[4](Arg4: u64)
58Call royalty_rule::add<KingFizh>(&mut TransferPolicy<KingFizh>, &TransferPolicyCap<KingFizh>, u16, u64)
59CopyLoc[3](Arg3: u16)
60CopyLoc[1](Arg1: &mut Collection)
61Call settings_mut(&mut Collection): &mut SettingsV1
62MutBorrowField[40](SettingsV1.royalty_bps: u16)
63WriteRef
64CopyLoc[1](Arg1: &mut Collection)
65LdU8(4)
66Call config_changed(&mut Collection, u8)
67MoveLoc[1](Arg1: &mut Collection)
68FreezeRef
69Call object::id<Collection>(&Collection): ID
70MoveLoc[3](Arg3: u16)
71MoveLoc[4](Arg4: u64)
72Pack[31](RoyaltySet)
73Call event::emit<RoyaltySet>(RoyaltySet)
74Ret
}
public migrate_collection(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)
5FreezeRef
6Call configuration(&Collection): &Config
7ImmBorrowField[41](Config.code_version: u64)
8ReadRef
9LdConst[13](u64: 1)
10Eq
11BrFalse(13)
B1:
12Branch(17)
B2:
13MoveLoc[1](Arg1: &mut Collection)
14Pop
15LdConst[17](u64: 100)
16Abort
B3:
17CopyLoc[1](Arg1: &mut Collection)
18ImmBorrowField[42](Collection.version: u64)
19ReadRef
20LdConst[13](u64: 1)
21Lt
22BrFalse(24)
B4:
23Branch(28)
B5:
24MoveLoc[1](Arg1: &mut Collection)
25Pop
26LdConst[52](u64: 121)
27Abort
B6:
28CopyLoc[1](Arg1: &mut Collection)
29FreezeRef
30Call object::id<Collection>(&Collection): ID
31CopyLoc[1](Arg1: &mut Collection)
32ImmBorrowField[42](Collection.version: u64)
33ReadRef
34LdConst[13](u64: 1)
35Pack[34](Migrated)
36Call event::emit<Migrated>(Migrated)
37LdConst[13](u64: 1)
38MoveLoc[1](Arg1: &mut Collection)
39MutBorrowField[42](Collection.version: u64)
40WriteRef
41Ret
}
public migrate_vault<Ty0>(Arg0: &AdminCap, Arg1: &mut Vault<Ty0>) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1ImmBorrowField[43](AdminCap.collection: ID)
2ReadRef
3CopyLoc[1](Arg1: &mut Vault<Ty0>)
4ImmBorrowFieldGeneric[0](Vault.collection: ID)
5ReadRef
6Eq
7BrFalse(9)
B1:
8Branch(13)
B2:
9MoveLoc[1](Arg1: &mut Vault<Ty0>)
10Pop
11LdConst[79](u64: 150)
12Abort
B3:
13CopyLoc[1](Arg1: &mut Vault<Ty0>)
14ImmBorrowFieldGeneric[3](Vault.version: u64)
15ReadRef
16LdConst[13](u64: 1)
17Lt
18BrFalse(20)
B4:
19Branch(24)
B5:
20MoveLoc[1](Arg1: &mut Vault<Ty0>)
21Pop
22LdConst[52](u64: 121)
23Abort
B6:
24CopyLoc[1](Arg1: &mut Vault<Ty0>)
25FreezeRef
26Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
27CopyLoc[1](Arg1: &mut Vault<Ty0>)
28ImmBorrowFieldGeneric[3](Vault.version: u64)
29ReadRef
30LdConst[13](u64: 1)
31Pack[34](Migrated)
32Call event::emit<Migrated>(Migrated)
33LdConst[13](u64: 1)
34MoveLoc[1](Arg1: &mut Vault<Ty0>)
35MutBorrowFieldGeneric[3](Vault.version: u64)
36WriteRef
37Ret
}
entry transfer_admin(Arg0: AdminCap, Arg1: address) {
B0:
0CopyLoc[1](Arg1: address)
1Pack[35](AdminTransferred)
2Call event::emit<AdminTransferred>(AdminTransferred)
3MoveLoc[0](Arg0: AdminCap)
4MoveLoc[1](Arg1: address)
5Call transfer::transfer<AdminCap>(AdminCap, address)
6Ret
}
entry transfer_seed_cap(Arg0: SeedCap, Arg1: address) {
B0:
0MoveLoc[0](Arg0: SeedCap)
1MoveLoc[1](Arg1: address)
2Call transfer::transfer<SeedCap>(SeedCap, address)
3Ret
}
entry mint_to_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &KioskOwnerCap, Arg9: Coin<SUI>, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: u128, Arg14: u64, Arg15: &Clock, Arg16: &Random, Arg17: &mut TxContext) {
L18: loc0: RandomGenerator
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[14](Arg14: u64)
3Call assert_revision(&Collection, u64)
4MoveLoc[16](Arg16: &Random)
5CopyLoc[17](Arg17: &mut TxContext)
6Call random::new_generator(&Random, &mut TxContext): RandomGenerator
7StLoc[18](loc0: RandomGenerator)
8MoveLoc[0](Arg0: &mut Collection)
9MoveLoc[1](Arg1: &mut Vault<Ty0>)
10MoveLoc[2](Arg2: &mut SuiSystemState)
11MoveLoc[3](Arg3: &GlobalConfig)
12MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
13MoveLoc[5](Arg5: &mut BurnManager)
14MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
15MoveLoc[7](Arg7: &mut Kiosk)
16MoveLoc[8](Arg8: &KioskOwnerCap)
17Call option::none<u64>(): Option<u64>
18MoveLoc[9](Arg9: Coin<SUI>)
19MoveLoc[10](Arg10: u64)
20MoveLoc[11](Arg11: u64)
21MoveLoc[12](Arg12: u64)
22MoveLoc[13](Arg13: u128)
23MoveLoc[15](Arg15: &Clock)
24MutBorrowLoc[18](loc0: RandomGenerator)
25MoveLoc[17](Arg17: &mut TxContext)
26Call mint_drawn<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Option<u64>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut RandomGenerator, &mut TxContext)
27Ret
}
entry mint_to_new_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: Coin<SUI>, Arg8: u64, Arg9: u64, Arg10: u64, Arg11: u128, Arg12: u64, Arg13: &Clock, Arg14: &Random, Arg15: &mut TxContext) {
L16: loc0: RandomGenerator
L17: loc1: Kiosk
L18: loc2: KioskOwnerCap
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[12](Arg12: u64)
3Call assert_revision(&Collection, u64)
4MoveLoc[14](Arg14: &Random)
5CopyLoc[15](Arg15: &mut TxContext)
6Call random::new_generator(&Random, &mut TxContext): RandomGenerator
7StLoc[16](loc0: RandomGenerator)
8CopyLoc[15](Arg15: &mut TxContext)
9Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap
10StLoc[18](loc2: KioskOwnerCap)
11StLoc[17](loc1: Kiosk)
12MoveLoc[0](Arg0: &mut Collection)
13MoveLoc[1](Arg1: &mut Vault<Ty0>)
14MoveLoc[2](Arg2: &mut SuiSystemState)
15MoveLoc[3](Arg3: &GlobalConfig)
16MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
17MoveLoc[5](Arg5: &mut BurnManager)
18MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
19MutBorrowLoc[17](loc1: Kiosk)
20ImmBorrowLoc[18](loc2: KioskOwnerCap)
21Call option::none<u64>(): Option<u64>
22MoveLoc[7](Arg7: Coin<SUI>)
23MoveLoc[8](Arg8: u64)
24MoveLoc[9](Arg9: u64)
25MoveLoc[10](Arg10: u64)
26MoveLoc[11](Arg11: u128)
27MoveLoc[13](Arg13: &Clock)
28MutBorrowLoc[16](loc0: RandomGenerator)
29CopyLoc[15](Arg15: &mut TxContext)
30Call mint_drawn<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Option<u64>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut RandomGenerator, &mut TxContext)
31MoveLoc[17](loc1: Kiosk)
32Call transfer::public_share_object<Kiosk>(Kiosk)
33MoveLoc[18](loc2: KioskOwnerCap)
34MoveLoc[15](Arg15: &mut TxContext)
35FreezeRef
36Call tx_context::sender(&TxContext): address
37Call transfer::public_transfer<KioskOwnerCap>(KioskOwnerCap, address)
38Ret
}
entry mint_to_personal_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &mut PersonalKioskCap, Arg9: Coin<SUI>, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: u128, Arg14: u64, Arg15: &Clock, Arg16: &Random, Arg17: &mut TxContext) {
L18: loc0: Borrow
L19: loc1: RandomGenerator
L20: loc2: KioskOwnerCap
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[14](Arg14: u64)
3Call assert_revision(&Collection, u64)
4MoveLoc[16](Arg16: &Random)
5CopyLoc[17](Arg17: &mut TxContext)
6Call random::new_generator(&Random, &mut TxContext): RandomGenerator
7StLoc[19](loc1: RandomGenerator)
8CopyLoc[8](Arg8: &mut PersonalKioskCap)
9Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow
10StLoc[18](loc0: Borrow)
11StLoc[20](loc2: KioskOwnerCap)
12MoveLoc[0](Arg0: &mut Collection)
13MoveLoc[1](Arg1: &mut Vault<Ty0>)
14MoveLoc[2](Arg2: &mut SuiSystemState)
15MoveLoc[3](Arg3: &GlobalConfig)
16MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
17MoveLoc[5](Arg5: &mut BurnManager)
18MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
19MoveLoc[7](Arg7: &mut Kiosk)
20ImmBorrowLoc[20](loc2: KioskOwnerCap)
21Call option::none<u64>(): Option<u64>
22MoveLoc[9](Arg9: Coin<SUI>)
23MoveLoc[10](Arg10: u64)
24MoveLoc[11](Arg11: u64)
25MoveLoc[12](Arg12: u64)
26MoveLoc[13](Arg13: u128)
27MoveLoc[15](Arg15: &Clock)
28MutBorrowLoc[19](loc1: RandomGenerator)
29MoveLoc[17](Arg17: &mut TxContext)
30Call mint_drawn<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Option<u64>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut RandomGenerator, &mut TxContext)
31MoveLoc[8](Arg8: &mut PersonalKioskCap)
32MoveLoc[20](loc2: KioskOwnerCap)
33MoveLoc[18](loc0: Borrow)
34Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)
35Ret
}
entry mint_holder_to_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &KioskOwnerCap, Arg9: Coin<Ty0>, Arg10: Coin<SUI>, Arg11: u64, Arg12: u64, Arg13: u64, Arg14: u128, Arg15: u64, Arg16: &Clock, Arg17: &Random, Arg18: &mut TxContext) {
L19: loc0: RandomGenerator
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[15](Arg15: u64)
3Call assert_revision(&Collection, u64)
4MoveLoc[17](Arg17: &Random)
5CopyLoc[18](Arg18: &mut TxContext)
6Call random::new_generator(&Random, &mut TxContext): RandomGenerator
7StLoc[19](loc0: RandomGenerator)
8MoveLoc[0](Arg0: &mut Collection)
9MoveLoc[1](Arg1: &mut Vault<Ty0>)
10MoveLoc[2](Arg2: &mut SuiSystemState)
11MoveLoc[3](Arg3: &GlobalConfig)
12MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
13MoveLoc[5](Arg5: &mut BurnManager)
14MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
15MoveLoc[7](Arg7: &mut Kiosk)
16MoveLoc[8](Arg8: &KioskOwnerCap)
17ImmBorrowLoc[9](Arg9: Coin<Ty0>)
18Call coin::value<Ty0>(&Coin<Ty0>): u64
19Call option::some<u64>(u64): Option<u64>
20MoveLoc[10](Arg10: Coin<SUI>)
21MoveLoc[11](Arg11: u64)
22MoveLoc[12](Arg12: u64)
23MoveLoc[13](Arg13: u64)
24MoveLoc[14](Arg14: u128)
25MoveLoc[16](Arg16: &Clock)
26MutBorrowLoc[19](loc0: RandomGenerator)
27CopyLoc[18](Arg18: &mut TxContext)
28Call mint_drawn<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Option<u64>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut RandomGenerator, &mut TxContext)
29MoveLoc[9](Arg9: Coin<Ty0>)
30MoveLoc[18](Arg18: &mut TxContext)
31FreezeRef
32Call tx_context::sender(&TxContext): address
33Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
34Ret
}
entry mint_holder_to_new_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: Coin<Ty0>, Arg8: Coin<SUI>, Arg9: u64, Arg10: u64, Arg11: u64, Arg12: u128, Arg13: u64, Arg14: &Clock, Arg15: &Random, Arg16: &mut TxContext) {
L17: loc0: RandomGenerator
L18: loc1: Kiosk
L19: loc2: KioskOwnerCap
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[13](Arg13: u64)
3Call assert_revision(&Collection, u64)
4MoveLoc[15](Arg15: &Random)
5CopyLoc[16](Arg16: &mut TxContext)
6Call random::new_generator(&Random, &mut TxContext): RandomGenerator
7StLoc[17](loc0: RandomGenerator)
8CopyLoc[16](Arg16: &mut TxContext)
9Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap
10StLoc[19](loc2: KioskOwnerCap)
11StLoc[18](loc1: Kiosk)
12MoveLoc[0](Arg0: &mut Collection)
13MoveLoc[1](Arg1: &mut Vault<Ty0>)
14MoveLoc[2](Arg2: &mut SuiSystemState)
15MoveLoc[3](Arg3: &GlobalConfig)
16MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
17MoveLoc[5](Arg5: &mut BurnManager)
18MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
19MutBorrowLoc[18](loc1: Kiosk)
20ImmBorrowLoc[19](loc2: KioskOwnerCap)
21ImmBorrowLoc[7](Arg7: Coin<Ty0>)
22Call coin::value<Ty0>(&Coin<Ty0>): u64
23Call option::some<u64>(u64): Option<u64>
24MoveLoc[8](Arg8: Coin<SUI>)
25MoveLoc[9](Arg9: u64)
26MoveLoc[10](Arg10: u64)
27MoveLoc[11](Arg11: u64)
28MoveLoc[12](Arg12: u128)
29MoveLoc[14](Arg14: &Clock)
30MutBorrowLoc[17](loc0: RandomGenerator)
31CopyLoc[16](Arg16: &mut TxContext)
32Call mint_drawn<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Option<u64>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut RandomGenerator, &mut TxContext)
33MoveLoc[7](Arg7: Coin<Ty0>)
34CopyLoc[16](Arg16: &mut TxContext)
35FreezeRef
36Call tx_context::sender(&TxContext): address
37Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
38MoveLoc[18](loc1: Kiosk)
39Call transfer::public_share_object<Kiosk>(Kiosk)
40MoveLoc[19](loc2: KioskOwnerCap)
41MoveLoc[16](Arg16: &mut TxContext)
42FreezeRef
43Call tx_context::sender(&TxContext): address
44Call transfer::public_transfer<KioskOwnerCap>(KioskOwnerCap, address)
45Ret
}
entry mint_holder_to_personal_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &mut PersonalKioskCap, Arg9: Coin<Ty0>, Arg10: Coin<SUI>, Arg11: u64, Arg12: u64, Arg13: u64, Arg14: u128, Arg15: u64, Arg16: &Clock, Arg17: &Random, Arg18: &mut TxContext) {
L19: loc0: Borrow
L20: loc1: RandomGenerator
L21: loc2: KioskOwnerCap
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[15](Arg15: u64)
3Call assert_revision(&Collection, u64)
4MoveLoc[17](Arg17: &Random)
5CopyLoc[18](Arg18: &mut TxContext)
6Call random::new_generator(&Random, &mut TxContext): RandomGenerator
7StLoc[20](loc1: RandomGenerator)
8CopyLoc[8](Arg8: &mut PersonalKioskCap)
9Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow
10StLoc[19](loc0: Borrow)
11StLoc[21](loc2: KioskOwnerCap)
12MoveLoc[0](Arg0: &mut Collection)
13MoveLoc[1](Arg1: &mut Vault<Ty0>)
14MoveLoc[2](Arg2: &mut SuiSystemState)
15MoveLoc[3](Arg3: &GlobalConfig)
16MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
17MoveLoc[5](Arg5: &mut BurnManager)
18MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
19MoveLoc[7](Arg7: &mut Kiosk)
20ImmBorrowLoc[21](loc2: KioskOwnerCap)
21ImmBorrowLoc[9](Arg9: Coin<Ty0>)
22Call coin::value<Ty0>(&Coin<Ty0>): u64
23Call option::some<u64>(u64): Option<u64>
24MoveLoc[10](Arg10: Coin<SUI>)
25MoveLoc[11](Arg11: u64)
26MoveLoc[12](Arg12: u64)
27MoveLoc[13](Arg13: u64)
28MoveLoc[14](Arg14: u128)
29MoveLoc[16](Arg16: &Clock)
30MutBorrowLoc[20](loc1: RandomGenerator)
31CopyLoc[18](Arg18: &mut TxContext)
32Call mint_drawn<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Option<u64>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut RandomGenerator, &mut TxContext)
33MoveLoc[9](Arg9: Coin<Ty0>)
34MoveLoc[18](Arg18: &mut TxContext)
35FreezeRef
36Call tx_context::sender(&TxContext): address
37Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
38MoveLoc[8](Arg8: &mut PersonalKioskCap)
39MoveLoc[21](loc2: KioskOwnerCap)
40MoveLoc[19](loc0: Borrow)
41Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)
42Ret
}
entry mint_reserved_to_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &KioskOwnerCap, Arg9: Coin<SUI>, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: u128, Arg14: u64, Arg15: &Clock, Arg16: &mut TxContext) {
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[14](Arg14: u64)
3Call assert_revision(&Collection, u64)
4MoveLoc[0](Arg0: &mut Collection)
5MoveLoc[1](Arg1: &mut Vault<Ty0>)
6MoveLoc[2](Arg2: &mut SuiSystemState)
7MoveLoc[3](Arg3: &GlobalConfig)
8MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
9MoveLoc[5](Arg5: &mut BurnManager)
10MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
11MoveLoc[7](Arg7: &mut Kiosk)
12MoveLoc[8](Arg8: &KioskOwnerCap)
13MoveLoc[9](Arg9: Coin<SUI>)
14MoveLoc[10](Arg10: u64)
15MoveLoc[11](Arg11: u64)
16MoveLoc[12](Arg12: u64)
17MoveLoc[13](Arg13: u128)
18MoveLoc[15](Arg15: &Clock)
19MoveLoc[16](Arg16: &mut TxContext)
20Call mint_reserved<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut TxContext)
21Ret
}
entry mint_reserved_to_new_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: Coin<SUI>, Arg8: u64, Arg9: u64, Arg10: u64, Arg11: u128, Arg12: u64, Arg13: &Clock, Arg14: &mut TxContext) {
L15: loc0: Kiosk
L16: loc1: KioskOwnerCap
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[12](Arg12: u64)
3Call assert_revision(&Collection, u64)
4CopyLoc[14](Arg14: &mut TxContext)
5Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap
6StLoc[16](loc1: KioskOwnerCap)
7StLoc[15](loc0: Kiosk)
8MoveLoc[0](Arg0: &mut Collection)
9MoveLoc[1](Arg1: &mut Vault<Ty0>)
10MoveLoc[2](Arg2: &mut SuiSystemState)
11MoveLoc[3](Arg3: &GlobalConfig)
12MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
13MoveLoc[5](Arg5: &mut BurnManager)
14MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
15MutBorrowLoc[15](loc0: Kiosk)
16ImmBorrowLoc[16](loc1: KioskOwnerCap)
17MoveLoc[7](Arg7: Coin<SUI>)
18MoveLoc[8](Arg8: u64)
19MoveLoc[9](Arg9: u64)
20MoveLoc[10](Arg10: u64)
21MoveLoc[11](Arg11: u128)
22MoveLoc[13](Arg13: &Clock)
23CopyLoc[14](Arg14: &mut TxContext)
24Call mint_reserved<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut TxContext)
25MoveLoc[15](loc0: Kiosk)
26Call transfer::public_share_object<Kiosk>(Kiosk)
27MoveLoc[16](loc1: KioskOwnerCap)
28MoveLoc[14](Arg14: &mut TxContext)
29FreezeRef
30Call tx_context::sender(&TxContext): address
31Call transfer::public_transfer<KioskOwnerCap>(KioskOwnerCap, address)
32Ret
}
entry mint_reserved_to_personal_kiosk<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &mut PersonalKioskCap, Arg9: Coin<SUI>, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: u128, Arg14: u64, Arg15: &Clock, Arg16: &mut TxContext) {
L17: loc0: Borrow
L18: loc1: KioskOwnerCap
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[14](Arg14: u64)
3Call assert_revision(&Collection, u64)
4CopyLoc[8](Arg8: &mut PersonalKioskCap)
5Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow
6StLoc[17](loc0: Borrow)
7StLoc[18](loc1: KioskOwnerCap)
8MoveLoc[0](Arg0: &mut Collection)
9MoveLoc[1](Arg1: &mut Vault<Ty0>)
10MoveLoc[2](Arg2: &mut SuiSystemState)
11MoveLoc[3](Arg3: &GlobalConfig)
12MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
13MoveLoc[5](Arg5: &mut BurnManager)
14MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
15MoveLoc[7](Arg7: &mut Kiosk)
16ImmBorrowLoc[18](loc1: KioskOwnerCap)
17MoveLoc[9](Arg9: Coin<SUI>)
18MoveLoc[10](Arg10: u64)
19MoveLoc[11](Arg11: u64)
20MoveLoc[12](Arg12: u64)
21MoveLoc[13](Arg13: u128)
22MoveLoc[15](Arg15: &Clock)
23MoveLoc[16](Arg16: &mut TxContext)
24Call mint_reserved<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, &mut Kiosk, &KioskOwnerCap, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut TxContext)
25MoveLoc[8](Arg8: &mut PersonalKioskCap)
26MoveLoc[18](loc1: KioskOwnerCap)
27MoveLoc[17](loc0: Borrow)
28Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)
29Ret
}
mint_drawn<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &KioskOwnerCap, Arg9: Option<u64>, Arg10: Coin<SUI>, Arg11: u64, Arg12: u64, Arg13: u64, Arg14: u128, Arg15: &Clock, Arg16: &mut RandomGenerator, Arg17: &mut TxContext) {
L18: loc0: bool
L19: loc1: u64
L20: loc2: u64
L21: loc3: KingFizh
L22: loc4: u64
L23: loc5: Coin<SUI>
L24: loc6: Balance<SUI>
L25: loc7: vector<StakedSui>
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2CopyLoc[15](Arg15: &Clock)
3Call clock::timestamp_ms(&Clock): u64
4MoveLoc[9](Arg9: Option<u64>)
5Call check_window(&Collection, u64, Option<u64>)
6CopyLoc[0](Arg0: &mut Collection)
7FreezeRef
8CopyLoc[15](Arg15: &Clock)
9Call clock::timestamp_ms(&Clock): u64
10Call check_public_inventory(&Collection, u64)
11CopyLoc[11](Arg11: u64)
12LdU64(1)
13Ge
14BrFalse(20)
B1:
15CopyLoc[11](Arg11: u64)
16LdConst[12](u64: 25)
17Le
18StLoc[18](loc0: bool)
19Branch(22)
B2:
20LdFalse
21StLoc[18](loc0: bool)
B3:
22MoveLoc[18](loc0: bool)
23BrFalse(25)
B4:
24Branch(51)
B5:
25MoveLoc[1](Arg1: &mut Vault<Ty0>)
26Pop
27MoveLoc[2](Arg2: &mut SuiSystemState)
28Pop
29MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
30Pop
31MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
32Pop
33MoveLoc[5](Arg5: &mut BurnManager)
34Pop
35MoveLoc[8](Arg8: &KioskOwnerCap)
36Pop
37MoveLoc[7](Arg7: &mut Kiosk)
38Pop
39MoveLoc[16](Arg16: &mut RandomGenerator)
40Pop
41MoveLoc[17](Arg17: &mut TxContext)
42Pop
43MoveLoc[3](Arg3: &GlobalConfig)
44Pop
45MoveLoc[0](Arg0: &mut Collection)
46Pop
47MoveLoc[15](Arg15: &Clock)
48Pop
49LdConst[47](u64: 116)
50Abort
B6:
51CopyLoc[11](Arg11: u64)
52CopyLoc[0](Arg0: &mut Collection)
53ImmBorrowField[1](Collection.supply: u64)
54ReadRef
55CopyLoc[0](Arg0: &mut Collection)
56ImmBorrowField[9](Collection.drawn: u64)
57ReadRef
58Sub
59Le
60BrFalse(62)
B7:
61Branch(88)
B8:
62MoveLoc[1](Arg1: &mut Vault<Ty0>)
63Pop
64MoveLoc[2](Arg2: &mut SuiSystemState)
65Pop
66MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
67Pop
68MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
69Pop
70MoveLoc[5](Arg5: &mut BurnManager)
71Pop
72MoveLoc[8](Arg8: &KioskOwnerCap)
73Pop
74MoveLoc[7](Arg7: &mut Kiosk)
75Pop
76MoveLoc[16](Arg16: &mut RandomGenerator)
77Pop
78MoveLoc[17](Arg17: &mut TxContext)
79Pop
80MoveLoc[3](Arg3: &GlobalConfig)
81Pop
82MoveLoc[0](Arg0: &mut Collection)
83Pop
84MoveLoc[15](Arg15: &Clock)
85Pop
86LdConst[33](u64: 102)
87Abort
B9:
88CopyLoc[0](Arg0: &mut Collection)
89FreezeRef
90CopyLoc[1](Arg1: &mut Vault<Ty0>)
91MoveLoc[2](Arg2: &mut SuiSystemState)
92MoveLoc[3](Arg3: &GlobalConfig)
93MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
94MoveLoc[5](Arg5: &mut BurnManager)
95CopyLoc[6](Arg6: &TransferPolicy<KingFizh>)
96MoveLoc[10](Arg10: Coin<SUI>)
97CopyLoc[11](Arg11: u64)
98MoveLoc[12](Arg12: u64)
99MoveLoc[13](Arg13: u64)
100MoveLoc[14](Arg14: u128)
101MoveLoc[15](Arg15: &Clock)
102CopyLoc[17](Arg17: &mut TxContext)
103Call pay_and_lock<Ty0>(&Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut TxContext): vector<StakedSui> * u64 * Coin<SUI> * Balance<SUI>
104StLoc[24](loc6: Balance<SUI>)
105StLoc[23](loc5: Coin<SUI>)
106StLoc[22](loc4: u64)
107StLoc[25](loc7: vector<StakedSui>)
108LdU64(0)
109StLoc[19](loc1: u64)
B10:
110CopyLoc[19](loc1: u64)
111CopyLoc[11](Arg11: u64)
112Lt
113BrFalse(138)
B11:
114CopyLoc[0](Arg0: &mut Collection)
115CopyLoc[16](Arg16: &mut RandomGenerator)
116Call draw(&mut Collection, &mut RandomGenerator): u64
117StLoc[20](loc2: u64)
118CopyLoc[0](Arg0: &mut Collection)
119CopyLoc[1](Arg1: &mut Vault<Ty0>)
120MutBorrowLoc[25](loc7: vector<StakedSui>)
121VecPopBack(201)
122MoveLoc[20](loc2: u64)
123CopyLoc[22](loc4: u64)
124LdFalse
125CopyLoc[17](Arg17: &mut TxContext)
126Call forge<Ty0>(&mut Collection, &mut Vault<Ty0>, StakedSui, u64, u64, bool, &mut TxContext): KingFizh
127StLoc[21](loc3: KingFizh)
128CopyLoc[7](Arg7: &mut Kiosk)
129CopyLoc[8](Arg8: &KioskOwnerCap)
130CopyLoc[6](Arg6: &TransferPolicy<KingFizh>)
131MoveLoc[21](loc3: KingFizh)
132Call kiosk::lock<KingFizh>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<KingFizh>, KingFizh)
133MoveLoc[19](loc1: u64)
134LdU64(1)
135Add
136StLoc[19](loc1: u64)
137Branch(110)
B12:
138MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
139Pop
140MoveLoc[8](Arg8: &KioskOwnerCap)
141Pop
142MoveLoc[7](Arg7: &mut Kiosk)
143Pop
144MoveLoc[16](Arg16: &mut RandomGenerator)
145Pop
146MoveLoc[0](Arg0: &mut Collection)
147Pop
148MoveLoc[25](loc7: vector<StakedSui>)
149VecUnpack(201, 0)
150MoveLoc[1](Arg1: &mut Vault<Ty0>)
151MoveLoc[24](loc6: Balance<SUI>)
152Call credit_slack<Ty0>(&mut Vault<Ty0>, Balance<SUI>)
153MoveLoc[23](loc5: Coin<SUI>)
154MoveLoc[17](Arg17: &mut TxContext)
155FreezeRef
156Call tx_context::sender(&TxContext): address
157Call send_sui(Coin<SUI>, address)
158Ret
}
mint_reserved<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: &mut Kiosk, Arg8: &KioskOwnerCap, Arg9: Coin<SUI>, Arg10: u64, Arg11: u64, Arg12: u64, Arg13: u128, Arg14: &Clock, Arg15: &mut TxContext) {
L16: loc0: KingFizh
L17: loc1: u64
L18: loc2: Coin<SUI>
L19: loc3: Balance<SUI>
L20: loc4: vector<StakedSui>
B0:
0CopyLoc[14](Arg14: &Clock)
1Call clock::timestamp_ms(&Clock): u64
2CopyLoc[0](Arg0: &mut Collection)
3ImmBorrowField[14](Collection.holder_start_ms: u64)
4ReadRef
5Ge
6BrFalse(8)
B1:
7Branch(32)
B2:
8MoveLoc[1](Arg1: &mut Vault<Ty0>)
9Pop
10MoveLoc[2](Arg2: &mut SuiSystemState)
11Pop
12MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
13Pop
14MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
15Pop
16MoveLoc[5](Arg5: &mut BurnManager)
17Pop
18MoveLoc[8](Arg8: &KioskOwnerCap)
19Pop
20MoveLoc[7](Arg7: &mut Kiosk)
21Pop
22MoveLoc[15](Arg15: &mut TxContext)
23Pop
24MoveLoc[3](Arg3: &GlobalConfig)
25Pop
26MoveLoc[0](Arg0: &mut Collection)
27Pop
28MoveLoc[14](Arg14: &Clock)
29Pop
30LdConst[65](u64: 135)
31Abort
B3:
32CopyLoc[0](Arg0: &mut Collection)
33ImmBorrowField[8](Collection.reservations: Table<u64, address>)
34CopyLoc[10](Arg10: u64)
35Call table::contains<u64, address>(&Table<u64, address>, u64): bool
36BrFalse(38)
B4:
37Branch(62)
B5:
38MoveLoc[1](Arg1: &mut Vault<Ty0>)
39Pop
40MoveLoc[2](Arg2: &mut SuiSystemState)
41Pop
42MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
43Pop
44MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
45Pop
46MoveLoc[5](Arg5: &mut BurnManager)
47Pop
48MoveLoc[8](Arg8: &KioskOwnerCap)
49Pop
50MoveLoc[7](Arg7: &mut Kiosk)
51Pop
52MoveLoc[15](Arg15: &mut TxContext)
53Pop
54MoveLoc[3](Arg3: &GlobalConfig)
55Pop
56MoveLoc[0](Arg0: &mut Collection)
57Pop
58MoveLoc[14](Arg14: &Clock)
59Pop
60LdConst[59](u64: 129)
61Abort
B6:
62CopyLoc[0](Arg0: &mut Collection)
63ImmBorrowField[8](Collection.reservations: Table<u64, address>)
64CopyLoc[10](Arg10: u64)
65Call table::borrow<u64, address>(&Table<u64, address>, u64): &address
66ReadRef
67CopyLoc[15](Arg15: &mut TxContext)
68FreezeRef
69Call tx_context::sender(&TxContext): address
70Eq
71BrFalse(73)
B7:
72Branch(97)
B8:
73MoveLoc[1](Arg1: &mut Vault<Ty0>)
74Pop
75MoveLoc[2](Arg2: &mut SuiSystemState)
76Pop
77MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
78Pop
79MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
80Pop
81MoveLoc[5](Arg5: &mut BurnManager)
82Pop
83MoveLoc[8](Arg8: &KioskOwnerCap)
84Pop
85MoveLoc[7](Arg7: &mut Kiosk)
86Pop
87MoveLoc[15](Arg15: &mut TxContext)
88Pop
89MoveLoc[3](Arg3: &GlobalConfig)
90Pop
91MoveLoc[0](Arg0: &mut Collection)
92Pop
93MoveLoc[14](Arg14: &Clock)
94Pop
95LdConst[60](u64: 130)
96Abort
B9:
97CopyLoc[0](Arg0: &mut Collection)
98MutBorrowField[8](Collection.reservations: Table<u64, address>)
99CopyLoc[10](Arg10: u64)
100Call table::remove<u64, address>(&mut Table<u64, address>, u64): address
101Pop
102CopyLoc[0](Arg0: &mut Collection)
103FreezeRef
104CopyLoc[1](Arg1: &mut Vault<Ty0>)
105MoveLoc[2](Arg2: &mut SuiSystemState)
106MoveLoc[3](Arg3: &GlobalConfig)
107MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
108MoveLoc[5](Arg5: &mut BurnManager)
109CopyLoc[6](Arg6: &TransferPolicy<KingFizh>)
110MoveLoc[9](Arg9: Coin<SUI>)
111LdU64(1)
112MoveLoc[11](Arg11: u64)
113MoveLoc[12](Arg12: u64)
114MoveLoc[13](Arg13: u128)
115MoveLoc[14](Arg14: &Clock)
116CopyLoc[15](Arg15: &mut TxContext)
117Call pay_and_lock<Ty0>(&Collection, &mut Vault<Ty0>, &mut SuiSystemState, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut BurnManager, &TransferPolicy<KingFizh>, Coin<SUI>, u64, u64, u64, u128, &Clock, &mut TxContext): vector<StakedSui> * u64 * Coin<SUI> * Balance<SUI>
118StLoc[19](loc3: Balance<SUI>)
119StLoc[18](loc2: Coin<SUI>)
120StLoc[17](loc1: u64)
121StLoc[20](loc4: vector<StakedSui>)
122MoveLoc[0](Arg0: &mut Collection)
123CopyLoc[1](Arg1: &mut Vault<Ty0>)
124MutBorrowLoc[20](loc4: vector<StakedSui>)
125VecPopBack(201)
126MoveLoc[10](Arg10: u64)
127MoveLoc[17](loc1: u64)
128LdTrue
129CopyLoc[15](Arg15: &mut TxContext)
130Call forge<Ty0>(&mut Collection, &mut Vault<Ty0>, StakedSui, u64, u64, bool, &mut TxContext): KingFizh
131StLoc[16](loc0: KingFizh)
132MoveLoc[7](Arg7: &mut Kiosk)
133MoveLoc[8](Arg8: &KioskOwnerCap)
134MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
135MoveLoc[16](loc0: KingFizh)
136Call kiosk::lock<KingFizh>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<KingFizh>, KingFizh)
137MoveLoc[20](loc4: vector<StakedSui>)
138VecUnpack(201, 0)
139MoveLoc[1](Arg1: &mut Vault<Ty0>)
140MoveLoc[19](loc3: Balance<SUI>)
141Call credit_slack<Ty0>(&mut Vault<Ty0>, Balance<SUI>)
142MoveLoc[18](loc2: Coin<SUI>)
143MoveLoc[15](Arg15: &mut TxContext)
144FreezeRef
145Call tx_context::sender(&TxContext): address
146Call send_sui(Coin<SUI>, address)
147Ret
}
check_window(Arg0: &Collection, Arg1: u64, Arg2: Option<u64>) {
B0:
0ImmBorrowLoc[2](Arg2: Option<u64>)
1Call option::is_some<u64>(&Option<u64>): bool
2BrFalse(25)
B1:
3MoveLoc[1](Arg1: u64)
4CopyLoc[0](Arg0: &Collection)
5ImmBorrowField[14](Collection.holder_start_ms: u64)
6ReadRef
7Ge
8BrFalse(10)
B2:
9Branch(14)
B3:
10MoveLoc[0](Arg0: &Collection)
11Pop
12LdConst[65](u64: 135)
13Abort
B4:
14ImmBorrowLoc[2](Arg2: Option<u64>)
15Call option::borrow<u64>(&Option<u64>): &u64
16ReadRef
17MoveLoc[0](Arg0: &Collection)
18ImmBorrowField[32](Collection.min_holder_balance: u64)
19ReadRef
20Ge
21BrFalse(23)
B5:
22Branch(34)
B6:
23LdConst[66](u64: 136)
24Abort
B7:
25MoveLoc[1](Arg1: u64)
26MoveLoc[0](Arg0: &Collection)
27ImmBorrowField[18](Collection.public_start_ms: u64)
28ReadRef
29Ge
30BrFalse(32)
B8:
31Branch(34)
B9:
32LdConst[65](u64: 135)
33Abort
B10:
34Ret
}
check_public_inventory(Arg0: &Collection, Arg1: u64) {
L2: loc0: bool
B0:
0CopyLoc[1](Arg1: u64)
1CopyLoc[0](Arg0: &Collection)
2ImmBorrowField[18](Collection.public_start_ms: u64)
3ReadRef
4Ge
5BrFalse(18)
B1:
6MoveLoc[1](Arg1: u64)
7CopyLoc[0](Arg0: &Collection)
8ImmBorrowField[18](Collection.public_start_ms: u64)
9ReadRef
10Sub
11CopyLoc[0](Arg0: &Collection)
12Call settings(&Collection): &SettingsV1
13ImmBorrowField[19](SettingsV1.migration_duration_ms: u64)
14ReadRef
15Ge
16StLoc[2](loc0: bool)
17Branch(20)
B2:
18LdFalse
19StLoc[2](loc0: bool)
B3:
20MoveLoc[2](loc0: bool)
21BrFalse(31)
B4:
22MoveLoc[0](Arg0: &Collection)
23Call legacy_state(&Collection): &State
24Call legacy::reserved_count(&State): u64
25LdU64(0)
26Eq
27BrFalse(29)
B5:
28Branch(33)
B6:
29LdConst[71](u64: 142)
30Abort
B7:
31MoveLoc[0](Arg0: &Collection)
32Pop
B8:
33Ret
}
pay_and_lock<Ty0>(Arg0: &Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: &mut BurnManager, Arg6: &TransferPolicy<KingFizh>, Arg7: Coin<SUI>, Arg8: u64, Arg9: u64, Arg10: u64, Arg11: u128, Arg12: &Clock, Arg13: &mut TxContext): vector<StakedSui> * u64 * Coin<SUI> * Balance<SUI> {
L14: loc0: bool
L15: loc1: bool
L16: loc2: Coin<SUI>
L17: loc3: u64
L18: loc4: Balance<Ty0>
L19: loc5: u64
L20: loc6: u128
L21: loc7: u64
L22: loc8: Coin<SUI>
L23: loc9: Position
L24: loc10: u64
L25: loc11: address
L26: loc12: u64
L27: loc13: Balance<SUI>
L28: loc14: Balance<SUI>
L29: loc15: Coin<SUI>
L30: loc16: ID
L31: loc17: u64
L32: loc18: CetusLPBurnProof
L33: loc19: AddLiquidityReceipt<Ty0, SUI>
L34: loc20: vector<StakedSui>
L35: loc21: u64
L36: loc22: FlashSwapReceipt<Ty0, SUI>
L37: loc23: u32
L38: loc24: u32
L39: loc25: Balance<SUI>
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2CopyLoc[1](Arg1: &mut Vault<Ty0>)
3FreezeRef
4Call check_vault<Ty0>(&Vault<Ty0>)
5CopyLoc[0](Arg0: &Collection)
6ImmBorrowField[6](Collection.mint_open: bool)
7ReadRef
8BrFalse(10)
B1:
9Branch(30)
B2:
10MoveLoc[1](Arg1: &mut Vault<Ty0>)
11Pop
12MoveLoc[2](Arg2: &mut SuiSystemState)
13Pop
14MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
15Pop
16MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
17Pop
18MoveLoc[5](Arg5: &mut BurnManager)
19Pop
20MoveLoc[13](Arg13: &mut TxContext)
21Pop
22MoveLoc[3](Arg3: &GlobalConfig)
23Pop
24MoveLoc[0](Arg0: &Collection)
25Pop
26MoveLoc[12](Arg12: &Clock)
27Pop
28LdConst[32](u64: 101)
29Abort
B3:
30CopyLoc[0](Arg0: &Collection)
31LdU8(0)
32Call assert_action(&Collection, u8)
33CopyLoc[0](Arg0: &Collection)
34Call assert_configured(&Collection)
35CopyLoc[1](Arg1: &mut Vault<Ty0>)
36ImmBorrowFieldGeneric[0](Vault.collection: ID)
37ReadRef
38CopyLoc[0](Arg0: &Collection)
39Call object::id<Collection>(&Collection): ID
40Eq
41BrFalse(43)
B4:
42Branch(63)
B5:
43MoveLoc[1](Arg1: &mut Vault<Ty0>)
44Pop
45MoveLoc[2](Arg2: &mut SuiSystemState)
46Pop
47MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
48Pop
49MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
50Pop
51MoveLoc[5](Arg5: &mut BurnManager)
52Pop
53MoveLoc[13](Arg13: &mut TxContext)
54Pop
55MoveLoc[3](Arg3: &GlobalConfig)
56Pop
57MoveLoc[0](Arg0: &Collection)
58Pop
59MoveLoc[12](Arg12: &Clock)
60Pop
61LdConst[41](u64: 110)
62Abort
B6:
63MoveLoc[6](Arg6: &TransferPolicy<KingFizh>)
64Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
65CopyLoc[0](Arg0: &Collection)
66ImmBorrowField[13](Collection.policy: ID)
67ReadRef
68Eq
69BrFalse(71)
B7:
70Branch(89)
B8:
71MoveLoc[1](Arg1: &mut Vault<Ty0>)
72Pop
73MoveLoc[2](Arg2: &mut SuiSystemState)
74Pop
75MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
76Pop
77MoveLoc[5](Arg5: &mut BurnManager)
78Pop
79MoveLoc[13](Arg13: &mut TxContext)
80Pop
81MoveLoc[3](Arg3: &GlobalConfig)
82Pop
83MoveLoc[0](Arg0: &Collection)
84Pop
85MoveLoc[12](Arg12: &Clock)
86Pop
87LdConst[49](u64: 118)
88Abort
B9:
89CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
90FreezeRef
91Call object::id<Pool<Ty0, SUI>>(&Pool<Ty0, SUI>): ID
92StLoc[30](loc16: ID)
93CopyLoc[30](loc16: ID)
94CopyLoc[0](Arg0: &Collection)
95ImmBorrowField[22](Collection.swap_pool: ID)
96ReadRef
97Eq
98BrFalse(106)
B10:
99CopyLoc[30](loc16: ID)
100CopyLoc[0](Arg0: &Collection)
101ImmBorrowField[23](Collection.lp_pool: ID)
102ReadRef
103Eq
104StLoc[14](loc0: bool)
105Branch(108)
B11:
106LdFalse
107StLoc[14](loc0: bool)
B12:
108MoveLoc[14](loc0: bool)
109BrFalse(111)
B13:
110Branch(129)
B14:
111MoveLoc[1](Arg1: &mut Vault<Ty0>)
112Pop
113MoveLoc[2](Arg2: &mut SuiSystemState)
114Pop
115MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
116Pop
117MoveLoc[5](Arg5: &mut BurnManager)
118Pop
119MoveLoc[13](Arg13: &mut TxContext)
120Pop
121MoveLoc[3](Arg3: &GlobalConfig)
122Pop
123MoveLoc[0](Arg0: &Collection)
124Pop
125MoveLoc[12](Arg12: &Clock)
126Pop
127LdConst[36](u64: 105)
128Abort
B15:
129CopyLoc[0](Arg0: &Collection)
130ImmBorrowField[45](Collection.price: u64)
131ReadRef
132CopyLoc[9](Arg9: u64)
133Le
134BrFalse(136)
B16:
135Branch(154)
B17:
136MoveLoc[1](Arg1: &mut Vault<Ty0>)
137Pop
138MoveLoc[2](Arg2: &mut SuiSystemState)
139Pop
140MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
141Pop
142MoveLoc[5](Arg5: &mut BurnManager)
143Pop
144MoveLoc[13](Arg13: &mut TxContext)
145Pop
146MoveLoc[3](Arg3: &GlobalConfig)
147Pop
148MoveLoc[0](Arg0: &Collection)
149Pop
150MoveLoc[12](Arg12: &Clock)
151Pop
152LdConst[35](u64: 104)
153Abort
B18:
154ImmBorrowLoc[7](Arg7: Coin<SUI>)
155Call coin::value<SUI>(&Coin<SUI>): u64
156CopyLoc[0](Arg0: &Collection)
157ImmBorrowField[45](Collection.price: u64)
158ReadRef
159CopyLoc[8](Arg8: u64)
160Mul
161Ge
162BrFalse(164)
B19:
163Branch(182)
B20:
164MoveLoc[1](Arg1: &mut Vault<Ty0>)
165Pop
166MoveLoc[2](Arg2: &mut SuiSystemState)
167Pop
168MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
169Pop
170MoveLoc[5](Arg5: &mut BurnManager)
171Pop
172MoveLoc[13](Arg13: &mut TxContext)
173Pop
174MoveLoc[3](Arg3: &GlobalConfig)
175Pop
176MoveLoc[0](Arg0: &Collection)
177Pop
178MoveLoc[12](Arg12: &Clock)
179Pop
180LdConst[34](u64: 103)
181Abort
B21:
182CopyLoc[0](Arg0: &Collection)
183ImmBorrowField[46](Collection.lp_amount: u64)
184ReadRef
185CopyLoc[8](Arg8: u64)
186Mul
187StLoc[24](loc10: u64)
188CopyLoc[10](Arg10: u64)
189LdU64(0)
190Gt
191BrFalse(197)
B22:
192CopyLoc[10](Arg10: u64)
193CopyLoc[24](loc10: u64)
194Lt
195StLoc[15](loc1: bool)
196Branch(199)
B23:
197LdFalse
198StLoc[15](loc1: bool)
B24:
199MoveLoc[15](loc1: bool)
200BrFalse(202)
B25:
201Branch(220)
B26:
202MoveLoc[1](Arg1: &mut Vault<Ty0>)
203Pop
204MoveLoc[2](Arg2: &mut SuiSystemState)
205Pop
206MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
207Pop
208MoveLoc[5](Arg5: &mut BurnManager)
209Pop
210MoveLoc[13](Arg13: &mut TxContext)
211Pop
212MoveLoc[3](Arg3: &GlobalConfig)
213Pop
214MoveLoc[0](Arg0: &Collection)
215Pop
216MoveLoc[12](Arg12: &Clock)
217Pop
218LdConst[37](u64: 106)
219Abort
B27:
220CopyLoc[13](Arg13: &mut TxContext)
221FreezeRef
222Call tx_context::sender(&TxContext): address
223StLoc[25](loc11: address)
224CopyLoc[0](Arg0: &Collection)
225ImmBorrowField[45](Collection.price: u64)
226ReadRef
227CopyLoc[0](Arg0: &Collection)
228ImmBorrowField[15](Collection.stake_amount: u64)
229ReadRef
230Sub
231CopyLoc[0](Arg0: &Collection)
232ImmBorrowField[46](Collection.lp_amount: u64)
233ReadRef
234Sub
235CopyLoc[8](Arg8: u64)
236Mul
237StLoc[17](loc3: u64)
238CopyLoc[0](Arg0: &Collection)
239MoveLoc[7](Arg7: Coin<SUI>)
240LdU8(0)
241CopyLoc[8](Arg8: u64)
242MoveLoc[9](Arg9: u64)
243CopyLoc[13](Arg13: &mut TxContext)
244Call route_payment(&Collection, Coin<SUI>, u8, u64, u64, &mut TxContext): Coin<SUI> * Coin<SUI>
245StLoc[16](loc2: Coin<SUI>)
246StLoc[29](loc15: Coin<SUI>)
247VecPack(201, 0)
248StLoc[34](loc20: vector<StakedSui>)
249LdU64(0)
250StLoc[19](loc5: u64)
B28:
251CopyLoc[19](loc5: u64)
252CopyLoc[8](Arg8: u64)
253Lt
254BrFalse(274)
B29:
255MutBorrowLoc[34](loc20: vector<StakedSui>)
256CopyLoc[2](Arg2: &mut SuiSystemState)
257MutBorrowLoc[29](loc15: Coin<SUI>)
258CopyLoc[0](Arg0: &Collection)
259ImmBorrowField[15](Collection.stake_amount: u64)
260ReadRef
261CopyLoc[13](Arg13: &mut TxContext)
262Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>
263CopyLoc[0](Arg0: &Collection)
264ImmBorrowField[16](Collection.validator: address)
265ReadRef
266CopyLoc[13](Arg13: &mut TxContext)
267Call sui_system::request_add_stake_non_entry(&mut SuiSystemState, Coin<SUI>, address, &mut TxContext): StakedSui
268VecPushBack(201)
269MoveLoc[19](loc5: u64)
270LdU64(1)
271Add
272StLoc[19](loc5: u64)
273Branch(251)
B30:
274MoveLoc[2](Arg2: &mut SuiSystemState)
275Pop
276MoveLoc[0](Arg0: &Collection)
277Pop
278MutBorrowLoc[29](loc15: Coin<SUI>)
279CopyLoc[24](loc10: u64)
280CopyLoc[13](Arg13: &mut TxContext)
281Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>
282StLoc[22](loc8: Coin<SUI>)
283MoveLoc[29](loc15: Coin<SUI>)
284Call coin::destroy_zero<SUI>(Coin<SUI>)
285CopyLoc[3](Arg3: &GlobalConfig)
286CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
287LdFalse
288LdTrue
289MoveLoc[10](Arg10: u64)
290LdConst[21](u128: 7922..)
291CopyLoc[12](Arg12: &Clock)
292Call pool::flash_swap<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, bool, bool, u64, u128, &Clock): Balance<Ty0> * Balance<SUI> * FlashSwapReceipt<Ty0, SUI>
293StLoc[36](loc22: FlashSwapReceipt<Ty0, SUI>)
294StLoc[39](loc25: Balance<SUI>)
295StLoc[18](loc4: Balance<Ty0>)
296MoveLoc[39](loc25: Balance<SUI>)
297Call balance::destroy_zero<SUI>(Balance<SUI>)
298ImmBorrowLoc[36](loc22: FlashSwapReceipt<Ty0, SUI>)
299Call pool::swap_pay_amount<Ty0, SUI>(&FlashSwapReceipt<Ty0, SUI>): u64
300StLoc[35](loc21: u64)
301MutBorrowLoc[22](loc8: Coin<SUI>)
302CopyLoc[35](loc21: u64)
303CopyLoc[13](Arg13: &mut TxContext)
304Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>
305Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
306StLoc[28](loc14: Balance<SUI>)
307CopyLoc[3](Arg3: &GlobalConfig)
308CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
309Call balance::zero<Ty0>(): Balance<Ty0>
310MoveLoc[28](loc14: Balance<SUI>)
311MoveLoc[36](loc22: FlashSwapReceipt<Ty0, SUI>)
312Call pool::repay_flash_swap<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, Balance<Ty0>, Balance<SUI>, FlashSwapReceipt<Ty0, SUI>)
313ImmBorrowLoc[18](loc4: Balance<Ty0>)
314Call balance::value<Ty0>(&Balance<Ty0>): u64
315StLoc[21](loc7: u64)
316CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
317FreezeRef
318Call pool::tick_spacing<Ty0, SUI>(&Pool<Ty0, SUI>): u32
319Call full_range_ticks(u32): u32 * u32
320StLoc[38](loc24: u32)
321StLoc[37](loc23: u32)
322CopyLoc[3](Arg3: &GlobalConfig)
323CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
324MoveLoc[37](loc23: u32)
325MoveLoc[38](loc24: u32)
326CopyLoc[13](Arg13: &mut TxContext)
327Call pool::open_position<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, u32, u32, &mut TxContext): Position
328StLoc[23](loc9: Position)
329CopyLoc[3](Arg3: &GlobalConfig)
330CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
331MutBorrowLoc[23](loc9: Position)
332CopyLoc[21](loc7: u64)
333LdTrue
334MoveLoc[12](Arg12: &Clock)
335Call pool::add_liquidity_fix_coin<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, &mut Position, u64, bool, &Clock): AddLiquidityReceipt<Ty0, SUI>
336StLoc[33](loc19: AddLiquidityReceipt<Ty0, SUI>)
337ImmBorrowLoc[33](loc19: AddLiquidityReceipt<Ty0, SUI>)
338Call pool::add_liquidity_pay_amount<Ty0, SUI>(&AddLiquidityReceipt<Ty0, SUI>): u64 * u64
339StLoc[26](loc12: u64)
340CopyLoc[21](loc7: u64)
341Eq
342BrFalse(344)
B31:
343Branch(356)
B32:
344MoveLoc[1](Arg1: &mut Vault<Ty0>)
345Pop
346MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
347Pop
348MoveLoc[5](Arg5: &mut BurnManager)
349Pop
350MoveLoc[13](Arg13: &mut TxContext)
351Pop
352MoveLoc[3](Arg3: &GlobalConfig)
353Pop
354LdConst[38](u64: 107)
355Abort
B33:
356ImmBorrowLoc[22](loc8: Coin<SUI>)
357Call coin::value<SUI>(&Coin<SUI>): u64
358CopyLoc[26](loc12: u64)
359Ge
360BrFalse(362)
B34:
361Branch(374)
B35:
362MoveLoc[1](Arg1: &mut Vault<Ty0>)
363Pop
364MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
365Pop
366MoveLoc[5](Arg5: &mut BurnManager)
367Pop
368MoveLoc[13](Arg13: &mut TxContext)
369Pop
370MoveLoc[3](Arg3: &GlobalConfig)
371Pop
372LdConst[34](u64: 103)
373Abort
B36:
374MutBorrowLoc[22](loc8: Coin<SUI>)
375CopyLoc[26](loc12: u64)
376CopyLoc[13](Arg13: &mut TxContext)
377Call coin::split<SUI>(&mut Coin<SUI>, u64, &mut TxContext): Coin<SUI>
378Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
379StLoc[27](loc13: Balance<SUI>)
380MoveLoc[3](Arg3: &GlobalConfig)
381MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
382MoveLoc[18](loc4: Balance<Ty0>)
383MoveLoc[27](loc13: Balance<SUI>)
384MoveLoc[33](loc19: AddLiquidityReceipt<Ty0, SUI>)
385Call pool::repay_add_liquidity<Ty0, SUI>(&GlobalConfig, &mut Pool<Ty0, SUI>, Balance<Ty0>, Balance<SUI>, AddLiquidityReceipt<Ty0, SUI>)
386CopyLoc[35](loc21: u64)
387CopyLoc[26](loc12: u64)
388Add
389CastU128
390LdU128(10000)
391Mul
392MoveLoc[24](loc10: u64)
393CastU128
394LdU64(10000)
395LdConst[16](u64: 1000)
396Sub
397CastU128
398Mul
399Ge
400BrFalse(402)
B37:
401Branch(410)
B38:
402MoveLoc[1](Arg1: &mut Vault<Ty0>)
403Pop
404MoveLoc[5](Arg5: &mut BurnManager)
405Pop
406MoveLoc[13](Arg13: &mut TxContext)
407Pop
408LdConst[69](u64: 139)
409Abort
B39:
410ImmBorrowLoc[23](loc9: Position)
411Call position::liquidity(&Position): u128
412StLoc[20](loc6: u128)
413CopyLoc[20](loc6: u128)
414MoveLoc[11](Arg11: u128)
415Ge
416BrFalse(418)
B40:
417Branch(426)
B41:
418MoveLoc[1](Arg1: &mut Vault<Ty0>)
419Pop
420MoveLoc[5](Arg5: &mut BurnManager)
421Pop
422MoveLoc[13](Arg13: &mut TxContext)
423Pop
424LdConst[39](u64: 108)
425Abort
B42:
426MoveLoc[5](Arg5: &mut BurnManager)
427MoveLoc[23](loc9: Position)
428MoveLoc[13](Arg13: &mut TxContext)
429Call lp_burn::burn_lp_v2(&mut BurnManager, Position, &mut TxContext): CetusLPBurnProof
430StLoc[32](loc18: CetusLPBurnProof)
431CopyLoc[1](Arg1: &mut Vault<Ty0>)
432ImmBorrowFieldGeneric[4](Vault.positions: u64)
433ReadRef
434StLoc[31](loc17: u64)
435CopyLoc[1](Arg1: &mut Vault<Ty0>)
436MutBorrowFieldGeneric[5](Vault.proofs: Table<u64, CetusLPBurnProof>)
437CopyLoc[31](loc17: u64)
438MoveLoc[32](loc18: CetusLPBurnProof)
439Call table::add<u64, CetusLPBurnProof>(&mut Table<u64, CetusLPBurnProof>, u64, CetusLPBurnProof)
440CopyLoc[1](Arg1: &mut Vault<Ty0>)
441MutBorrowFieldGeneric[6](Vault.id: UID)
442CopyLoc[31](loc17: u64)
443Pack[6](PositionPoolKey)
444MoveLoc[30](loc16: ID)
445Call dynamic_field::add<PositionPoolKey, ID>(&mut UID, PositionPoolKey, ID)
446CopyLoc[31](loc17: u64)
447LdU64(1)
448Add
449CopyLoc[1](Arg1: &mut Vault<Ty0>)
450MutBorrowFieldGeneric[4](Vault.positions: u64)
451WriteRef
452MoveLoc[1](Arg1: &mut Vault<Ty0>)
453FreezeRef
454Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
455CopyLoc[31](loc17: u64)
456MoveLoc[8](Arg8: u64)
457MoveLoc[25](loc11: address)
458MoveLoc[20](loc6: u128)
459CopyLoc[35](loc21: u64)
460MoveLoc[35](loc21: u64)
461MoveLoc[26](loc12: u64)
462Add
463MoveLoc[21](loc7: u64)
464MoveLoc[17](loc3: u64)
465Pack[19](PositionLocked)
466Call event::emit<PositionLocked>(PositionLocked)
467MoveLoc[34](loc20: vector<StakedSui>)
468MoveLoc[31](loc17: u64)
469MoveLoc[16](loc2: Coin<SUI>)
470MoveLoc[22](loc8: Coin<SUI>)
471Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
472Ret
}
public full_range_ticks(Arg0: u32): u32 * u32 {
L1: loc0: bool
L2: loc1: u32
B0:
0CopyLoc[0](Arg0: u32)
1LdU32(0)
2Gt
3BrFalse(9)
B1:
4CopyLoc[0](Arg0: u32)
5LdConst[20](u32: 443636)
6Le
7StLoc[1](loc0: bool)
8Branch(11)
B2:
9LdFalse
10StLoc[1](loc0: bool)
B3:
11MoveLoc[1](loc0: bool)
12BrFalse(14)
B4:
13Branch(16)
B5:
14LdConst[54](u64: 123)
15Abort
B6:
16LdConst[20](u32: 443636)
17CopyLoc[0](Arg0: u32)
18Div
19MoveLoc[0](Arg0: u32)
20Mul
21StLoc[2](loc1: u32)
22LdU32(4294967295)
23CopyLoc[2](loc1: u32)
24Sub
25LdU32(1)
26Add
27MoveLoc[2](loc1: u32)
28Ret
}
credit_slack<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: Balance<SUI>) {
L2: loc0: u64
B0:
0ImmBorrowLoc[1](Arg1: Balance<SUI>)
1Call balance::value<SUI>(&Balance<SUI>): u64
2StLoc[2](loc0: u64)
3CopyLoc[0](Arg0: &mut Vault<Ty0>)
4ImmBorrowFieldGeneric[7](Vault.acc_b: u128)
5ReadRef
6CopyLoc[2](loc0: u64)
7CastU128
8LdConst[14](u128: 1000..)
9Mul
10CopyLoc[0](Arg0: &mut Vault<Ty0>)
11ImmBorrowFieldGeneric[8](Vault.live: u64)
12ReadRef
13CastU128
14Div
15Add
16CopyLoc[0](Arg0: &mut Vault<Ty0>)
17MutBorrowFieldGeneric[7](Vault.acc_b: u128)
18WriteRef
19CopyLoc[0](Arg0: &mut Vault<Ty0>)
20ImmBorrowFieldGeneric[9](Vault.swept_b: u64)
21ReadRef
22MoveLoc[2](loc0: u64)
23Add
24CopyLoc[0](Arg0: &mut Vault<Ty0>)
25MutBorrowFieldGeneric[9](Vault.swept_b: u64)
26WriteRef
27MoveLoc[0](Arg0: &mut Vault<Ty0>)
28MutBorrowFieldGeneric[10](Vault.pot_b: Balance<SUI>)
29MoveLoc[1](Arg1: Balance<SUI>)
30Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
31Pop
32Ret
}
draw(Arg0: &mut Collection, Arg1: &mut RandomGenerator): u64 {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[9](Collection.drawn: u64)
2ReadRef
3CopyLoc[0](Arg0: &mut Collection)
4ImmBorrowField[1](Collection.supply: u64)
5ReadRef
6Lt
7BrFalse(9)
B1:
8Branch(15)
B2:
9MoveLoc[1](Arg1: &mut RandomGenerator)
10Pop
11MoveLoc[0](Arg0: &mut Collection)
12Pop
13LdConst[33](u64: 102)
14Abort
B3:
15MoveLoc[1](Arg1: &mut RandomGenerator)
16LdU64(0)
17CopyLoc[0](Arg0: &mut Collection)
18ImmBorrowField[4](Collection.pool: vector<u16>)
19VecLen(173)
20LdU64(1)
21Sub
22Call random::generate_u64_in_range(&mut RandomGenerator, u64, u64): u64
23StLoc[2](loc0: u64)
24CopyLoc[0](Arg0: &mut Collection)
25ImmBorrowField[9](Collection.drawn: u64)
26ReadRef
27LdU64(1)
28Add
29CopyLoc[0](Arg0: &mut Collection)
30MutBorrowField[9](Collection.drawn: u64)
31WriteRef
32MoveLoc[0](Arg0: &mut Collection)
33MutBorrowField[4](Collection.pool: vector<u16>)
34MoveLoc[2](loc0: u64)
35Call vector::swap_remove<u16>(&mut vector<u16>, u64): u16
36CastU64
37Ret
}
forge<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: StakedSui, Arg3: u64, Arg4: u64, Arg5: bool, Arg6: &mut TxContext): KingFizh {
L7: loc0: VecMap<String, String>
L8: loc1: &ItemData
L9: loc2: VecMap<String, String>
L10: loc3: UID
L11: loc4: ID
L12: loc5: vector<u8>
L13: loc6: u64
L14: loc7: address
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[5](Collection.minted: u64)
2ReadRef
3CopyLoc[0](Arg0: &mut Collection)
4ImmBorrowField[1](Collection.supply: u64)
5ReadRef
6Lt
7BrFalse(9)
B1:
8Branch(17)
B2:
9MoveLoc[1](Arg1: &mut Vault<Ty0>)
10Pop
11MoveLoc[6](Arg6: &mut TxContext)
12Pop
13MoveLoc[0](Arg0: &mut Collection)
14Pop
15LdConst[33](u64: 102)
16Abort
B3:
17CopyLoc[0](Arg0: &mut Collection)
18ImmBorrowField[5](Collection.minted: u64)
19ReadRef
20LdU64(1)
21Add
22CopyLoc[0](Arg0: &mut Collection)
23MutBorrowField[5](Collection.minted: u64)
24WriteRef
25CopyLoc[1](Arg1: &mut Vault<Ty0>)
26ImmBorrowFieldGeneric[8](Vault.live: u64)
27ReadRef
28LdU64(1)
29Add
30CopyLoc[1](Arg1: &mut Vault<Ty0>)
31MutBorrowFieldGeneric[8](Vault.live: u64)
32WriteRef
33CopyLoc[0](Arg0: &mut Collection)
34ImmBorrowField[2](Collection.registry: Table<u64, ItemData>)
35CopyLoc[3](Arg3: u64)
36Call table::borrow<u64, ItemData>(&Table<u64, ItemData>, u64): &ItemData
37StLoc[8](loc1: &ItemData)
38CopyLoc[8](loc1: &ItemData)
39ImmBorrowField[54](ItemData.attributes: VecMap<String, String>)
40ReadRef
41StLoc[7](loc0: VecMap<String, String>)
42CopyLoc[8](loc1: &ItemData)
43ImmBorrowField[55](ItemData.filler: VecMap<String, String>)
44ReadRef
45StLoc[9](loc2: VecMap<String, String>)
46MoveLoc[8](loc1: &ItemData)
47ImmBorrowField[56](ItemData.pad: vector<u8>)
48ReadRef
49StLoc[12](loc5: vector<u8>)
50ImmBorrowLoc[2](Arg2: StakedSui)
51Call staking_pool::staked_sui_amount(&StakedSui): u64
52StLoc[13](loc6: u64)
53CopyLoc[13](loc6: u64)
54CopyLoc[0](Arg0: &mut Collection)
55ImmBorrowField[15](Collection.stake_amount: u64)
56ReadRef
57Eq
58BrFalse(60)
B4:
59Branch(68)
B5:
60MoveLoc[1](Arg1: &mut Vault<Ty0>)
61Pop
62MoveLoc[6](Arg6: &mut TxContext)
63Pop
64MoveLoc[0](Arg0: &mut Collection)
65Pop
66LdConst[44](u64: 113)
67Abort
B6:
68CopyLoc[0](Arg0: &mut Collection)
69ImmBorrowField[16](Collection.validator: address)
70ReadRef
71StLoc[14](loc7: address)
72CopyLoc[6](Arg6: &mut TxContext)
73Call object::new(&mut TxContext): UID
74StLoc[10](loc3: UID)
75ImmBorrowLoc[10](loc3: UID)
76Call object::uid_to_inner(&UID): ID
77StLoc[11](loc4: ID)
78CopyLoc[0](Arg0: &mut Collection)
79MutBorrowField[20](Collection.items: Table<u64, ID>)
80CopyLoc[3](Arg3: u64)
81CopyLoc[11](loc4: ID)
82Call table::add<u64, ID>(&mut Table<u64, ID>, u64, ID)
83MoveLoc[11](loc4: ID)
84CopyLoc[0](Arg0: &mut Collection)
85ImmBorrowField[5](Collection.minted: u64)
86ReadRef
87CopyLoc[3](Arg3: u64)
88CopyLoc[6](Arg6: &mut TxContext)
89FreezeRef
90Call tx_context::sender(&TxContext): address
91CopyLoc[13](loc6: u64)
92CopyLoc[14](loc7: address)
93CopyLoc[4](Arg4: u64)
94MoveLoc[5](Arg5: bool)
95Pack[18](Minted)
96Call event::emit<Minted>(Minted)
97MoveLoc[10](loc3: UID)
98MoveLoc[0](Arg0: &mut Collection)
99ImmBorrowField[5](Collection.minted: u64)
100ReadRef
101MoveLoc[3](Arg3: u64)
102MoveLoc[7](loc0: VecMap<String, String>)
103MoveLoc[9](loc2: VecMap<String, String>)
104LdConst[24](vector<u8>: "tok..)
105Call string::utf8(vector<u8>): String
106CopyLoc[1](Arg1: &mut Vault<Ty0>)
107FreezeRef
108Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
109MoveLoc[4](Arg4: u64)
110MoveLoc[2](Arg2: StakedSui)
111Call option::some<StakedSui>(StakedSui): Option<StakedSui>
112MoveLoc[13](loc6: u64)
113MoveLoc[14](loc7: address)
114LdConst[22](vector<u8>: "Act..)
115Call string::utf8(vector<u8>): String
116CopyLoc[1](Arg1: &mut Vault<Ty0>)
117ImmBorrowFieldGeneric[11](Vault.acc_a: u128)
118ReadRef
119MoveLoc[1](Arg1: &mut Vault<Ty0>)
120ImmBorrowFieldGeneric[7](Vault.acc_b: u128)
121ReadRef
122MoveLoc[6](Arg6: &mut TxContext)
123FreezeRef
124Call tx_context::epoch(&TxContext): u64
125LdU64(0)
126MoveLoc[12](loc5: vector<u8>)
127Pack[11](KingFizh)
128Ret
}
public migrate_to_kiosk<Ty0: store + key, Ty1>(Arg0: &mut Collection, Arg1: &mut Vault<Ty1>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: &mut Archive, Arg5: &mut Kiosk, Arg6: &KioskOwnerCap, Arg7: Ty0, Arg8: Coin<SUI>, Arg9: u64, Arg10: u64, Arg11: &Clock, Arg12: &mut TxContext) {
L13: loc0: Coin<SUI>
L14: loc1: ID
L15: loc2: u64
L16: loc3: KingFizh
B0:
0CopyLoc[0](Arg0: &mut Collection)
1MoveLoc[1](Arg1: &mut Vault<Ty1>)
2MoveLoc[2](Arg2: &mut SuiSystemState)
3CopyLoc[3](Arg3: &TransferPolicy<KingFizh>)
4ImmBorrowLoc[7](Arg7: Ty0)
5MoveLoc[8](Arg8: Coin<SUI>)
6MoveLoc[9](Arg9: u64)
7MoveLoc[10](Arg10: u64)
8MoveLoc[11](Arg11: &Clock)
9CopyLoc[12](Arg12: &mut TxContext)
10Call prepare_migration<Ty0, Ty1>(&mut Collection, &mut Vault<Ty1>, &mut SuiSystemState, &TransferPolicy<KingFizh>, &Ty0, Coin<SUI>, u64, u64, &Clock, &mut TxContext): KingFizh * Coin<SUI> * u64
11StLoc[15](loc2: u64)
12StLoc[13](loc0: Coin<SUI>)
13StLoc[16](loc3: KingFizh)
14CopyLoc[0](Arg0: &mut Collection)
15FreezeRef
16Call object::id<Collection>(&Collection): ID
17StLoc[14](loc1: ID)
18MoveLoc[0](Arg0: &mut Collection)
19FreezeRef
20Call legacy_state(&Collection): &State
21MoveLoc[4](Arg4: &mut Archive)
22MoveLoc[14](loc1: ID)
23MoveLoc[7](Arg7: Ty0)
24MoveLoc[15](loc2: u64)
25CopyLoc[12](Arg12: &mut TxContext)
26FreezeRef
27Call legacy::archive<Ty0>(&State, &mut Archive, ID, Ty0, u64, &TxContext)
28MoveLoc[5](Arg5: &mut Kiosk)
29MoveLoc[6](Arg6: &KioskOwnerCap)
30MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
31MoveLoc[16](loc3: KingFizh)
32Call kiosk::lock<KingFizh>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<KingFizh>, KingFizh)
33MoveLoc[13](loc0: Coin<SUI>)
34MoveLoc[12](Arg12: &mut TxContext)
35FreezeRef
36Call tx_context::sender(&TxContext): address
37Call send_sui(Coin<SUI>, address)
38Ret
}
public migrate_to_new_kiosk<Ty0: store + key, Ty1>(Arg0: &mut Collection, Arg1: &mut Vault<Ty1>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: &mut Archive, Arg5: Ty0, Arg6: Coin<SUI>, Arg7: u64, Arg8: u64, Arg9: &Clock, Arg10: &mut TxContext) {
L11: loc0: KioskOwnerCap
L12: loc1: Kiosk
B0:
0CopyLoc[10](Arg10: &mut TxContext)
1Call kiosk::new(&mut TxContext): Kiosk * KioskOwnerCap
2StLoc[11](loc0: KioskOwnerCap)
3StLoc[12](loc1: Kiosk)
4MoveLoc[0](Arg0: &mut Collection)
5MoveLoc[1](Arg1: &mut Vault<Ty1>)
6MoveLoc[2](Arg2: &mut SuiSystemState)
7MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
8MoveLoc[4](Arg4: &mut Archive)
9MutBorrowLoc[12](loc1: Kiosk)
10ImmBorrowLoc[11](loc0: KioskOwnerCap)
11MoveLoc[5](Arg5: Ty0)
12MoveLoc[6](Arg6: Coin<SUI>)
13MoveLoc[7](Arg7: u64)
14MoveLoc[8](Arg8: u64)
15MoveLoc[9](Arg9: &Clock)
16CopyLoc[10](Arg10: &mut TxContext)
17Call migrate_to_kiosk<Ty0, Ty1>(&mut Collection, &mut Vault<Ty1>, &mut SuiSystemState, &TransferPolicy<KingFizh>, &mut Archive, &mut Kiosk, &KioskOwnerCap, Ty0, Coin<SUI>, u64, u64, &Clock, &mut TxContext)
18MoveLoc[12](loc1: Kiosk)
19Call transfer::public_share_object<Kiosk>(Kiosk)
20MoveLoc[11](loc0: KioskOwnerCap)
21MoveLoc[10](Arg10: &mut TxContext)
22FreezeRef
23Call tx_context::sender(&TxContext): address
24Call transfer::public_transfer<KioskOwnerCap>(KioskOwnerCap, address)
25Ret
}
public migrate_to_personal_kiosk<Ty0: store + key, Ty1>(Arg0: &mut Collection, Arg1: &mut Vault<Ty1>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: &mut Archive, Arg5: &mut Kiosk, Arg6: &mut PersonalKioskCap, Arg7: Ty0, Arg8: Coin<SUI>, Arg9: u64, Arg10: u64, Arg11: &Clock, Arg12: &mut TxContext) {
L13: loc0: Borrow
L14: loc1: KioskOwnerCap
B0:
0CopyLoc[6](Arg6: &mut PersonalKioskCap)
1Call personal_kiosk::borrow_val(&mut PersonalKioskCap): KioskOwnerCap * Borrow
2StLoc[13](loc0: Borrow)
3StLoc[14](loc1: KioskOwnerCap)
4MoveLoc[0](Arg0: &mut Collection)
5MoveLoc[1](Arg1: &mut Vault<Ty1>)
6MoveLoc[2](Arg2: &mut SuiSystemState)
7MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
8MoveLoc[4](Arg4: &mut Archive)
9MoveLoc[5](Arg5: &mut Kiosk)
10ImmBorrowLoc[14](loc1: KioskOwnerCap)
11MoveLoc[7](Arg7: Ty0)
12MoveLoc[8](Arg8: Coin<SUI>)
13MoveLoc[9](Arg9: u64)
14MoveLoc[10](Arg10: u64)
15MoveLoc[11](Arg11: &Clock)
16MoveLoc[12](Arg12: &mut TxContext)
17Call migrate_to_kiosk<Ty0, Ty1>(&mut Collection, &mut Vault<Ty1>, &mut SuiSystemState, &TransferPolicy<KingFizh>, &mut Archive, &mut Kiosk, &KioskOwnerCap, Ty0, Coin<SUI>, u64, u64, &Clock, &mut TxContext)
18MoveLoc[6](Arg6: &mut PersonalKioskCap)
19MoveLoc[14](loc1: KioskOwnerCap)
20MoveLoc[13](loc0: Borrow)
21Call personal_kiosk::return_val(&mut PersonalKioskCap, KioskOwnerCap, Borrow)
22Ret
}
public migrate_from_kiosk<Ty0: store + key, Ty1>(Arg0: &mut Collection, Arg1: &mut Vault<Ty1>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: &mut Archive, Arg5: &mut Kiosk, Arg6: &KioskOwnerCap, Arg7: &mut Kiosk, Arg8: &KioskOwnerCap, Arg9: &mut TransferPolicy<Ty0>, Arg10: ID, Arg11: Coin<SUI>, Arg12: Coin<SUI>, Arg13: u64, Arg14: u64, Arg15: &Clock, Arg16: &mut TxContext) {
L17: loc0: Coin<SUI>
L18: loc1: ID
L19: loc2: u64
L20: loc3: KingFizh
L21: loc4: Ty0
L22: loc5: PurchaseCap<Ty0>
L23: loc6: TransferRequest<Ty0>
B0:
0Call legacy::assert_authentic<Ty0>()
1CopyLoc[7](Arg7: &mut Kiosk)
2MoveLoc[8](Arg8: &KioskOwnerCap)
3MoveLoc[10](Arg10: ID)
4LdU64(0)
5CopyLoc[16](Arg16: &mut TxContext)
6Call kiosk::list_with_purchase_cap<Ty0>(&mut Kiosk, &KioskOwnerCap, ID, u64, &mut TxContext): PurchaseCap<Ty0>
7StLoc[22](loc5: PurchaseCap<Ty0>)
8MoveLoc[7](Arg7: &mut Kiosk)
9MoveLoc[22](loc5: PurchaseCap<Ty0>)
10CopyLoc[16](Arg16: &mut TxContext)
11Call coin::zero<SUI>(&mut TxContext): Coin<SUI>
12Call kiosk::purchase_with_cap<Ty0>(&mut Kiosk, PurchaseCap<Ty0>, Coin<SUI>): Ty0 * TransferRequest<Ty0>
13StLoc[23](loc6: TransferRequest<Ty0>)
14StLoc[21](loc4: Ty0)
15CopyLoc[0](Arg0: &mut Collection)
16MoveLoc[1](Arg1: &mut Vault<Ty1>)
17MoveLoc[2](Arg2: &mut SuiSystemState)
18CopyLoc[3](Arg3: &TransferPolicy<KingFizh>)
19ImmBorrowLoc[21](loc4: Ty0)
20MoveLoc[11](Arg11: Coin<SUI>)
21MoveLoc[13](Arg13: u64)
22MoveLoc[14](Arg14: u64)
23MoveLoc[15](Arg15: &Clock)
24CopyLoc[16](Arg16: &mut TxContext)
25Call prepare_migration<Ty0, Ty1>(&mut Collection, &mut Vault<Ty1>, &mut SuiSystemState, &TransferPolicy<KingFizh>, &Ty0, Coin<SUI>, u64, u64, &Clock, &mut TxContext): KingFizh * Coin<SUI> * u64
26StLoc[19](loc2: u64)
27StLoc[17](loc0: Coin<SUI>)
28StLoc[20](loc3: KingFizh)
29CopyLoc[0](Arg0: &mut Collection)
30FreezeRef
31Call object::id<Collection>(&Collection): ID
32StLoc[18](loc1: ID)
33MoveLoc[0](Arg0: &mut Collection)
34FreezeRef
35Call legacy_state(&Collection): &State
36MoveLoc[4](Arg4: &mut Archive)
37MoveLoc[18](loc1: ID)
38MoveLoc[21](loc4: Ty0)
39MoveLoc[19](loc2: u64)
40MoveLoc[23](loc6: TransferRequest<Ty0>)
41MoveLoc[9](Arg9: &mut TransferPolicy<Ty0>)
42MoveLoc[12](Arg12: Coin<SUI>)
43CopyLoc[16](Arg16: &mut TxContext)
44Call legacy::archive_with_policy<Ty0>(&State, &mut Archive, ID, Ty0, u64, TransferRequest<Ty0>, &mut TransferPolicy<Ty0>, Coin<SUI>, &mut TxContext)
45MoveLoc[5](Arg5: &mut Kiosk)
46MoveLoc[6](Arg6: &KioskOwnerCap)
47MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
48MoveLoc[20](loc3: KingFizh)
49Call kiosk::lock<KingFizh>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<KingFizh>, KingFizh)
50MoveLoc[17](loc0: Coin<SUI>)
51MoveLoc[16](Arg16: &mut TxContext)
52FreezeRef
53Call tx_context::sender(&TxContext): address
54Call send_sui(Coin<SUI>, address)
55Ret
}
public migrate_in_kiosk<Ty0: store + key, Ty1>(Arg0: &mut Collection, Arg1: &mut Vault<Ty1>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: &mut Archive, Arg5: &mut Kiosk, Arg6: &KioskOwnerCap, Arg7: &mut TransferPolicy<Ty0>, Arg8: ID, Arg9: Coin<SUI>, Arg10: Coin<SUI>, Arg11: u64, Arg12: u64, Arg13: &Clock, Arg14: &mut TxContext) {
L15: loc0: Coin<SUI>
L16: loc1: ID
L17: loc2: u64
L18: loc3: KingFizh
L19: loc4: Ty0
L20: loc5: PurchaseCap<Ty0>
L21: loc6: TransferRequest<Ty0>
B0:
0Call legacy::assert_authentic<Ty0>()
1CopyLoc[5](Arg5: &mut Kiosk)
2CopyLoc[6](Arg6: &KioskOwnerCap)
3MoveLoc[8](Arg8: ID)
4LdU64(0)
5CopyLoc[14](Arg14: &mut TxContext)
6Call kiosk::list_with_purchase_cap<Ty0>(&mut Kiosk, &KioskOwnerCap, ID, u64, &mut TxContext): PurchaseCap<Ty0>
7StLoc[20](loc5: PurchaseCap<Ty0>)
8CopyLoc[5](Arg5: &mut Kiosk)
9MoveLoc[20](loc5: PurchaseCap<Ty0>)
10CopyLoc[14](Arg14: &mut TxContext)
11Call coin::zero<SUI>(&mut TxContext): Coin<SUI>
12Call kiosk::purchase_with_cap<Ty0>(&mut Kiosk, PurchaseCap<Ty0>, Coin<SUI>): Ty0 * TransferRequest<Ty0>
13StLoc[21](loc6: TransferRequest<Ty0>)
14StLoc[19](loc4: Ty0)
15CopyLoc[0](Arg0: &mut Collection)
16MoveLoc[1](Arg1: &mut Vault<Ty1>)
17MoveLoc[2](Arg2: &mut SuiSystemState)
18CopyLoc[3](Arg3: &TransferPolicy<KingFizh>)
19ImmBorrowLoc[19](loc4: Ty0)
20MoveLoc[9](Arg9: Coin<SUI>)
21MoveLoc[11](Arg11: u64)
22MoveLoc[12](Arg12: u64)
23MoveLoc[13](Arg13: &Clock)
24CopyLoc[14](Arg14: &mut TxContext)
25Call prepare_migration<Ty0, Ty1>(&mut Collection, &mut Vault<Ty1>, &mut SuiSystemState, &TransferPolicy<KingFizh>, &Ty0, Coin<SUI>, u64, u64, &Clock, &mut TxContext): KingFizh * Coin<SUI> * u64
26StLoc[17](loc2: u64)
27StLoc[15](loc0: Coin<SUI>)
28StLoc[18](loc3: KingFizh)
29CopyLoc[0](Arg0: &mut Collection)
30FreezeRef
31Call object::id<Collection>(&Collection): ID
32StLoc[16](loc1: ID)
33MoveLoc[0](Arg0: &mut Collection)
34FreezeRef
35Call legacy_state(&Collection): &State
36MoveLoc[4](Arg4: &mut Archive)
37MoveLoc[16](loc1: ID)
38MoveLoc[19](loc4: Ty0)
39MoveLoc[17](loc2: u64)
40MoveLoc[21](loc6: TransferRequest<Ty0>)
41MoveLoc[7](Arg7: &mut TransferPolicy<Ty0>)
42MoveLoc[10](Arg10: Coin<SUI>)
43CopyLoc[14](Arg14: &mut TxContext)
44Call legacy::archive_with_policy<Ty0>(&State, &mut Archive, ID, Ty0, u64, TransferRequest<Ty0>, &mut TransferPolicy<Ty0>, Coin<SUI>, &mut TxContext)
45MoveLoc[5](Arg5: &mut Kiosk)
46MoveLoc[6](Arg6: &KioskOwnerCap)
47MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
48MoveLoc[18](loc3: KingFizh)
49Call kiosk::lock<KingFizh>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<KingFizh>, KingFizh)
50MoveLoc[15](loc0: Coin<SUI>)
51MoveLoc[14](Arg14: &mut TxContext)
52FreezeRef
53Call tx_context::sender(&TxContext): address
54Call send_sui(Coin<SUI>, address)
55Ret
}
prepare_migration<Ty0: store + key, Ty1>(Arg0: &mut Collection, Arg1: &mut Vault<Ty1>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: &Ty0, Arg5: Coin<SUI>, Arg6: u64, Arg7: u64, Arg8: &Clock, Arg9: &mut TxContext): KingFizh * Coin<SUI> * u64 {
L10: loc0: u64
L11: loc1: ID
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2MoveLoc[7](Arg7: u64)
3Call assert_revision(&Collection, u64)
4CopyLoc[4](Arg4: &Ty0)
5Call object::id<Ty0>(&Ty0): ID
6StLoc[11](loc1: ID)
7CopyLoc[0](Arg0: &mut Collection)
8FreezeRef
9Call legacy_state(&Collection): &State
10MoveLoc[4](Arg4: &Ty0)
11Call legacy::index<Ty0>(&State, &Ty0): u64
12StLoc[10](loc0: u64)
13MoveLoc[0](Arg0: &mut Collection)
14MoveLoc[1](Arg1: &mut Vault<Ty1>)
15MoveLoc[2](Arg2: &mut SuiSystemState)
16MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
17MoveLoc[11](loc1: ID)
18MoveLoc[10](loc0: u64)
19MoveLoc[5](Arg5: Coin<SUI>)
20MoveLoc[6](Arg6: u64)
21MoveLoc[8](Arg8: &Clock)
22MoveLoc[9](Arg9: &mut TxContext)
23Call prepare_migration_at_index<Ty1>(&mut Collection, &mut Vault<Ty1>, &mut SuiSystemState, &TransferPolicy<KingFizh>, ID, u64, Coin<SUI>, u64, &Clock, &mut TxContext): KingFizh * Coin<SUI> * u64
24Ret
}
prepare_migration_at_index<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &TransferPolicy<KingFizh>, Arg4: ID, Arg5: u64, Arg6: Coin<SUI>, Arg7: u64, Arg8: &Clock, Arg9: &mut TxContext): KingFizh * Coin<SUI> * u64 {
L10: loc0: Allocation
L11: loc1: address
L12: loc2: u64
L13: loc3: ID
L14: loc4: ID
L15: loc5: Coin<SUI>
L16: loc6: Coin<SUI>
L17: loc7: KingFizh
L18: loc8: u8
L19: loc9: StakedSui
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2CopyLoc[1](Arg1: &mut Vault<Ty0>)
3FreezeRef
4MoveLoc[3](Arg3: &TransferPolicy<KingFizh>)
5CopyLoc[4](Arg4: ID)
6CopyLoc[5](Arg5: u64)
7MoveLoc[8](Arg8: &Clock)
8Call clock::timestamp_ms(&Clock): u64
9CopyLoc[9](Arg9: &mut TxContext)
10FreezeRef
11Call tx_context::sender(&TxContext): address
12Call validate_migration<Ty0>(&Collection, &Vault<Ty0>, &TransferPolicy<KingFizh>, ID, u64, u64, address): u8
13StLoc[18](loc8: u8)
14CopyLoc[0](Arg0: &mut Collection)
15FreezeRef
16MoveLoc[6](Arg6: Coin<SUI>)
17CopyLoc[18](loc8: u8)
18LdU64(1)
19MoveLoc[7](Arg7: u64)
20CopyLoc[9](Arg9: &mut TxContext)
21Call route_payment(&Collection, Coin<SUI>, u8, u64, u64, &mut TxContext): Coin<SUI> * Coin<SUI>
22StLoc[16](loc6: Coin<SUI>)
23StLoc[15](loc5: Coin<SUI>)
24ImmBorrowLoc[15](loc5: Coin<SUI>)
25Call coin::value<SUI>(&Coin<SUI>): u64
26CopyLoc[0](Arg0: &mut Collection)
27ImmBorrowField[15](Collection.stake_amount: u64)
28ReadRef
29Eq
30BrFalse(32)
B1:
31Branch(42)
B2:
32MoveLoc[1](Arg1: &mut Vault<Ty0>)
33Pop
34MoveLoc[2](Arg2: &mut SuiSystemState)
35Pop
36MoveLoc[9](Arg9: &mut TxContext)
37Pop
38MoveLoc[0](Arg0: &mut Collection)
39Pop
40LdConst[44](u64: 113)
41Abort
B3:
42MoveLoc[2](Arg2: &mut SuiSystemState)
43MoveLoc[15](loc5: Coin<SUI>)
44CopyLoc[0](Arg0: &mut Collection)
45ImmBorrowField[16](Collection.validator: address)
46ReadRef
47CopyLoc[9](Arg9: &mut TxContext)
48Call sui_system::request_add_stake_non_entry(&mut SuiSystemState, Coin<SUI>, address, &mut TxContext): StakedSui
49StLoc[19](loc9: StakedSui)
50CopyLoc[0](Arg0: &mut Collection)
51Call legacy_state_mut(&mut Collection): &mut State
52CopyLoc[4](Arg4: ID)
53CopyLoc[5](Arg5: u64)
54Call legacy::record(&mut State, ID, u64)
55CopyLoc[0](Arg0: &mut Collection)
56MoveLoc[1](Arg1: &mut Vault<Ty0>)
57MoveLoc[19](loc9: StakedSui)
58CopyLoc[5](Arg5: u64)
59LdConst[26](u64: 1844..)
60LdTrue
61CopyLoc[9](Arg9: &mut TxContext)
62Call forge<Ty0>(&mut Collection, &mut Vault<Ty0>, StakedSui, u64, u64, bool, &mut TxContext): KingFizh
63StLoc[17](loc7: KingFizh)
64MoveLoc[4](Arg4: ID)
65StLoc[14](loc4: ID)
66ImmBorrowLoc[17](loc7: KingFizh)
67Call object::id<KingFizh>(&KingFizh): ID
68StLoc[13](loc3: ID)
69CopyLoc[5](Arg5: u64)
70StLoc[12](loc2: u64)
71MoveLoc[9](Arg9: &mut TxContext)
72FreezeRef
73Call tx_context::sender(&TxContext): address
74StLoc[11](loc1: address)
75MoveLoc[0](Arg0: &mut Collection)
76FreezeRef
77CopyLoc[18](loc8: u8)
78Call route_allocation(&Collection, u8): Allocation
79StLoc[10](loc0: Allocation)
80MoveLoc[14](loc4: ID)
81MoveLoc[13](loc3: ID)
82MoveLoc[12](loc2: u64)
83MoveLoc[11](loc1: address)
84ImmBorrowLoc[10](loc0: Allocation)
85Call terms::allocation_price(&Allocation): u64
86MoveLoc[18](loc8: u8)
87LdU8(2)
88Eq
89Pack[33](LegacyMigrated)
90Call event::emit<LegacyMigrated>(LegacyMigrated)
91MoveLoc[17](loc7: KingFizh)
92MoveLoc[16](loc6: Coin<SUI>)
93MoveLoc[5](Arg5: u64)
94Ret
}
validate_migration<Ty0>(Arg0: &Collection, Arg1: &Vault<Ty0>, Arg2: &TransferPolicy<KingFizh>, Arg3: ID, Arg4: u64, Arg5: u64, Arg6: address): u8 {
L7: loc0: bool
L8: loc1: bool
L9: loc2: u8
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2CopyLoc[1](Arg1: &Vault<Ty0>)
3Call check_vault<Ty0>(&Vault<Ty0>)
4CopyLoc[0](Arg0: &Collection)
5Call assert_configured(&Collection)
6CopyLoc[0](Arg0: &Collection)
7ImmBorrowField[6](Collection.mint_open: bool)
8ReadRef
9BrFalse(11)
B1:
10Branch(19)
B2:
11MoveLoc[1](Arg1: &Vault<Ty0>)
12Pop
13MoveLoc[2](Arg2: &TransferPolicy<KingFizh>)
14Pop
15MoveLoc[0](Arg0: &Collection)
16Pop
17LdConst[32](u64: 101)
18Abort
B3:
19CopyLoc[0](Arg0: &Collection)
20LdU8(1)
21Call assert_action(&Collection, u8)
22CopyLoc[1](Arg1: &Vault<Ty0>)
23ImmBorrowFieldGeneric[0](Vault.collection: ID)
24ReadRef
25CopyLoc[0](Arg0: &Collection)
26Call object::id<Collection>(&Collection): ID
27Eq
28BrFalse(37)
B4:
29MoveLoc[1](Arg1: &Vault<Ty0>)
30Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
31CopyLoc[0](Arg0: &Collection)
32ImmBorrowField[12](Collection.vault: ID)
33ReadRef
34Eq
35StLoc[7](loc0: bool)
36Branch(41)
B5:
37MoveLoc[1](Arg1: &Vault<Ty0>)
38Pop
39LdFalse
40StLoc[7](loc0: bool)
B6:
41MoveLoc[7](loc0: bool)
42BrFalse(44)
B7:
43Branch(50)
B8:
44MoveLoc[2](Arg2: &TransferPolicy<KingFizh>)
45Pop
46MoveLoc[0](Arg0: &Collection)
47Pop
48LdConst[41](u64: 110)
49Abort
B9:
50MoveLoc[2](Arg2: &TransferPolicy<KingFizh>)
51Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
52CopyLoc[0](Arg0: &Collection)
53ImmBorrowField[13](Collection.policy: ID)
54ReadRef
55Eq
56BrFalse(58)
B10:
57Branch(62)
B11:
58MoveLoc[0](Arg0: &Collection)
59Pop
60LdConst[49](u64: 118)
61Abort
B12:
62CopyLoc[4](Arg4: u64)
63LdU64(0)
64Gt
65BrFalse(82)
B13:
66CopyLoc[4](Arg4: u64)
67CopyLoc[0](Arg0: &Collection)
68ImmBorrowField[1](Collection.supply: u64)
69ReadRef
70Le
71BrFalse(79)
B14:
72CopyLoc[0](Arg0: &Collection)
73ImmBorrowField[20](Collection.items: Table<u64, ID>)
74CopyLoc[4](Arg4: u64)
75Call table::contains<u64, ID>(&Table<u64, ID>, u64): bool
76Not
77StLoc[8](loc1: bool)
78Branch(84)
B15:
79LdFalse
80StLoc[8](loc1: bool)
81Branch(84)
B16:
82LdFalse
83StLoc[8](loc1: bool)
B17:
84MoveLoc[8](loc1: bool)
85BrFalse(87)
B18:
86Branch(91)
B19:
87MoveLoc[0](Arg0: &Collection)
88Pop
89LdConst[53](u64: 122)
90Abort
B20:
91CopyLoc[0](Arg0: &Collection)
92Call legacy_state(&Collection): &State
93MoveLoc[3](Arg3: ID)
94MoveLoc[4](Arg4: u64)
95MoveLoc[5](Arg5: u64)
96CopyLoc[0](Arg0: &Collection)
97ImmBorrowField[18](Collection.public_start_ms: u64)
98ReadRef
99CopyLoc[0](Arg0: &Collection)
100Call settings(&Collection): &SettingsV1
101ImmBorrowField[19](SettingsV1.migration_duration_ms: u64)
102ReadRef
103Call legacy::check_claim_window(&State, ID, u64, u64, u64, u64)
104MoveLoc[0](Arg0: &Collection)
105Call legacy_state(&Collection): &State
106MoveLoc[6](Arg6: address)
107Call legacy::is_vip(&State, address): bool
108BrFalse(112)
B21:
109LdU8(2)
110StLoc[9](loc2: u8)
111Branch(114)
B22:
112LdU8(1)
113StLoc[9](loc2: u8)
B23:
114MoveLoc[9](loc2: u8)
115Ret
}
public configuration(Arg0: &Collection): &Config {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[10](Collection.id: UID)
2LdFalse
3Pack[5](ConfigKey)
4Call dynamic_object_field::borrow<ConfigKey, Config>(&UID, ConfigKey): &Config
5Ret
}
configuration_mut(Arg0: &mut Collection): &mut Config {
B0:
0MoveLoc[0](Arg0: &mut Collection)
1MutBorrowField[10](Collection.id: UID)
2LdFalse
3Pack[5](ConfigKey)
4Call dynamic_object_field::borrow_mut<ConfigKey, Config>(&mut UID, ConfigKey): &mut Config
5Ret
}
settings(Arg0: &Collection): &SettingsV1 {
L1: loc0: bool
L2: loc1: &Config
B0:
0CopyLoc[0](Arg0: &Collection)
1Call configuration(&Collection): &Config
2StLoc[2](loc1: &Config)
3CopyLoc[2](loc1: &Config)
4ImmBorrowField[41](Config.code_version: u64)
5ReadRef
6LdConst[13](u64: 1)
7Eq
8BrFalse(29)
B1:
9CopyLoc[2](loc1: &Config)
10ImmBorrowField[58](Config.collection: ID)
11ReadRef
12CopyLoc[0](Arg0: &Collection)
13Call object::id<Collection>(&Collection): ID
14Eq
15BrFalse(24)
B2:
16CopyLoc[2](loc1: &Config)
17Call object::id<Config>(&Config): ID
18MoveLoc[0](Arg0: &Collection)
19ImmBorrowField[59](Collection.config: ID)
20ReadRef
21Eq
22StLoc[1](loc0: bool)
23Branch(33)
B3:
24MoveLoc[0](Arg0: &Collection)
25Pop
26LdFalse
27StLoc[1](loc0: bool)
28Branch(33)
B4:
29MoveLoc[0](Arg0: &Collection)
30Pop
31LdFalse
32StLoc[1](loc0: bool)
B5:
33MoveLoc[1](loc0: bool)
34BrFalse(36)
B6:
35Branch(40)
B7:
36MoveLoc[2](loc1: &Config)
37Pop
38LdConst[17](u64: 100)
39Abort
B8:
40MoveLoc[2](loc1: &Config)
41ImmBorrowField[60](Config.values: Versioned)
42Call versioned::load_value<SettingsV1>(&Versioned): &SettingsV1
43Ret
}
settings_mut(Arg0: &mut Collection): &mut SettingsV1 {
B0:
0MoveLoc[0](Arg0: &mut Collection)
1Call configuration_mut(&mut Collection): &mut Config
2MutBorrowField[60](Config.values: Versioned)
3Call versioned::load_value_mut<SettingsV1>(&mut Versioned): &mut SettingsV1
4Ret
}
config_changed(Arg0: &mut Collection, Arg1: u8) {
L2: loc0: &mut Config
B0:
0MoveLoc[0](Arg0: &mut Collection)
1Call configuration_mut(&mut Collection): &mut Config
2StLoc[2](loc0: &mut Config)
3CopyLoc[2](loc0: &mut Config)
4ImmBorrowField[61](Config.revision: u64)
5ReadRef
6LdU64(1)
7Add
8CopyLoc[2](loc0: &mut Config)
9MutBorrowField[61](Config.revision: u64)
10WriteRef
11CopyLoc[2](loc0: &mut Config)
12FreezeRef
13Call object::id<Config>(&Config): ID
14MoveLoc[2](loc0: &mut Config)
15ImmBorrowField[61](Config.revision: u64)
16ReadRef
17MoveLoc[1](Arg1: u8)
18Pack[39](ConfigUpdated)
19Call event::emit<ConfigUpdated>(ConfigUpdated)
20Ret
}
public config_id(Arg0: &Collection): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[59](Collection.config: ID)
2ReadRef
3Ret
}
public config_revision(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1Call configuration(&Collection): &Config
2ImmBorrowField[61](Config.revision: u64)
3ReadRef
4Ret
}
public config_code_version(Arg0: &Config): u64 {
B0:
0MoveLoc[0](Arg0: &Config)
1ImmBorrowField[41](Config.code_version: u64)
2ReadRef
3Ret
}
public config_schema_version(Arg0: &Config): u64 {
B0:
0MoveLoc[0](Arg0: &Config)
1ImmBorrowField[60](Config.values: Versioned)
2Call versioned::version(&Versioned): u64
3Ret
}
public configured_allocation(Arg0: &Collection, Arg1: u8): u64 * u64 * u64 * u64 * u64 * u64 {
L2: loc0: Allocation
B0:
0MoveLoc[0](Arg0: &Collection)
1MoveLoc[1](Arg1: u8)
2Call route_allocation(&Collection, u8): Allocation
3StLoc[2](loc0: Allocation)
4ImmBorrowLoc[2](loc0: Allocation)
5Call terms::allocation_values(&Allocation): u64 * u64 * u64 * u64 * u64 * u64
6Ret
}
route_allocation(Arg0: &Collection, Arg1: u8): Allocation {
L2: loc0: Allocation
L3: loc1: Allocation
L4: loc2: &SettingsV1
B0:
0MoveLoc[0](Arg0: &Collection)
1Call settings(&Collection): &SettingsV1
2StLoc[4](loc2: &SettingsV1)
3CopyLoc[1](Arg1: u8)
4LdU8(0)
5Eq
6BrFalse(12)
B1:
7MoveLoc[4](loc2: &SettingsV1)
8ImmBorrowField[62](SettingsV1.public_mint: Allocation)
9ReadRef
10StLoc[3](loc1: Allocation)
11Branch(36)
B2:
12CopyLoc[1](Arg1: u8)
13LdU8(1)
14Eq
15BrFalse(21)
B3:
16MoveLoc[4](loc2: &SettingsV1)
17ImmBorrowField[63](SettingsV1.migration: Allocation)
18ReadRef
19StLoc[2](loc0: Allocation)
20Branch(34)
B4:
21MoveLoc[1](Arg1: u8)
22LdU8(2)
23Eq
24BrFalse(26)
B5:
25Branch(30)
B6:
26MoveLoc[4](loc2: &SettingsV1)
27Pop
28LdConst[54](u64: 123)
29Abort
B7:
30MoveLoc[4](loc2: &SettingsV1)
31ImmBorrowField[64](SettingsV1.vip_migration: Allocation)
32ReadRef
33StLoc[2](loc0: Allocation)
B8:
34MoveLoc[2](loc0: Allocation)
35StLoc[3](loc1: Allocation)
B9:
36MoveLoc[3](loc1: Allocation)
37Ret
}
route_payment(Arg0: &Collection, Arg1: Coin<SUI>, Arg2: u8, Arg3: u64, Arg4: u64, Arg5: &mut TxContext): Coin<SUI> * Coin<SUI> {
L6: loc0: &SettingsV1
B0:
0CopyLoc[0](Arg0: &Collection)
1Call settings(&Collection): &SettingsV1
2StLoc[6](loc0: &SettingsV1)
3CopyLoc[3](Arg3: u64)
4CopyLoc[6](loc0: &SettingsV1)
5ImmBorrowField[65](SettingsV1.max_per_tx: u64)
6ReadRef
7Le
8BrFalse(10)
B1:
9Branch(18)
B2:
10MoveLoc[5](Arg5: &mut TxContext)
11Pop
12MoveLoc[6](loc0: &SettingsV1)
13Pop
14MoveLoc[0](Arg0: &Collection)
15Pop
16LdConst[47](u64: 116)
17Abort
B3:
18MoveLoc[1](Arg1: Coin<SUI>)
19MoveLoc[0](Arg0: &Collection)
20CopyLoc[2](Arg2: u8)
21Call route_allocation(&Collection, u8): Allocation
22MoveLoc[2](Arg2: u8)
23MoveLoc[3](Arg3: u64)
24MoveLoc[4](Arg4: u64)
25CopyLoc[6](loc0: &SettingsV1)
26ImmBorrowField[29](SettingsV1.treasury_wallet: address)
27ReadRef
28CopyLoc[6](loc0: &SettingsV1)
29ImmBorrowField[27](SettingsV1.hive_wallet: address)
30ReadRef
31MoveLoc[6](loc0: &SettingsV1)
32ImmBorrowField[66](SettingsV1.subsidy_wallet: address)
33ReadRef
34MoveLoc[5](Arg5: &mut TxContext)
35Call terms::pay_allocated(Coin<SUI>, Allocation, u8, u64, u64, address, address, address, &mut TxContext): Coin<SUI> * Coin<SUI>
36Ret
}
assert_revision(Arg0: &Collection, Arg1: u64) {
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2MoveLoc[0](Arg0: &Collection)
3Call config_revision(&Collection): u64
4MoveLoc[1](Arg1: u64)
5Eq
6BrFalse(8)
B1:
7Branch(10)
B2:
8LdConst[76](u64: 147)
9Abort
B3:
10Ret
}
assert_action(Arg0: &Collection, Arg1: u8) {
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2MoveLoc[0](Arg0: &Collection)
3Call settings(&Collection): &SettingsV1
4ImmBorrowField[67](SettingsV1.emergency_pauses: u64)
5ReadRef
6LdU64(1)
7MoveLoc[1](Arg1: u8)
8Shl
9BitAnd
10LdU64(0)
11Eq
12BrFalse(14)
B1:
13Branch(16)
B2:
14LdConst[77](u64: 148)
15Abort
B3:
16Ret
}
public set_economics(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: vector<u64>, Arg3: vector<u64>, Arg4: vector<u64>) {
L5: loc0: bool
L6: loc1: &mut SettingsV1
L7: loc2: Allocation
L8: loc3: Allocation
L9: loc4: Allocation
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7MoveLoc[2](Arg2: vector<u64>)
8LdU8(0)
9Call terms::checked_allocation(vector<u64>, u8): Allocation
10StLoc[8](loc3: Allocation)
11MoveLoc[3](Arg3: vector<u64>)
12LdU8(1)
13Call terms::checked_allocation(vector<u64>, u8): Allocation
14StLoc[7](loc2: Allocation)
15MoveLoc[4](Arg4: vector<u64>)
16LdU8(2)
17Call terms::checked_allocation(vector<u64>, u8): Allocation
18StLoc[9](loc4: Allocation)
19ImmBorrowLoc[8](loc3: Allocation)
20Call terms::allocation_stake(&Allocation): u64
21ImmBorrowLoc[7](loc2: Allocation)
22Call terms::allocation_stake(&Allocation): u64
23Eq
24BrFalse(32)
B1:
25ImmBorrowLoc[8](loc3: Allocation)
26Call terms::allocation_stake(&Allocation): u64
27ImmBorrowLoc[9](loc4: Allocation)
28Call terms::allocation_stake(&Allocation): u64
29Eq
30StLoc[5](loc0: bool)
31Branch(34)
B2:
32LdFalse
33StLoc[5](loc0: bool)
B3:
34MoveLoc[5](loc0: bool)
35BrFalse(37)
B4:
36Branch(41)
B5:
37MoveLoc[1](Arg1: &mut Collection)
38Pop
39LdConst[54](u64: 123)
40Abort
B6:
41ImmBorrowLoc[8](loc3: Allocation)
42Call terms::allocation_price(&Allocation): u64
43CopyLoc[1](Arg1: &mut Collection)
44MutBorrowField[45](Collection.price: u64)
45WriteRef
46ImmBorrowLoc[8](loc3: Allocation)
47Call terms::allocation_stake(&Allocation): u64
48CopyLoc[1](Arg1: &mut Collection)
49MutBorrowField[15](Collection.stake_amount: u64)
50WriteRef
51ImmBorrowLoc[8](loc3: Allocation)
52Call terms::allocation_lp(&Allocation): u64
53CopyLoc[1](Arg1: &mut Collection)
54MutBorrowField[46](Collection.lp_amount: u64)
55WriteRef
56CopyLoc[1](Arg1: &mut Collection)
57Call settings_mut(&mut Collection): &mut SettingsV1
58StLoc[6](loc1: &mut SettingsV1)
59MoveLoc[8](loc3: Allocation)
60CopyLoc[6](loc1: &mut SettingsV1)
61MutBorrowField[62](SettingsV1.public_mint: Allocation)
62WriteRef
63MoveLoc[7](loc2: Allocation)
64CopyLoc[6](loc1: &mut SettingsV1)
65MutBorrowField[63](SettingsV1.migration: Allocation)
66WriteRef
67MoveLoc[9](loc4: Allocation)
68MoveLoc[6](loc1: &mut SettingsV1)
69MutBorrowField[64](SettingsV1.vip_migration: Allocation)
70WriteRef
71MoveLoc[1](Arg1: &mut Collection)
72LdU8(0)
73Call config_changed(&mut Collection, u8)
74Ret
}
public set_recipients(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: address, Arg3: address, Arg4: address, Arg5: address) {
L6: loc0: bool
L7: loc1: &mut SettingsV1
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7CopyLoc[2](Arg2: address)
8LdConst[97](address: 0x00..)
9Neq
10BrFalse(30)
B1:
11CopyLoc[3](Arg3: address)
12LdConst[97](address: 0x00..)
13Neq
14BrFalse(27)
B2:
15CopyLoc[4](Arg4: address)
16LdConst[97](address: 0x00..)
17Neq
18BrFalse(24)
B3:
19CopyLoc[5](Arg5: address)
20LdConst[97](address: 0x00..)
21Neq
22StLoc[6](loc0: bool)
23Branch(32)
B4:
24LdFalse
25StLoc[6](loc0: bool)
26Branch(32)
B5:
27LdFalse
28StLoc[6](loc0: bool)
29Branch(32)
B6:
30LdFalse
31StLoc[6](loc0: bool)
B7:
32MoveLoc[6](loc0: bool)
33BrFalse(35)
B8:
34Branch(39)
B9:
35MoveLoc[1](Arg1: &mut Collection)
36Pop
37LdConst[54](u64: 123)
38Abort
B10:
39CopyLoc[3](Arg3: address)
40CopyLoc[1](Arg1: &mut Collection)
41MutBorrowField[26](Collection.fee_wallet: address)
42WriteRef
43CopyLoc[2](Arg2: address)
44CopyLoc[1](Arg1: &mut Collection)
45MutBorrowField[28](Collection.royalty_wallet: address)
46WriteRef
47CopyLoc[1](Arg1: &mut Collection)
48Call settings_mut(&mut Collection): &mut SettingsV1
49StLoc[7](loc1: &mut SettingsV1)
50MoveLoc[2](Arg2: address)
51CopyLoc[7](loc1: &mut SettingsV1)
52MutBorrowField[29](SettingsV1.treasury_wallet: address)
53WriteRef
54MoveLoc[3](Arg3: address)
55CopyLoc[7](loc1: &mut SettingsV1)
56MutBorrowField[27](SettingsV1.hive_wallet: address)
57WriteRef
58MoveLoc[4](Arg4: address)
59CopyLoc[7](loc1: &mut SettingsV1)
60MutBorrowField[66](SettingsV1.subsidy_wallet: address)
61WriteRef
62MoveLoc[5](Arg5: address)
63MoveLoc[7](loc1: &mut SettingsV1)
64MutBorrowField[39](SettingsV1.willie_wallet: address)
65WriteRef
66MoveLoc[1](Arg1: &mut Collection)
67LdU8(1)
68Call config_changed(&mut Collection, u8)
69Ret
}
public set_royalty_split(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u16) {
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_collection(&Collection)
7CopyLoc[2](Arg2: u16)
8LdU16(0)
9Gt
10BrFalse(16)
B1:
11CopyLoc[2](Arg2: u16)
12LdU16(10000)
13Lt
14StLoc[3](loc0: bool)
15Branch(18)
B2:
16LdFalse
17StLoc[3](loc0: bool)
B3:
18MoveLoc[3](loc0: bool)
19BrFalse(21)
B4:
20Branch(25)
B5:
21MoveLoc[1](Arg1: &mut Collection)
22Pop
23LdConst[70](u64: 141)
24Abort
B6:
25MoveLoc[2](Arg2: u16)
26CopyLoc[1](Arg1: &mut Collection)
27Call settings_mut(&mut Collection): &mut SettingsV1
28MutBorrowField[38](SettingsV1.royalty_willie_bps: u16)
29WriteRef
30MoveLoc[1](Arg1: &mut Collection)
31LdU8(4)
32Call config_changed(&mut Collection, u8)
33Ret
}
public set_access_limits(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: u64) {
L4: loc0: bool
L5: loc1: &mut SettingsV1
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7CopyLoc[2](Arg2: u64)
8LdU64(0)
9Gt
10BrFalse(23)
B1:
11CopyLoc[3](Arg3: u64)
12LdU64(0)
13Gt
14BrFalse(20)
B2:
15CopyLoc[3](Arg3: u64)
16LdConst[12](u64: 25)
17Le
18StLoc[4](loc0: bool)
19Branch(25)
B3:
20LdFalse
21StLoc[4](loc0: bool)
22Branch(25)
B4:
23LdFalse
24StLoc[4](loc0: bool)
B5:
25MoveLoc[4](loc0: bool)
26BrFalse(28)
B6:
27Branch(32)
B7:
28MoveLoc[1](Arg1: &mut Collection)
29Pop
30LdConst[54](u64: 123)
31Abort
B8:
32CopyLoc[1](Arg1: &mut Collection)
33FreezeRef
34Call legacy_state(&Collection): &State
35CopyLoc[2](Arg2: u64)
36Call legacy::minimum_king_for(&State, u64): u64
37CopyLoc[1](Arg1: &mut Collection)
38MutBorrowField[32](Collection.min_holder_balance: u64)
39WriteRef
40CopyLoc[1](Arg1: &mut Collection)
41Call settings_mut(&mut Collection): &mut SettingsV1
42StLoc[5](loc1: &mut SettingsV1)
43MoveLoc[2](Arg2: u64)
44CopyLoc[5](loc1: &mut SettingsV1)
45MutBorrowField[31](SettingsV1.min_king_tokens: u64)
46WriteRef
47MoveLoc[3](Arg3: u64)
48MoveLoc[5](loc1: &mut SettingsV1)
49MutBorrowField[65](SettingsV1.max_per_tx: u64)
50WriteRef
51MoveLoc[1](Arg1: &mut Collection)
52LdU8(5)
53Call config_changed(&mut Collection, u8)
54Ret
}
public set_launch_terms(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: u64, Arg3: u64, Arg4: u64) {
L5: loc0: bool
L6: loc1: bool
L7: loc2: &mut SettingsV1
L8: loc3: 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_collection(&Collection)
7CopyLoc[1](Arg1: &mut Collection)
8ImmBorrowField[6](Collection.mint_open: bool)
9ReadRef
10Not
11BrFalse(19)
B1:
12CopyLoc[1](Arg1: &mut Collection)
13ImmBorrowField[5](Collection.minted: u64)
14ReadRef
15LdU64(0)
16Eq
17StLoc[5](loc0: bool)
18Branch(21)
B2:
19LdFalse
20StLoc[5](loc0: bool)
B3:
21MoveLoc[5](loc0: bool)
22BrFalse(24)
B4:
23Branch(28)
B5:
24MoveLoc[1](Arg1: &mut Collection)
25Pop
26LdConst[61](u64: 131)
27Abort
B6:
28CopyLoc[3](Arg3: u64)
29LdU64(0)
30Gt
31BrFalse(53)
B7:
32CopyLoc[2](Arg2: u64)
33CopyLoc[3](Arg3: u64)
34Ge
35BrFalse(50)
B8:
36CopyLoc[4](Arg4: u64)
37LdU64(0)
38Gt
39BrFalse(47)
B9:
40CopyLoc[2](Arg2: u64)
41LdConst[26](u64: 1844..)
42CopyLoc[4](Arg4: u64)
43Sub
44Le
45StLoc[6](loc1: bool)
46Branch(55)
B10:
47LdFalse
48StLoc[6](loc1: bool)
49Branch(55)
B11:
50LdFalse
51StLoc[6](loc1: bool)
52Branch(55)
B12:
53LdFalse
54StLoc[6](loc1: bool)
B13:
55MoveLoc[6](loc1: bool)
56BrFalse(58)
B14:
57Branch(62)
B15:
58MoveLoc[1](Arg1: &mut Collection)
59Pop
60LdConst[67](u64: 137)
61Abort
B16:
62CopyLoc[1](Arg1: &mut Collection)
63FreezeRef
64Call legacy_state(&Collection): &State
65CopyLoc[1](Arg1: &mut Collection)
66FreezeRef
67Call settings(&Collection): &SettingsV1
68ImmBorrowField[31](SettingsV1.min_king_tokens: u64)
69ReadRef
70Call legacy::minimum_king_for(&State, u64): u64
71StLoc[8](loc3: u64)
72CopyLoc[1](Arg1: &mut Collection)
73Call settings_mut(&mut Collection): &mut SettingsV1
74StLoc[7](loc2: &mut SettingsV1)
75CopyLoc[3](Arg3: u64)
76CopyLoc[7](loc2: &mut SettingsV1)
77MutBorrowField[30](SettingsV1.early_access_ms: u64)
78WriteRef
79MoveLoc[4](Arg4: u64)
80MoveLoc[7](loc2: &mut SettingsV1)
81MutBorrowField[19](SettingsV1.migration_duration_ms: u64)
82WriteRef
83MoveLoc[1](Arg1: &mut Collection)
84CopyLoc[2](Arg2: u64)
85MoveLoc[3](Arg3: u64)
86Sub
87MoveLoc[2](Arg2: u64)
88MoveLoc[8](loc3: u64)
89Call set_schedule_internal(&mut Collection, u64, u64, u64)
90Ret
}
public set_emergency_pauses(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_collection(&Collection)
7CopyLoc[2](Arg2: u64)
8LdU64(127)
9Le
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[1](Arg1: &mut Collection)
13Pop
14LdConst[54](u64: 123)
15Abort
B3:
16MoveLoc[2](Arg2: u64)
17CopyLoc[1](Arg1: &mut Collection)
18Call settings_mut(&mut Collection): &mut SettingsV1
19MutBorrowField[67](SettingsV1.emergency_pauses: u64)
20WriteRef
21MoveLoc[1](Arg1: &mut Collection)
22LdU8(6)
23Call config_changed(&mut Collection, u8)
24Ret
}
public register_upgrade_cap(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &UpgradeCap) {
L3: loc0: bool
L4: loc1: ID
L5: loc2: &mut Config
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call check_collection(&Collection)
7MoveLoc[1](Arg1: &mut Collection)
8Call configuration_mut(&mut Collection): &mut Config
9StLoc[5](loc2: &mut Config)
10CopyLoc[5](loc2: &mut Config)
11ImmBorrowField[68](Config.upgrade_cap: Option<ID>)
12Call option::is_some<ID>(&Option<ID>): bool
13BrFalse(25)
B1:
14MoveLoc[5](loc2: &mut Config)
15ImmBorrowField[68](Config.upgrade_cap: Option<ID>)
16Call option::borrow<ID>(&Option<ID>): &ID
17ReadRef
18MoveLoc[2](Arg2: &UpgradeCap)
19Call object::id<UpgradeCap>(&UpgradeCap): ID
20Eq
21BrFalse(23)
B2:
22Branch(56)
B3:
23LdConst[78](u64: 149)
24Abort
B4:
25CopyLoc[2](Arg2: &UpgradeCap)
26Call package::version(&UpgradeCap): u64
27LdU64(1)
28Eq
29BrFalse(39)
B5:
30CopyLoc[2](Arg2: &UpgradeCap)
31Call package::upgrade_package(&UpgradeCap): ID
32StLoc[4](loc1: ID)
33ImmBorrowLoc[4](loc1: ID)
34Call object::id_to_address(&ID): address
35Call type_name::original_id<KingFizh>(): address
36Eq
37StLoc[3](loc0: bool)
38Branch(41)
B6:
39LdFalse
40StLoc[3](loc0: bool)
B7:
41MoveLoc[3](loc0: bool)
42BrFalse(44)
B8:
43Branch(50)
B9:
44MoveLoc[5](loc2: &mut Config)
45Pop
46MoveLoc[2](Arg2: &UpgradeCap)
47Pop
48LdConst[78](u64: 149)
49Abort
B10:
50MoveLoc[2](Arg2: &UpgradeCap)
51Call object::id<UpgradeCap>(&UpgradeCap): ID
52Call option::some<ID>(ID): Option<ID>
53MoveLoc[5](loc2: &mut Config)
54MutBorrowField[68](Config.upgrade_cap: Option<ID>)
55WriteRef
B11:
56Ret
}
public advance_protocol_version<Ty0>(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut Vault<Ty0>, Arg3: &UpgradeCap) {
L4: loc0: bool
L5: loc1: bool
L6: loc2: 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_collection(&Collection)
7CopyLoc[2](Arg2: &mut Vault<Ty0>)
8FreezeRef
9Call check_vault<Ty0>(&Vault<Ty0>)
10CopyLoc[2](Arg2: &mut Vault<Ty0>)
11ImmBorrowFieldGeneric[0](Vault.collection: ID)
12ReadRef
13CopyLoc[1](Arg1: &mut Collection)
14FreezeRef
15Call object::id<Collection>(&Collection): ID
16Eq
17BrFalse(27)
B1:
18CopyLoc[2](Arg2: &mut Vault<Ty0>)
19FreezeRef
20Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
21CopyLoc[1](Arg1: &mut Collection)
22ImmBorrowField[12](Collection.vault: ID)
23ReadRef
24Eq
25StLoc[4](loc0: bool)
26Branch(29)
B2:
27LdFalse
28StLoc[4](loc0: bool)
B3:
29MoveLoc[4](loc0: bool)
30BrFalse(32)
B4:
31Branch(40)
B5:
32MoveLoc[2](Arg2: &mut Vault<Ty0>)
33Pop
34MoveLoc[3](Arg3: &UpgradeCap)
35Pop
36MoveLoc[1](Arg1: &mut Collection)
37Pop
38LdConst[41](u64: 110)
39Abort
B6:
40CopyLoc[1](Arg1: &mut Collection)
41FreezeRef
42Call configuration(&Collection): &Config
43ImmBorrowField[68](Config.upgrade_cap: Option<ID>)
44Call option::is_some<ID>(&Option<ID>): bool
45BrFalse(57)
B7:
46CopyLoc[1](Arg1: &mut Collection)
47FreezeRef
48Call configuration(&Collection): &Config
49ImmBorrowField[68](Config.upgrade_cap: Option<ID>)
50Call option::borrow<ID>(&Option<ID>): &ID
51ReadRef
52CopyLoc[3](Arg3: &UpgradeCap)
53Call object::id<UpgradeCap>(&UpgradeCap): ID
54Eq
55StLoc[5](loc1: bool)
56Branch(59)
B8:
57LdFalse
58StLoc[5](loc1: bool)
B9:
59MoveLoc[5](loc1: bool)
60BrFalse(62)
B10:
61Branch(70)
B11:
62MoveLoc[2](Arg2: &mut Vault<Ty0>)
63Pop
64MoveLoc[3](Arg3: &UpgradeCap)
65Pop
66MoveLoc[1](Arg1: &mut Collection)
67Pop
68LdConst[78](u64: 149)
69Abort
B12:
70CopyLoc[3](Arg3: &UpgradeCap)
71Call package::version(&UpgradeCap): u64
72StLoc[6](loc2: u64)
73CopyLoc[6](loc2: u64)
74LdConst[13](u64: 1)
75LdU64(1)
76Add
77Eq
78BrFalse(80)
B13:
79Branch(88)
B14:
80MoveLoc[2](Arg2: &mut Vault<Ty0>)
81Pop
82MoveLoc[3](Arg3: &UpgradeCap)
83Pop
84MoveLoc[1](Arg1: &mut Collection)
85Pop
86LdConst[52](u64: 121)
87Abort
B15:
88MoveLoc[1](Arg1: &mut Collection)
89MoveLoc[2](Arg2: &mut Vault<Ty0>)
90MoveLoc[6](loc2: u64)
91MoveLoc[3](Arg3: &UpgradeCap)
92Call package::upgrade_package(&UpgradeCap): ID
93Call advance_protocol_internal<Ty0>(&mut Collection, &mut Vault<Ty0>, u64, ID)
94Ret
}
public activate_protocol_upgrade<Ty0>(Arg0: &AdminCap, Arg1: &mut Collection, Arg2: &mut Vault<Ty0>, Arg3: &UpgradeCap) {
L4: loc0: bool
L5: loc1: bool
L6: loc2: bool
B0:
0MoveLoc[0](Arg0: &AdminCap)
1CopyLoc[1](Arg1: &mut Collection)
2FreezeRef
3Call assert_admin(&AdminCap, &Collection)
4CopyLoc[1](Arg1: &mut Collection)
5FreezeRef
6Call configuration(&Collection): &Config
7ImmBorrowField[68](Config.upgrade_cap: Option<ID>)
8Call option::is_some<ID>(&Option<ID>): bool
9BrFalse(21)
B1:
10CopyLoc[1](Arg1: &mut Collection)
11FreezeRef
12Call configuration(&Collection): &Config
13ImmBorrowField[68](Config.upgrade_cap: Option<ID>)
14Call option::borrow<ID>(&Option<ID>): &ID
15ReadRef
16CopyLoc[3](Arg3: &UpgradeCap)
17Call object::id<UpgradeCap>(&UpgradeCap): ID
18Eq
19StLoc[4](loc0: bool)
20Branch(23)
B2:
21LdFalse
22StLoc[4](loc0: bool)
B3:
23MoveLoc[4](loc0: bool)
24BrFalse(26)
B4:
25Branch(34)
B5:
26MoveLoc[2](Arg2: &mut Vault<Ty0>)
27Pop
28MoveLoc[3](Arg3: &UpgradeCap)
29Pop
30MoveLoc[1](Arg1: &mut Collection)
31Pop
32LdConst[78](u64: 149)
33Abort
B6:
34CopyLoc[3](Arg3: &UpgradeCap)
35Call package::version(&UpgradeCap): u64
36LdConst[13](u64: 1)
37Eq
38BrFalse(70)
B7:
39CopyLoc[1](Arg1: &mut Collection)
40ImmBorrowField[42](Collection.version: u64)
41ReadRef
42LdConst[13](u64: 1)
43Lt
44BrFalse(67)
B8:
45CopyLoc[2](Arg2: &mut Vault<Ty0>)
46ImmBorrowFieldGeneric[3](Vault.version: u64)
47ReadRef
48CopyLoc[1](Arg1: &mut Collection)
49ImmBorrowField[42](Collection.version: u64)
50ReadRef
51Eq
52BrFalse(64)
B9:
53CopyLoc[1](Arg1: &mut Collection)
54FreezeRef
55Call configuration(&Collection): &Config
56ImmBorrowField[41](Config.code_version: u64)
57ReadRef
58CopyLoc[1](Arg1: &mut Collection)
59ImmBorrowField[42](Collection.version: u64)
60ReadRef
61Eq
62StLoc[5](loc1: bool)
63Branch(72)
B10:
64LdFalse
65StLoc[5](loc1: bool)
66Branch(72)
B11:
67LdFalse
68StLoc[5](loc1: bool)
69Branch(72)
B12:
70LdFalse
71StLoc[5](loc1: bool)
B13:
72MoveLoc[5](loc1: bool)
73BrFalse(75)
B14:
74Branch(83)
B15:
75MoveLoc[2](Arg2: &mut Vault<Ty0>)
76Pop
77MoveLoc[3](Arg3: &UpgradeCap)
78Pop
79MoveLoc[1](Arg1: &mut Collection)
80Pop
81LdConst[52](u64: 121)
82Abort
B16:
83CopyLoc[2](Arg2: &mut Vault<Ty0>)
84ImmBorrowFieldGeneric[0](Vault.collection: ID)
85ReadRef
86CopyLoc[1](Arg1: &mut Collection)
87FreezeRef
88Call object::id<Collection>(&Collection): ID
89Eq
90BrFalse(100)
B17:
91CopyLoc[2](Arg2: &mut Vault<Ty0>)
92FreezeRef
93Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
94CopyLoc[1](Arg1: &mut Collection)
95ImmBorrowField[12](Collection.vault: ID)
96ReadRef
97Eq
98StLoc[6](loc2: bool)
99Branch(102)
B18:
100LdFalse
101StLoc[6](loc2: bool)
B19:
102MoveLoc[6](loc2: bool)
103BrFalse(105)
B20:
104Branch(113)
B21:
105MoveLoc[2](Arg2: &mut Vault<Ty0>)
106Pop
107MoveLoc[3](Arg3: &UpgradeCap)
108Pop
109MoveLoc[1](Arg1: &mut Collection)
110Pop
111LdConst[41](u64: 110)
112Abort
B22:
113MoveLoc[1](Arg1: &mut Collection)
114MoveLoc[2](Arg2: &mut Vault<Ty0>)
115LdConst[13](u64: 1)
116MoveLoc[3](Arg3: &UpgradeCap)
117Call package::upgrade_package(&UpgradeCap): ID
118Call advance_protocol_internal<Ty0>(&mut Collection, &mut Vault<Ty0>, u64, ID)
119Ret
}
advance_protocol_internal<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: u64, Arg3: ID) {
L4: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut Collection)
1ImmBorrowField[42](Collection.version: u64)
2ReadRef
3StLoc[4](loc0: u64)
4CopyLoc[2](Arg2: u64)
5CopyLoc[0](Arg0: &mut Collection)
6MutBorrowField[42](Collection.version: u64)
7WriteRef
8CopyLoc[2](Arg2: u64)
9CopyLoc[1](Arg1: &mut Vault<Ty0>)
10MutBorrowFieldGeneric[3](Vault.version: u64)
11WriteRef
12CopyLoc[2](Arg2: u64)
13CopyLoc[0](Arg0: &mut Collection)
14Call configuration_mut(&mut Collection): &mut Config
15MutBorrowField[41](Config.code_version: u64)
16WriteRef
17CopyLoc[0](Arg0: &mut Collection)
18FreezeRef
19Call object::id<Collection>(&Collection): ID
20MoveLoc[1](Arg1: &mut Vault<Ty0>)
21FreezeRef
22Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
23MoveLoc[0](Arg0: &mut Collection)
24ImmBorrowField[59](Collection.config: ID)
25ReadRef
26MoveLoc[4](loc0: u64)
27MoveLoc[2](Arg2: u64)
28MoveLoc[3](Arg3: ID)
29Pack[40](ProtocolUpgraded)
30Call event::emit<ProtocolUpgraded>(ProtocolUpgraded)
31Ret
}
public harvest(Arg0: &Collection, Arg1: &mut SuiSystemState, Arg2: &mut Kiosk, Arg3: &KioskOwnerCap, Arg4: ID, Arg5: &mut TxContext) {
L6: loc0: StakedSui
L7: loc1: Balance<SUI>
L8: loc2: address
L9: loc3: &mut KingFizh
L10: loc4: u64
L11: loc5: Coin<SUI>
L12: loc6: StakedSui
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2CopyLoc[0](Arg0: &Collection)
3LdU8(2)
4Call assert_action(&Collection, u8)
5MoveLoc[2](Arg2: &mut Kiosk)
6MoveLoc[3](Arg3: &KioskOwnerCap)
7CopyLoc[4](Arg4: ID)
8Call kiosk::borrow_mut<KingFizh>(&mut Kiosk, &KioskOwnerCap, ID): &mut KingFizh
9StLoc[9](loc3: &mut KingFizh)
10CopyLoc[9](loc3: &mut KingFizh)
11FreezeRef
12Call is_active(&KingFizh): bool
13BrFalse(15)
B1:
14Branch(25)
B2:
15MoveLoc[1](Arg1: &mut SuiSystemState)
16Pop
17MoveLoc[9](loc3: &mut KingFizh)
18Pop
19MoveLoc[5](Arg5: &mut TxContext)
20Pop
21MoveLoc[0](Arg0: &Collection)
22Pop
23LdConst[42](u64: 111)
24Abort
B3:
25CopyLoc[9](loc3: &mut KingFizh)
26ImmBorrowField[69](KingFizh.vault: ID)
27ReadRef
28CopyLoc[0](Arg0: &Collection)
29ImmBorrowField[12](Collection.vault: ID)
30ReadRef
31Eq
32BrFalse(34)
B4:
33Branch(44)
B5:
34MoveLoc[1](Arg1: &mut SuiSystemState)
35Pop
36MoveLoc[9](loc3: &mut KingFizh)
37Pop
38MoveLoc[5](Arg5: &mut TxContext)
39Pop
40MoveLoc[0](Arg0: &Collection)
41Pop
42LdConst[41](u64: 110)
43Abort
B6:
44CopyLoc[9](loc3: &mut KingFizh)
45MutBorrowField[70](KingFizh.stake: Option<StakedSui>)
46Call option::extract<StakedSui>(&mut Option<StakedSui>): StakedSui
47StLoc[12](loc6: StakedSui)
48CopyLoc[1](Arg1: &mut SuiSystemState)
49MoveLoc[12](loc6: StakedSui)
50CopyLoc[5](Arg5: &mut TxContext)
51Call sui_system::request_withdraw_stake_non_entry(&mut SuiSystemState, StakedSui, &mut TxContext): Balance<SUI>
52StLoc[7](loc1: Balance<SUI>)
53ImmBorrowLoc[7](loc1: Balance<SUI>)
54Call balance::value<SUI>(&Balance<SUI>): u64
55CopyLoc[9](loc3: &mut KingFizh)
56ImmBorrowField[71](KingFizh.principal: u64)
57ReadRef
58Gt
59BrFalse(61)
B7:
60Branch(71)
B8:
61MoveLoc[1](Arg1: &mut SuiSystemState)
62Pop
63MoveLoc[9](loc3: &mut KingFizh)
64Pop
65MoveLoc[5](Arg5: &mut TxContext)
66Pop
67MoveLoc[0](Arg0: &Collection)
68Pop
69LdConst[43](u64: 112)
70Abort
B9:
71MutBorrowLoc[7](loc1: Balance<SUI>)
72CopyLoc[9](loc3: &mut KingFizh)
73ImmBorrowField[71](KingFizh.principal: u64)
74ReadRef
75CopyLoc[5](Arg5: &mut TxContext)
76Call coin::take<SUI>(&mut Balance<SUI>, u64, &mut TxContext): Coin<SUI>
77StLoc[11](loc5: Coin<SUI>)
78MoveLoc[1](Arg1: &mut SuiSystemState)
79MoveLoc[11](loc5: Coin<SUI>)
80CopyLoc[0](Arg0: &Collection)
81ImmBorrowField[16](Collection.validator: address)
82ReadRef
83CopyLoc[5](Arg5: &mut TxContext)
84Call sui_system::request_add_stake_non_entry(&mut SuiSystemState, Coin<SUI>, address, &mut TxContext): StakedSui
85StLoc[6](loc0: StakedSui)
86ImmBorrowLoc[6](loc0: StakedSui)
87Call staking_pool::staked_sui_amount(&StakedSui): u64
88CopyLoc[9](loc3: &mut KingFizh)
89ImmBorrowField[71](KingFizh.principal: u64)
90ReadRef
91Eq
92BrFalse(94)
B10:
93Branch(102)
B11:
94MoveLoc[9](loc3: &mut KingFizh)
95Pop
96MoveLoc[5](Arg5: &mut TxContext)
97Pop
98MoveLoc[0](Arg0: &Collection)
99Pop
100LdConst[44](u64: 113)
101Abort
B12:
102CopyLoc[9](loc3: &mut KingFizh)
103MutBorrowField[70](KingFizh.stake: Option<StakedSui>)
104MoveLoc[6](loc0: StakedSui)
105Call option::fill<StakedSui>(&mut Option<StakedSui>, StakedSui)
106CopyLoc[0](Arg0: &Collection)
107ImmBorrowField[16](Collection.validator: address)
108ReadRef
109CopyLoc[9](loc3: &mut KingFizh)
110MutBorrowField[72](KingFizh.validator: address)
111WriteRef
112ImmBorrowLoc[7](loc1: Balance<SUI>)
113Call balance::value<SUI>(&Balance<SUI>): u64
114StLoc[10](loc4: u64)
115CopyLoc[5](Arg5: &mut TxContext)
116FreezeRef
117Call tx_context::sender(&TxContext): address
118StLoc[8](loc2: address)
119MoveLoc[4](Arg4: ID)
120CopyLoc[9](loc3: &mut KingFizh)
121ImmBorrowField[73](KingFizh.number: u64)
122ReadRef
123MoveLoc[9](loc3: &mut KingFizh)
124ImmBorrowField[74](KingFizh.index: u64)
125ReadRef
126MoveLoc[10](loc4: u64)
127MoveLoc[0](Arg0: &Collection)
128ImmBorrowField[16](Collection.validator: address)
129ReadRef
130CopyLoc[8](loc2: address)
131Pack[20](Harvested)
132Call event::emit<Harvested>(Harvested)
133MoveLoc[7](loc1: Balance<SUI>)
134MoveLoc[5](Arg5: &mut TxContext)
135Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
136MoveLoc[8](loc2: address)
137Call send_sui(Coin<SUI>, address)
138Ret
}
public collect<Ty0>(Arg0: &Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut Kiosk, Arg3: &KioskOwnerCap, Arg4: ID, Arg5: &mut TxContext) {
L6: loc0: bool
L7: loc1: Coin<Ty0>
L8: loc2: Coin<SUI>
L9: loc3: address
L10: loc4: &mut KingFizh
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2CopyLoc[0](Arg0: &Collection)
3LdU8(3)
4Call assert_action(&Collection, u8)
5CopyLoc[1](Arg1: &mut Vault<Ty0>)
6ImmBorrowFieldGeneric[0](Vault.collection: ID)
7ReadRef
8CopyLoc[0](Arg0: &Collection)
9Call object::id<Collection>(&Collection): ID
10Eq
11BrFalse(21)
B1:
12CopyLoc[1](Arg1: &mut Vault<Ty0>)
13FreezeRef
14Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
15MoveLoc[0](Arg0: &Collection)
16ImmBorrowField[12](Collection.vault: ID)
17ReadRef
18Eq
19StLoc[6](loc0: bool)
20Branch(25)
B2:
21MoveLoc[0](Arg0: &Collection)
22Pop
23LdFalse
24StLoc[6](loc0: bool)
B3:
25MoveLoc[6](loc0: bool)
26BrFalse(28)
B4:
27Branch(38)
B5:
28MoveLoc[1](Arg1: &mut Vault<Ty0>)
29Pop
30MoveLoc[3](Arg3: &KioskOwnerCap)
31Pop
32MoveLoc[2](Arg2: &mut Kiosk)
33Pop
34MoveLoc[5](Arg5: &mut TxContext)
35Pop
36LdConst[41](u64: 110)
37Abort
B6:
38CopyLoc[1](Arg1: &mut Vault<Ty0>)
39FreezeRef
40Call check_vault<Ty0>(&Vault<Ty0>)
41MoveLoc[2](Arg2: &mut Kiosk)
42MoveLoc[3](Arg3: &KioskOwnerCap)
43CopyLoc[4](Arg4: ID)
44Call kiosk::borrow_mut<KingFizh>(&mut Kiosk, &KioskOwnerCap, ID): &mut KingFizh
45StLoc[10](loc4: &mut KingFizh)
46CopyLoc[10](loc4: &mut KingFizh)
47ImmBorrowField[69](KingFizh.vault: ID)
48ReadRef
49CopyLoc[1](Arg1: &mut Vault<Ty0>)
50FreezeRef
51Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
52Eq
53BrFalse(55)
B7:
54Branch(63)
B8:
55MoveLoc[1](Arg1: &mut Vault<Ty0>)
56Pop
57MoveLoc[10](loc4: &mut KingFizh)
58Pop
59MoveLoc[5](Arg5: &mut TxContext)
60Pop
61LdConst[41](u64: 110)
62Abort
B9:
63CopyLoc[10](loc4: &mut KingFizh)
64FreezeRef
65Call is_active(&KingFizh): bool
66BrFalse(68)
B10:
67Branch(76)
B11:
68MoveLoc[1](Arg1: &mut Vault<Ty0>)
69Pop
70MoveLoc[10](loc4: &mut KingFizh)
71Pop
72MoveLoc[5](Arg5: &mut TxContext)
73Pop
74LdConst[42](u64: 111)
75Abort
B12:
76MoveLoc[1](Arg1: &mut Vault<Ty0>)
77CopyLoc[10](loc4: &mut KingFizh)
78CopyLoc[5](Arg5: &mut TxContext)
79Call pay_pot<Ty0>(&mut Vault<Ty0>, &mut KingFizh, &mut TxContext): Coin<Ty0> * Coin<SUI>
80StLoc[8](loc2: Coin<SUI>)
81StLoc[7](loc1: Coin<Ty0>)
82MoveLoc[4](Arg4: ID)
83CopyLoc[10](loc4: &mut KingFizh)
84ImmBorrowField[73](KingFizh.number: u64)
85ReadRef
86MoveLoc[10](loc4: &mut KingFizh)
87ImmBorrowField[74](KingFizh.index: u64)
88ReadRef
89ImmBorrowLoc[7](loc1: Coin<Ty0>)
90Call coin::value<Ty0>(&Coin<Ty0>): u64
91ImmBorrowLoc[8](loc2: Coin<SUI>)
92Call coin::value<SUI>(&Coin<SUI>): u64
93CopyLoc[5](Arg5: &mut TxContext)
94FreezeRef
95Call tx_context::sender(&TxContext): address
96Pack[21](Collected)
97Call event::emit<Collected>(Collected)
98MoveLoc[5](Arg5: &mut TxContext)
99FreezeRef
100Call tx_context::sender(&TxContext): address
101StLoc[9](loc3: address)
102MoveLoc[7](loc1: Coin<Ty0>)
103CopyLoc[9](loc3: address)
104Call send<Ty0>(Coin<Ty0>, address)
105MoveLoc[8](loc2: Coin<SUI>)
106MoveLoc[9](loc3: address)
107Call send_sui(Coin<SUI>, address)
108Ret
}
public burn<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut SuiSystemState, Arg3: &mut TransferPolicy<KingFizh>, Arg4: &mut Kiosk, Arg5: &mut Kiosk, Arg6: &KioskOwnerCap, Arg7: ID, Arg8: &mut TxContext) {
L9: loc0: KingFizh
L10: loc1: TransferRequest<KingFizh>
L11: loc2: Balance<SUI>
B0:
0CopyLoc[0](Arg0: &mut Collection)
1FreezeRef
2CopyLoc[1](Arg1: &mut Vault<Ty0>)
3FreezeRef
4CopyLoc[3](Arg3: &mut TransferPolicy<KingFizh>)
5FreezeRef
6CopyLoc[4](Arg4: &mut Kiosk)
7FreezeRef
8Call check_burn<Ty0>(&Collection, &Vault<Ty0>, &TransferPolicy<KingFizh>, &Kiosk)
9CopyLoc[0](Arg0: &mut Collection)
10FreezeRef
11LdU8(4)
12Call assert_action(&Collection, u8)
13MoveLoc[5](Arg5: &mut Kiosk)
14MoveLoc[6](Arg6: &KioskOwnerCap)
15MoveLoc[7](Arg7: ID)
16CopyLoc[8](Arg8: &mut TxContext)
17Call take_out(&mut Kiosk, &KioskOwnerCap, ID, &mut TxContext): KingFizh * TransferRequest<KingFizh>
18StLoc[10](loc1: TransferRequest<KingFizh>)
19StLoc[9](loc0: KingFizh)
20ImmBorrowLoc[9](loc0: KingFizh)
21ImmBorrowField[69](KingFizh.vault: ID)
22ReadRef
23CopyLoc[1](Arg1: &mut Vault<Ty0>)
24FreezeRef
25Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
26Eq
27BrFalse(29)
B1:
28Branch(43)
B2:
29MoveLoc[1](Arg1: &mut Vault<Ty0>)
30Pop
31MoveLoc[2](Arg2: &mut SuiSystemState)
32Pop
33MoveLoc[3](Arg3: &mut TransferPolicy<KingFizh>)
34Pop
35MoveLoc[4](Arg4: &mut Kiosk)
36Pop
37MoveLoc[8](Arg8: &mut TxContext)
38Pop
39MoveLoc[0](Arg0: &mut Collection)
40Pop
41LdConst[41](u64: 110)
42Abort
B3:
43ImmBorrowLoc[9](loc0: KingFizh)
44Call is_active(&KingFizh): bool
45BrFalse(47)
B4:
46Branch(61)
B5:
47MoveLoc[1](Arg1: &mut Vault<Ty0>)
48Pop
49MoveLoc[2](Arg2: &mut SuiSystemState)
50Pop
51MoveLoc[3](Arg3: &mut TransferPolicy<KingFizh>)
52Pop
53MoveLoc[4](Arg4: &mut Kiosk)
54Pop
55MoveLoc[8](Arg8: &mut TxContext)
56Pop
57MoveLoc[0](Arg0: &mut Collection)
58Pop
59LdConst[42](u64: 111)
60Abort
B6:
61MoveLoc[2](Arg2: &mut SuiSystemState)
62MutBorrowLoc[9](loc0: KingFizh)
63MutBorrowField[70](KingFizh.stake: Option<StakedSui>)
64Call option::extract<StakedSui>(&mut Option<StakedSui>): StakedSui
65CopyLoc[8](Arg8: &mut TxContext)
66Call sui_system::request_withdraw_stake_non_entry(&mut SuiSystemState, StakedSui, &mut TxContext): Balance<SUI>
67StLoc[11](loc2: Balance<SUI>)
68MoveLoc[0](Arg0: &mut Collection)
69MoveLoc[1](Arg1: &mut Vault<Ty0>)
70MoveLoc[3](Arg3: &mut TransferPolicy<KingFizh>)
71MoveLoc[4](Arg4: &mut Kiosk)
72MoveLoc[9](loc0: KingFizh)
73MoveLoc[10](loc1: TransferRequest<KingFizh>)
74MoveLoc[11](loc2: Balance<SUI>)
75MoveLoc[8](Arg8: &mut TxContext)
76Call settle_burn<Ty0>(&mut Collection, &mut Vault<Ty0>, &mut TransferPolicy<KingFizh>, &mut Kiosk, KingFizh, TransferRequest<KingFizh>, Balance<SUI>, &mut TxContext)
77Ret
}
public sweep<Ty0>(Arg0: &Collection, Arg1: &mut Vault<Ty0>, Arg2: &BurnManager, Arg3: &GlobalConfig, Arg4: &mut Pool<Ty0, SUI>, Arg5: vector<u64>, Arg6: &mut TxContext) {
L7: loc0: bool
L8: loc1: Coin<Ty0>
L9: loc2: u64
L10: loc3: u64
L11: loc4: Coin<SUI>
L12: loc5: address
L13: loc6: Coin<Ty0>
L14: loc7: Coin<SUI>
L15: loc8: Balance<Ty0>
L16: loc9: Balance<SUI>
L17: loc10: u64
L18: loc11: u64
L19: loc12: u64
L20: loc13: &mut CetusLPBurnProof
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2CopyLoc[1](Arg1: &mut Vault<Ty0>)
3FreezeRef
4Call check_vault<Ty0>(&Vault<Ty0>)
5CopyLoc[1](Arg1: &mut Vault<Ty0>)
6ImmBorrowFieldGeneric[0](Vault.collection: ID)
7ReadRef
8CopyLoc[0](Arg0: &Collection)
9Call object::id<Collection>(&Collection): ID
10Eq
11BrFalse(13)
B1:
12Branch(27)
B2:
13MoveLoc[1](Arg1: &mut Vault<Ty0>)
14Pop
15MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
16Pop
17MoveLoc[2](Arg2: &BurnManager)
18Pop
19MoveLoc[6](Arg6: &mut TxContext)
20Pop
21MoveLoc[3](Arg3: &GlobalConfig)
22Pop
23MoveLoc[0](Arg0: &Collection)
24Pop
25LdConst[41](u64: 110)
26Abort
B3:
27MoveLoc[0](Arg0: &Collection)
28LdU8(5)
29Call assert_action(&Collection, u8)
30CopyLoc[1](Arg1: &mut Vault<Ty0>)
31ImmBorrowFieldGeneric[1](Vault.sweep_open: bool)
32ReadRef
33BrFalse(35)
B4:
34Branch(47)
B5:
35MoveLoc[1](Arg1: &mut Vault<Ty0>)
36Pop
37MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
38Pop
39MoveLoc[2](Arg2: &BurnManager)
40Pop
41MoveLoc[6](Arg6: &mut TxContext)
42Pop
43MoveLoc[3](Arg3: &GlobalConfig)
44Pop
45LdConst[45](u64: 114)
46Abort
B6:
47CopyLoc[1](Arg1: &mut Vault<Ty0>)
48ImmBorrowFieldGeneric[8](Vault.live: u64)
49ReadRef
50LdU64(0)
51Gt
52BrFalse(54)
B7:
53Branch(66)
B8:
54MoveLoc[1](Arg1: &mut Vault<Ty0>)
55Pop
56MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
57Pop
58MoveLoc[2](Arg2: &BurnManager)
59Pop
60MoveLoc[6](Arg6: &mut TxContext)
61Pop
62MoveLoc[3](Arg3: &GlobalConfig)
63Pop
64LdConst[46](u64: 115)
65Abort
B9:
66ImmBorrowLoc[5](Arg5: vector<u64>)
67VecLen(7)
68StLoc[18](loc11: u64)
69CopyLoc[18](loc11: u64)
70LdU64(0)
71Gt
72BrFalse(78)
B10:
73CopyLoc[18](loc11: u64)
74LdConst[18](u64: 50)
75Le
76StLoc[7](loc0: bool)
77Branch(80)
B11:
78LdFalse
79StLoc[7](loc0: bool)
B12:
80MoveLoc[7](loc0: bool)
81BrFalse(83)
B13:
82Branch(95)
B14:
83MoveLoc[1](Arg1: &mut Vault<Ty0>)
84Pop
85MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
86Pop
87MoveLoc[2](Arg2: &BurnManager)
88Pop
89MoveLoc[6](Arg6: &mut TxContext)
90Pop
91MoveLoc[3](Arg3: &GlobalConfig)
92Pop
93LdConst[47](u64: 116)
94Abort
B15:
95Call balance::zero<Ty0>(): Balance<Ty0>
96StLoc[15](loc8: Balance<Ty0>)
97Call balance::zero<SUI>(): Balance<SUI>
98StLoc[16](loc9: Balance<SUI>)
99LdU64(0)
100StLoc[17](loc10: u64)
B16:
101CopyLoc[17](loc10: u64)
102CopyLoc[18](loc11: u64)
103Lt
104BrFalse(181)
B17:
105ImmBorrowLoc[5](Arg5: vector<u64>)
106CopyLoc[17](loc10: u64)
107VecImmBorrow(7)
108ReadRef
109StLoc[19](loc12: u64)
110CopyLoc[19](loc12: u64)
111CopyLoc[1](Arg1: &mut Vault<Ty0>)
112ImmBorrowFieldGeneric[4](Vault.positions: u64)
113ReadRef
114Lt
115BrFalse(117)
B18:
116Branch(129)
B19:
117MoveLoc[1](Arg1: &mut Vault<Ty0>)
118Pop
119MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
120Pop
121MoveLoc[2](Arg2: &BurnManager)
122Pop
123MoveLoc[6](Arg6: &mut TxContext)
124Pop
125MoveLoc[3](Arg3: &GlobalConfig)
126Pop
127LdConst[53](u64: 122)
128Abort
B20:
129CopyLoc[1](Arg1: &mut Vault<Ty0>)
130ImmBorrowFieldGeneric[6](Vault.id: UID)
131CopyLoc[19](loc12: u64)
132Pack[6](PositionPoolKey)
133Call dynamic_field::borrow<PositionPoolKey, ID>(&UID, PositionPoolKey): &ID
134ReadRef
135CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
136FreezeRef
137Call object::id<Pool<Ty0, SUI>>(&Pool<Ty0, SUI>): ID
138Eq
139BrFalse(141)
B21:
140Branch(153)
B22:
141MoveLoc[1](Arg1: &mut Vault<Ty0>)
142Pop
143MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
144Pop
145MoveLoc[2](Arg2: &BurnManager)
146Pop
147MoveLoc[6](Arg6: &mut TxContext)
148Pop
149MoveLoc[3](Arg3: &GlobalConfig)
150Pop
151LdConst[36](u64: 105)
152Abort
B23:
153CopyLoc[1](Arg1: &mut Vault<Ty0>)
154MutBorrowFieldGeneric[5](Vault.proofs: Table<u64, CetusLPBurnProof>)
155MoveLoc[19](loc12: u64)
156Call table::borrow_mut<u64, CetusLPBurnProof>(&mut Table<u64, CetusLPBurnProof>, u64): &mut CetusLPBurnProof
157StLoc[20](loc13: &mut CetusLPBurnProof)
158CopyLoc[2](Arg2: &BurnManager)
159CopyLoc[3](Arg3: &GlobalConfig)
160CopyLoc[4](Arg4: &mut Pool<Ty0, SUI>)
161MoveLoc[20](loc13: &mut CetusLPBurnProof)
162CopyLoc[6](Arg6: &mut TxContext)
163Call lp_burn::collect_fee<Ty0, SUI>(&BurnManager, &GlobalConfig, &mut Pool<Ty0, SUI>, &mut CetusLPBurnProof, &mut TxContext): Coin<Ty0> * Coin<SUI>
164StLoc[11](loc4: Coin<SUI>)
165StLoc[8](loc1: Coin<Ty0>)
166MutBorrowLoc[15](loc8: Balance<Ty0>)
167MoveLoc[8](loc1: Coin<Ty0>)
168Call coin::into_balance<Ty0>(Coin<Ty0>): Balance<Ty0>
169Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
170Pop
171MutBorrowLoc[16](loc9: Balance<SUI>)
172MoveLoc[11](loc4: Coin<SUI>)
173Call coin::into_balance<SUI>(Coin<SUI>): Balance<SUI>
174Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
175Pop
176MoveLoc[17](loc10: u64)
177LdU64(1)
178Add
179StLoc[17](loc10: u64)
180Branch(101)
B24:
181MoveLoc[4](Arg4: &mut Pool<Ty0, SUI>)
182Pop
183MoveLoc[2](Arg2: &BurnManager)
184Pop
185MoveLoc[3](Arg3: &GlobalConfig)
186Pop
187ImmBorrowLoc[15](loc8: Balance<Ty0>)
188Call balance::value<Ty0>(&Balance<Ty0>): u64
189ImmBorrowLoc[16](loc9: Balance<SUI>)
190Call balance::value<SUI>(&Balance<SUI>): u64
191StLoc[10](loc3: u64)
192StLoc[9](loc2: u64)
193CopyLoc[1](Arg1: &mut Vault<Ty0>)
194MoveLoc[15](loc8: Balance<Ty0>)
195MoveLoc[16](loc9: Balance<SUI>)
196CopyLoc[6](Arg6: &mut TxContext)
197Call deposit<Ty0>(&mut Vault<Ty0>, Balance<Ty0>, Balance<SUI>, &mut TxContext): Coin<Ty0> * Coin<SUI>
198StLoc[14](loc7: Coin<SUI>)
199StLoc[13](loc6: Coin<Ty0>)
200MoveLoc[6](Arg6: &mut TxContext)
201FreezeRef
202Call tx_context::sender(&TxContext): address
203StLoc[12](loc5: address)
204CopyLoc[1](Arg1: &mut Vault<Ty0>)
205FreezeRef
206Call object::id<Vault<Ty0>>(&Vault<Ty0>): ID
207CopyLoc[12](loc5: address)
208MoveLoc[18](loc11: u64)
209MoveLoc[9](loc2: u64)
210MoveLoc[10](loc3: u64)
211ImmBorrowLoc[13](loc6: Coin<Ty0>)
212Call coin::value<Ty0>(&Coin<Ty0>): u64
213ImmBorrowLoc[14](loc7: Coin<SUI>)
214Call coin::value<SUI>(&Coin<SUI>): u64
215MoveLoc[1](Arg1: &mut Vault<Ty0>)
216ImmBorrowFieldGeneric[8](Vault.live: u64)
217ReadRef
218Pack[22](Swept)
219Call event::emit<Swept>(Swept)
220MoveLoc[13](loc6: Coin<Ty0>)
221CopyLoc[12](loc5: address)
222Call send<Ty0>(Coin<Ty0>, address)
223MoveLoc[14](loc7: Coin<SUI>)
224MoveLoc[12](loc5: address)
225Call send_sui(Coin<SUI>, address)
226Ret
}
assert_admin(Arg0: &AdminCap, Arg1: &Collection) {
B0:
0MoveLoc[0](Arg0: &AdminCap)
1ImmBorrowField[43](AdminCap.collection: ID)
2ReadRef
3MoveLoc[1](Arg1: &Collection)
4Call object::id<Collection>(&Collection): ID
5Eq
6BrFalse(8)
B1:
7Branch(10)
B2:
8LdConst[79](u64: 150)
9Abort
B3:
10Ret
}
check_collection(Arg0: &Collection) {
L1: loc0: bool
B0:
0CopyLoc[0](Arg0: &Collection)
1ImmBorrowField[42](Collection.version: u64)
2ReadRef
3LdConst[13](u64: 1)
4Eq
5BrFalse(14)
B1:
6MoveLoc[0](Arg0: &Collection)
7Call configuration(&Collection): &Config
8ImmBorrowField[41](Config.code_version: u64)
9ReadRef
10LdConst[13](u64: 1)
11Eq
12StLoc[1](loc0: bool)
13Branch(18)
B2:
14MoveLoc[0](Arg0: &Collection)
15Pop
16LdFalse
17StLoc[1](loc0: bool)
B3:
18MoveLoc[1](loc0: bool)
19BrFalse(21)
B4:
20Branch(23)
B5:
21LdConst[17](u64: 100)
22Abort
B6:
23Ret
}
check_vault<Ty0>(Arg0: &Vault<Ty0>) {
B0:
0MoveLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[3](Vault.version: u64)
2ReadRef
3LdConst[13](u64: 1)
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[17](u64: 100)
8Abort
B3:
9Ret
}
check_burn<Ty0>(Arg0: &Collection, Arg1: &Vault<Ty0>, Arg2: &TransferPolicy<KingFizh>, Arg3: &Kiosk) {
B0:
0CopyLoc[0](Arg0: &Collection)
1Call check_collection(&Collection)
2CopyLoc[1](Arg1: &Vault<Ty0>)
3Call check_vault<Ty0>(&Vault<Ty0>)
4MoveLoc[1](Arg1: &Vault<Ty0>)
5ImmBorrowFieldGeneric[0](Vault.collection: ID)
6ReadRef
7CopyLoc[0](Arg0: &Collection)
8Call object::id<Collection>(&Collection): ID
9Eq
10BrFalse(12)
B1:
11Branch(20)
B2:
12MoveLoc[2](Arg2: &TransferPolicy<KingFizh>)
13Pop
14MoveLoc[3](Arg3: &Kiosk)
15Pop
16MoveLoc[0](Arg0: &Collection)
17Pop
18LdConst[41](u64: 110)
19Abort
B3:
20MoveLoc[2](Arg2: &TransferPolicy<KingFizh>)
21Call object::id<TransferPolicy<KingFizh>>(&TransferPolicy<KingFizh>): ID
22CopyLoc[0](Arg0: &Collection)
23ImmBorrowField[13](Collection.policy: ID)
24ReadRef
25Eq
26BrFalse(28)
B4:
27Branch(34)
B5:
28MoveLoc[3](Arg3: &Kiosk)
29Pop
30MoveLoc[0](Arg0: &Collection)
31Pop
32LdConst[49](u64: 118)
33Abort
B6:
34MoveLoc[3](Arg3: &Kiosk)
35Call object::id<Kiosk>(&Kiosk): ID
36MoveLoc[0](Arg0: &Collection)
37ImmBorrowField[75](Collection.graveyard: ID)
38ReadRef
39Eq
40BrFalse(42)
B7:
41Branch(44)
B8:
42LdConst[48](u64: 117)
43Abort
B9:
44Ret
}
assert_configured(Arg0: &Collection) {
L1: loc0: bool
L2: loc1: ID
B0:
0LdConst[97](address: 0x00..)
1Call object::id_from_address(address): ID
2StLoc[2](loc1: ID)
3CopyLoc[0](Arg0: &Collection)
4ImmBorrowField[26](Collection.fee_wallet: address)
5ReadRef
6LdConst[97](address: 0x00..)
7Neq
8BrFalse(60)
B1:
9CopyLoc[0](Arg0: &Collection)
10ImmBorrowField[28](Collection.royalty_wallet: address)
11ReadRef
12LdConst[97](address: 0x00..)
13Neq
14BrFalse(55)
B2:
15CopyLoc[0](Arg0: &Collection)
16ImmBorrowField[16](Collection.validator: address)
17ReadRef
18LdConst[97](address: 0x00..)
19Neq
20BrFalse(50)
B3:
21CopyLoc[0](Arg0: &Collection)
22ImmBorrowField[22](Collection.swap_pool: ID)
23ReadRef
24CopyLoc[2](loc1: ID)
25Neq
26BrFalse(45)
B4:
27CopyLoc[0](Arg0: &Collection)
28ImmBorrowField[23](Collection.lp_pool: ID)
29ReadRef
30CopyLoc[2](loc1: ID)
31Neq
32BrFalse(40)
B5:
33MoveLoc[0](Arg0: &Collection)
34ImmBorrowField[12](Collection.vault: ID)
35ReadRef
36MoveLoc[2](loc1: ID)
37Neq
38StLoc[1](loc0: bool)
39Branch(64)
B6:
40MoveLoc[0](Arg0: &Collection)
41Pop
42LdFalse
43StLoc[1](loc0: bool)
44Branch(64)
B7:
45MoveLoc[0](Arg0: &Collection)
46Pop
47LdFalse
48StLoc[1](loc0: bool)
49Branch(64)
B8:
50MoveLoc[0](Arg0: &Collection)
51Pop
52LdFalse
53StLoc[1](loc0: bool)
54Branch(64)
B9:
55MoveLoc[0](Arg0: &Collection)
56Pop
57LdFalse
58StLoc[1](loc0: bool)
59Branch(64)
B10:
60MoveLoc[0](Arg0: &Collection)
61Pop
62LdFalse
63StLoc[1](loc0: bool)
B11:
64MoveLoc[1](loc0: bool)
65BrFalse(67)
B12:
66Branch(69)
B13:
67LdConst[40](u64: 109)
68Abort
B14:
69Ret
}
take_out(Arg0: &mut Kiosk, Arg1: &KioskOwnerCap, Arg2: ID, Arg3: &mut TxContext): KingFizh * TransferRequest<KingFizh> {
L4: loc0: PurchaseCap<KingFizh>
B0:
0CopyLoc[0](Arg0: &mut Kiosk)
1MoveLoc[1](Arg1: &KioskOwnerCap)
2MoveLoc[2](Arg2: ID)
3LdU64(0)
4CopyLoc[3](Arg3: &mut TxContext)
5Call kiosk::list_with_purchase_cap<KingFizh>(&mut Kiosk, &KioskOwnerCap, ID, u64, &mut TxContext): PurchaseCap<KingFizh>
6StLoc[4](loc0: PurchaseCap<KingFizh>)
7MoveLoc[0](Arg0: &mut Kiosk)
8MoveLoc[4](loc0: PurchaseCap<KingFizh>)
9MoveLoc[3](Arg3: &mut TxContext)
10Call coin::zero<SUI>(&mut TxContext): Coin<SUI>
11Call kiosk::purchase_with_cap<KingFizh>(&mut Kiosk, PurchaseCap<KingFizh>, Coin<SUI>): KingFizh * TransferRequest<KingFizh>
12Ret
}
settle_burn<Ty0>(Arg0: &mut Collection, Arg1: &mut Vault<Ty0>, Arg2: &mut TransferPolicy<KingFizh>, Arg3: &mut Kiosk, Arg4: KingFizh, Arg5: TransferRequest<KingFizh>, Arg6: Balance<SUI>, Arg7: &mut TxContext) {
L8: loc0: address
L9: loc1: u64
L10: loc2: ID
L11: loc3: u64
L12: loc4: Coin<Ty0>
L13: loc5: u64
L14: loc6: Coin<SUI>
L15: loc7: u64
L16: loc8: u64
L17: loc9: u64
L18: loc10: u64
L19: loc11: Coin<SUI>
B0:
0CopyLoc[7](Arg7: &mut TxContext)
1FreezeRef
2Call tx_context::sender(&TxContext): address
3StLoc[8](loc0: address)
4ImmBorrowLoc[6](Arg6: Balance<SUI>)
5Call balance::value<SUI>(&Balance<SUI>): u64
6StLoc[18](loc10: u64)
7CopyLoc[1](Arg1: &mut Vault<Ty0>)
8MutBorrowLoc[4](Arg4: KingFizh)
9CopyLoc[7](Arg7: &mut TxContext)
10Call pay_pot<Ty0>(&mut Vault<Ty0>, &mut KingFizh, &mut TxContext): Coin<Ty0> * Coin<SUI>
11StLoc[14](loc6: Coin<SUI>)
12StLoc[12](loc4: Coin<Ty0>)
13ImmBorrowLoc[12](loc4: Coin<Ty0>)
14Call coin::value<Ty0>(&Coin<Ty0>): u64
15ImmBorrowLoc[14](loc6: Coin<SUI>)
16Call coin::value<SUI>(&Coin<SUI>): u64
17StLoc[15](loc7: u64)
18StLoc[13](loc5: u64)
19CopyLoc[1](Arg1: &mut Vault<Ty0>)
20ImmBorrowFieldGeneric[8](Vault.live: u64)
21ReadRef
22LdU64(1)
23Sub
24CopyLoc[1](Arg1: &mut Vault<Ty0>)
25MutBorrowFieldGeneric[8](Vault.live: u64)
26WriteRef
27CopyLoc[0](Arg0: &mut Collection)
28ImmBorrowField[76](Collection.burned: u64)
29ReadRef
30LdU64(1)
31Add
32CopyLoc[0](Arg0: &mut Collection)
33MutBorrowField[76](Collection.burned: u64)
34WriteRef
35LdConst[23](vector<u8>: "Bur..)
36Call string::utf8(vector<u8>): String
37MutBorrowLoc[4](Arg4: KingFizh)
38MutBorrowField[77](KingFizh.status: String)
39WriteRef
40LdConst[25](vector<u8>: "bur..)
41Call string::utf8(vector<u8>): String
42MutBorrowLoc[4](Arg4: KingFizh)
43MutBorrowField[78](KingFizh.media: String)
44WriteRef
45CopyLoc[7](Arg7: &mut TxContext)
46FreezeRef
47Call tx_context::epoch(&TxContext): u64
48MutBorrowLoc[4](Arg4: KingFizh)
49MutBorrowField[79](KingFizh.burned_epoch: u64)
50WriteRef
51ImmBorrowLoc[4](Arg4: KingFizh)
52Call object::id<KingFizh>(&KingFizh): ID
53StLoc[10](loc2: ID)
54ImmBorrowLoc[4](Arg4: KingFizh)
55ImmBorrowField[73](KingFizh.number: u64)
56ReadRef
57ImmBorrowLoc[4](Arg4: KingFizh)
58ImmBorrowField[74](KingFizh.index: u64)
59ReadRef
60ImmBorrowLoc[4](Arg4: KingFizh)
61ImmBorrowField[71](KingFizh.principal: u64)
62ReadRef
63StLoc[16](loc8: u64)
64StLoc[9](loc1: u64)
65StLoc[11](loc3: u64)
66ImmBorrowLoc[4](Arg4: KingFizh)
67ImmBorrowField[70](KingFizh.stake: Option<StakedSui>)
68Call option::is_none<StakedSui>(&Option<StakedSui>): bool
69BrFalse(71)
B1:
70Branch(83)
B2:
71MoveLoc[1](Arg1: &mut Vault<Ty0>)
72Pop
73MoveLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
74Pop
75MoveLoc[3](Arg3: &mut Kiosk)
76Pop
77MoveLoc[7](Arg7: &mut TxContext)
78Pop
79MoveLoc[0](Arg0: &mut Collection)
80Pop
81LdConst[44](u64: 113)
82Abort
B3:
83CopyLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
84FreezeRef
85LdU64(0)
86Call royalty_rule::fee_amount<KingFizh>(&TransferPolicy<KingFizh>, u64): u64
87StLoc[17](loc9: u64)
88CopyLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
89MutBorrowLoc[5](Arg5: TransferRequest<KingFizh>)
90MutBorrowLoc[6](Arg6: Balance<SUI>)
91CopyLoc[17](loc9: u64)
92Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
93CopyLoc[7](Arg7: &mut TxContext)
94Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
95Call royalty_rule::pay<KingFizh>(&mut TransferPolicy<KingFizh>, &mut TransferRequest<KingFizh>, Coin<SUI>)
96CopyLoc[3](Arg3: &mut Kiosk)
97MoveLoc[0](Arg0: &mut Collection)
98ImmBorrowField[80](Collection.graveyard_cap: KioskOwnerCap)
99CopyLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
100FreezeRef
101MoveLoc[4](Arg4: KingFizh)
102Call kiosk::lock<KingFizh>(&mut Kiosk, &KioskOwnerCap, &TransferPolicy<KingFizh>, KingFizh)
103MutBorrowLoc[5](Arg5: TransferRequest<KingFizh>)
104MoveLoc[3](Arg3: &mut Kiosk)
105FreezeRef
106Call kiosk_lock_rule::prove<KingFizh>(&mut TransferRequest<KingFizh>, &Kiosk)
107MoveLoc[2](Arg2: &mut TransferPolicy<KingFizh>)
108FreezeRef
109MoveLoc[5](Arg5: TransferRequest<KingFizh>)
110Call transfer_policy::confirm_request<KingFizh>(&TransferPolicy<KingFizh>, TransferRequest<KingFizh>): ID * u64 * ID
111Pop
112Pop
113Pop
114MoveLoc[10](loc2: ID)
115MoveLoc[11](loc3: u64)
116MoveLoc[9](loc1: u64)
117CopyLoc[8](loc0: address)
118MoveLoc[16](loc8: u64)
119MoveLoc[18](loc10: u64)
120MoveLoc[13](loc5: u64)
121MoveLoc[15](loc7: u64)
122MoveLoc[17](loc9: u64)
123MoveLoc[1](Arg1: &mut Vault<Ty0>)
124ImmBorrowFieldGeneric[8](Vault.live: u64)
125ReadRef
126Pack[23](Burned)
127Call event::emit<Burned>(Burned)
128MoveLoc[6](Arg6: Balance<SUI>)
129MoveLoc[7](Arg7: &mut TxContext)
130Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
131StLoc[19](loc11: Coin<SUI>)
132MutBorrowLoc[19](loc11: Coin<SUI>)
133MoveLoc[14](loc6: Coin<SUI>)
134Call coin::join<SUI>(&mut Coin<SUI>, Coin<SUI>)
135MoveLoc[12](loc4: Coin<Ty0>)
136CopyLoc[8](loc0: address)
137Call send<Ty0>(Coin<Ty0>, address)
138MoveLoc[19](loc11: Coin<SUI>)
139MoveLoc[8](loc0: address)
140Call send_sui(Coin<SUI>, address)
141Ret
}
pay_pot<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: &mut KingFizh, Arg2: &mut TxContext): Coin<Ty0> * Coin<SUI> {
L3: loc0: u64
L4: loc1: u64
B0:
0CopyLoc[0](Arg0: &mut Vault<Ty0>)
1ImmBorrowFieldGeneric[11](Vault.acc_a: u128)
2ReadRef
3CopyLoc[1](Arg1: &mut KingFizh)
4ImmBorrowField[81](KingFizh.debt_a: u128)
5ReadRef
6Sub
7LdConst[14](u128: 1000..)
8Div
9CastU64
10StLoc[3](loc0: u64)
11CopyLoc[0](Arg0: &mut Vault<Ty0>)
12ImmBorrowFieldGeneric[7](Vault.acc_b: u128)
13ReadRef
14CopyLoc[1](Arg1: &mut KingFizh)
15ImmBorrowField[82](KingFizh.debt_b: u128)
16ReadRef
17Sub
18LdConst[14](u128: 1000..)
19Div
20CastU64
21StLoc[4](loc1: u64)
22CopyLoc[0](Arg0: &mut Vault<Ty0>)
23ImmBorrowFieldGeneric[11](Vault.acc_a: u128)
24ReadRef
25CopyLoc[1](Arg1: &mut KingFizh)
26MutBorrowField[81](KingFizh.debt_a: u128)
27WriteRef
28CopyLoc[0](Arg0: &mut Vault<Ty0>)
29ImmBorrowFieldGeneric[7](Vault.acc_b: u128)
30ReadRef
31MoveLoc[1](Arg1: &mut KingFizh)
32MutBorrowField[82](KingFizh.debt_b: u128)
33WriteRef
34CopyLoc[0](Arg0: &mut Vault<Ty0>)
35ImmBorrowFieldGeneric[12](Vault.paid_a: u64)
36ReadRef
37CopyLoc[3](loc0: u64)
38Add
39CopyLoc[0](Arg0: &mut Vault<Ty0>)
40MutBorrowFieldGeneric[12](Vault.paid_a: u64)
41WriteRef
42CopyLoc[0](Arg0: &mut Vault<Ty0>)
43ImmBorrowFieldGeneric[13](Vault.paid_b: u64)
44ReadRef
45CopyLoc[4](loc1: u64)
46Add
47CopyLoc[0](Arg0: &mut Vault<Ty0>)
48MutBorrowFieldGeneric[13](Vault.paid_b: u64)
49WriteRef
50CopyLoc[0](Arg0: &mut Vault<Ty0>)
51MutBorrowFieldGeneric[14](Vault.pot_a: Balance<Ty0>)
52MoveLoc[3](loc0: u64)
53Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
54CopyLoc[2](Arg2: &mut TxContext)
55Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
56MoveLoc[0](Arg0: &mut Vault<Ty0>)
57MutBorrowFieldGeneric[10](Vault.pot_b: Balance<SUI>)
58MoveLoc[4](loc1: u64)
59Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
60MoveLoc[2](Arg2: &mut TxContext)
61Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
62Ret
}
deposit<Ty0>(Arg0: &mut Vault<Ty0>, Arg1: Balance<Ty0>, Arg2: Balance<SUI>, Arg3: &mut TxContext): Coin<Ty0> * Coin<SUI> {
L4: loc0: Coin<Ty0>
L5: loc1: Coin<SUI>
L6: loc2: u64
L7: loc3: u64
L8: loc4: u128
L9: loc5: u64
L10: loc6: u64
B0:
0ImmBorrowLoc[1](Arg1: Balance<Ty0>)
1Call balance::value<Ty0>(&Balance<Ty0>): u64
2CastU128
3CopyLoc[0](Arg0: &mut Vault<Ty0>)
4ImmBorrowFieldGeneric[2](Vault.sweep_fee_bps: u64)
5ReadRef
6CastU128
7Mul
8LdU128(10000)
9Div
10CastU64
11StLoc[6](loc2: u64)
12ImmBorrowLoc[2](Arg2: Balance<SUI>)
13Call balance::value<SUI>(&Balance<SUI>): u64
14CastU128
15CopyLoc[0](Arg0: &mut Vault<Ty0>)
16ImmBorrowFieldGeneric[2](Vault.sweep_fee_bps: u64)
17ReadRef
18CastU128
19Mul
20LdU128(10000)
21Div
22CastU64
23StLoc[7](loc3: u64)
24MutBorrowLoc[1](Arg1: Balance<Ty0>)
25MoveLoc[6](loc2: u64)
26Call balance::split<Ty0>(&mut Balance<Ty0>, u64): Balance<Ty0>
27CopyLoc[3](Arg3: &mut TxContext)
28Call coin::from_balance<Ty0>(Balance<Ty0>, &mut TxContext): Coin<Ty0>
29StLoc[4](loc0: Coin<Ty0>)
30MutBorrowLoc[2](Arg2: Balance<SUI>)
31MoveLoc[7](loc3: u64)
32Call balance::split<SUI>(&mut Balance<SUI>, u64): Balance<SUI>
33MoveLoc[3](Arg3: &mut TxContext)
34Call coin::from_balance<SUI>(Balance<SUI>, &mut TxContext): Coin<SUI>
35StLoc[5](loc1: Coin<SUI>)
36ImmBorrowLoc[1](Arg1: Balance<Ty0>)
37Call balance::value<Ty0>(&Balance<Ty0>): u64
38ImmBorrowLoc[2](Arg2: Balance<SUI>)
39Call balance::value<SUI>(&Balance<SUI>): u64
40StLoc[10](loc6: u64)
41StLoc[9](loc5: u64)
42CopyLoc[0](Arg0: &mut Vault<Ty0>)
43ImmBorrowFieldGeneric[8](Vault.live: u64)
44ReadRef
45CastU128
46StLoc[8](loc4: u128)
47CopyLoc[0](Arg0: &mut Vault<Ty0>)
48ImmBorrowFieldGeneric[11](Vault.acc_a: u128)
49ReadRef
50CopyLoc[9](loc5: u64)
51CastU128
52LdConst[14](u128: 1000..)
53Mul
54CopyLoc[8](loc4: u128)
55Div
56Add
57CopyLoc[0](Arg0: &mut Vault<Ty0>)
58MutBorrowFieldGeneric[11](Vault.acc_a: u128)
59WriteRef
60CopyLoc[0](Arg0: &mut Vault<Ty0>)
61ImmBorrowFieldGeneric[7](Vault.acc_b: u128)
62ReadRef
63CopyLoc[10](loc6: u64)
64CastU128
65LdConst[14](u128: 1000..)
66Mul
67MoveLoc[8](loc4: u128)
68Div
69Add
70CopyLoc[0](Arg0: &mut Vault<Ty0>)
71MutBorrowFieldGeneric[7](Vault.acc_b: u128)
72WriteRef
73CopyLoc[0](Arg0: &mut Vault<Ty0>)
74ImmBorrowFieldGeneric[15](Vault.swept_a: u64)
75ReadRef
76MoveLoc[9](loc5: u64)
77Add
78CopyLoc[0](Arg0: &mut Vault<Ty0>)
79MutBorrowFieldGeneric[15](Vault.swept_a: u64)
80WriteRef
81CopyLoc[0](Arg0: &mut Vault<Ty0>)
82ImmBorrowFieldGeneric[9](Vault.swept_b: u64)
83ReadRef
84MoveLoc[10](loc6: u64)
85Add
86CopyLoc[0](Arg0: &mut Vault<Ty0>)
87MutBorrowFieldGeneric[9](Vault.swept_b: u64)
88WriteRef
89CopyLoc[0](Arg0: &mut Vault<Ty0>)
90MutBorrowFieldGeneric[14](Vault.pot_a: Balance<Ty0>)
91MoveLoc[1](Arg1: Balance<Ty0>)
92Call balance::join<Ty0>(&mut Balance<Ty0>, Balance<Ty0>): u64
93Pop
94MoveLoc[0](Arg0: &mut Vault<Ty0>)
95MutBorrowFieldGeneric[10](Vault.pot_b: Balance<SUI>)
96MoveLoc[2](Arg2: Balance<SUI>)
97Call balance::join<SUI>(&mut Balance<SUI>, Balance<SUI>): u64
98Pop
99MoveLoc[4](loc0: Coin<Ty0>)
100MoveLoc[5](loc1: Coin<SUI>)
101Ret
}
send<Ty0>(Arg0: Coin<Ty0>, Arg1: address) {
B0:
0ImmBorrowLoc[0](Arg0: Coin<Ty0>)
1Call coin::value<Ty0>(&Coin<Ty0>): u64
2LdU64(0)
3Eq
4BrFalse(8)
B1:
5MoveLoc[0](Arg0: Coin<Ty0>)
6Call coin::destroy_zero<Ty0>(Coin<Ty0>)
7Branch(11)
B2:
8MoveLoc[0](Arg0: Coin<Ty0>)
9MoveLoc[1](Arg1: address)
10Call transfer::public_transfer<Coin<Ty0>>(Coin<Ty0>, address)
B3:
11Ret
}
send_sui(Arg0: Coin<SUI>, Arg1: address) {
B0:
0MoveLoc[0](Arg0: Coin<SUI>)
1MoveLoc[1](Arg1: address)
2Call send<SUI>(Coin<SUI>, address)
3Ret
}
public version(): u64 {
B0:
0LdConst[13](u64: 1)
1Ret
}
public scale(): u128 {
B0:
0LdConst[14](u128: 1000..)
1Ret
}
public max_per_tx(): u64 {
B0:
0LdConst[12](u64: 25)
1Ret
}
public supply(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[1](Collection.supply: u64)
2ReadRef
3Ret
}
public minted(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[5](Collection.minted: u64)
2ReadRef
3Ret
}
public burned(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[76](Collection.burned: u64)
2ReadRef
3Ret
}
public seeded(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[3](Collection.seeded: u64)
2ReadRef
3Ret
}
public drawn(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[9](Collection.drawn: u64)
2ReadRef
3Ret
}
public public_remaining(Arg0: &Collection): u64 {
B0:
0CopyLoc[0](Arg0: &Collection)
1ImmBorrowField[1](Collection.supply: u64)
2ReadRef
3MoveLoc[0](Arg0: &Collection)
4ImmBorrowField[9](Collection.drawn: u64)
5ReadRef
6Sub
7Ret
}
public reserved_total(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[7](Collection.reserved_total: u64)
2ReadRef
3Ret
}
public reservation(Arg0: &Collection, Arg1: u64): Option<address> {
L2: loc0: Option<address>
B0:
0CopyLoc[0](Arg0: &Collection)
1ImmBorrowField[8](Collection.reservations: Table<u64, address>)
2CopyLoc[1](Arg1: u64)
3Call table::contains<u64, address>(&Table<u64, address>, u64): bool
4BrFalse(13)
B1:
5MoveLoc[0](Arg0: &Collection)
6ImmBorrowField[8](Collection.reservations: Table<u64, address>)
7MoveLoc[1](Arg1: u64)
8Call table::borrow<u64, address>(&Table<u64, address>, u64): &address
9ReadRef
10Call option::some<address>(address): Option<address>
11StLoc[2](loc0: Option<address>)
12Branch(17)
B2:
13MoveLoc[0](Arg0: &Collection)
14Pop
15Call option::none<address>(): Option<address>
16StLoc[2](loc0: Option<address>)
B3:
17MoveLoc[2](loc0: Option<address>)
18Ret
}
public price(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[45](Collection.price: u64)
2ReadRef
3Ret
}
public stake_amount(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[15](Collection.stake_amount: u64)
2ReadRef
3Ret
}
public lp_amount(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[46](Collection.lp_amount: u64)
2ReadRef
3Ret
}
public fee_wallet(Arg0: &Collection): address {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[26](Collection.fee_wallet: address)
2ReadRef
3Ret
}
public validator(Arg0: &Collection): address {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[16](Collection.validator: address)
2ReadRef
3Ret
}
public swap_pool(Arg0: &Collection): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[22](Collection.swap_pool: ID)
2ReadRef
3Ret
}
public lp_pool(Arg0: &Collection): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[23](Collection.lp_pool: ID)
2ReadRef
3Ret
}
public vault_id(Arg0: &Collection): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[12](Collection.vault: ID)
2ReadRef
3Ret
}
public policy_id(Arg0: &Collection): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[13](Collection.policy: ID)
2ReadRef
3Ret
}
public graveyard_id(Arg0: &Collection): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[75](Collection.graveyard: ID)
2ReadRef
3Ret
}
public mint_open(Arg0: &Collection): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[6](Collection.mint_open: bool)
2ReadRef
3Ret
}
public holder_start_ms(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[14](Collection.holder_start_ms: u64)
2ReadRef
3Ret
}
public public_start_ms(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[18](Collection.public_start_ms: u64)
2ReadRef
3Ret
}
public min_holder_balance(Arg0: &Collection): u64 {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[32](Collection.min_holder_balance: u64)
2ReadRef
3Ret
}
public royalty_wallet(Arg0: &Collection): address {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[28](Collection.royalty_wallet: address)
2ReadRef
3Ret
}
public is_minted(Arg0: &Collection, Arg1: u64): bool {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[20](Collection.items: Table<u64, ID>)
2MoveLoc[1](Arg1: u64)
3Call table::contains<u64, ID>(&Table<u64, ID>, u64): bool
4Ret
}
public item_id(Arg0: &Collection, Arg1: u64): ID {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[20](Collection.items: Table<u64, ID>)
2MoveLoc[1](Arg1: u64)
3Call table::borrow<u64, ID>(&Table<u64, ID>, u64): &ID
4ReadRef
5Ret
}
public traits(Arg0: &Collection, Arg1: u64): VecMap<String, String> {
B0:
0MoveLoc[0](Arg0: &Collection)
1ImmBorrowField[2](Collection.registry: Table<u64, ItemData>)
2MoveLoc[1](Arg1: u64)
3Call table::borrow<u64, ItemData>(&Table<u64, ItemData>, u64): &ItemData
4ImmBorrowField[54](ItemData.attributes: VecMap<String, String>)
5ReadRef
6Ret
}
public live<Ty0>(Arg0: &Vault<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[8](Vault.live: u64)
2ReadRef
3Ret
}
public positions<Ty0>(Arg0: &Vault<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[4](Vault.positions: u64)
2ReadRef
3Ret
}
public pot<Ty0>(Arg0: &Vault<Ty0>): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[14](Vault.pot_a: Balance<Ty0>)
2Call balance::value<Ty0>(&Balance<Ty0>): u64
3MoveLoc[0](Arg0: &Vault<Ty0>)
4ImmBorrowFieldGeneric[10](Vault.pot_b: Balance<SUI>)
5Call balance::value<SUI>(&Balance<SUI>): u64
6Ret
}
public acc<Ty0>(Arg0: &Vault<Ty0>): u128 * u128 {
B0:
0CopyLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[11](Vault.acc_a: u128)
2ReadRef
3MoveLoc[0](Arg0: &Vault<Ty0>)
4ImmBorrowFieldGeneric[7](Vault.acc_b: u128)
5ReadRef
6Ret
}
public sweep_fee_bps<Ty0>(Arg0: &Vault<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[2](Vault.sweep_fee_bps: u64)
2ReadRef
3Ret
}
public sweep_open<Ty0>(Arg0: &Vault<Ty0>): bool {
B0:
0MoveLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[1](Vault.sweep_open: bool)
2ReadRef
3Ret
}
public has_proof<Ty0>(Arg0: &Vault<Ty0>, Arg1: u64): bool {
B0:
0MoveLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[5](Vault.proofs: Table<u64, CetusLPBurnProof>)
2MoveLoc[1](Arg1: u64)
3Call table::contains<u64, CetusLPBurnProof>(&Table<u64, CetusLPBurnProof>, u64): bool
4Ret
}
public pending<Ty0>(Arg0: &Vault<Ty0>, Arg1: &KingFizh): u64 * u64 {
B0:
0CopyLoc[0](Arg0: &Vault<Ty0>)
1ImmBorrowFieldGeneric[11](Vault.acc_a: u128)
2ReadRef
3CopyLoc[1](Arg1: &KingFizh)
4ImmBorrowField[81](KingFizh.debt_a: u128)
5ReadRef
6Sub
7LdConst[14](u128: 1000..)
8Div
9CastU64
10MoveLoc[0](Arg0: &Vault<Ty0>)
11ImmBorrowFieldGeneric[7](Vault.acc_b: u128)
12ReadRef
13MoveLoc[1](Arg1: &KingFizh)
14ImmBorrowField[82](KingFizh.debt_b: u128)
15ReadRef
16Sub
17LdConst[14](u128: 1000..)
18Div
19CastU64
20Ret
}
public number(Arg0: &KingFizh): u64 {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[73](KingFizh.number: u64)
2ReadRef
3Ret
}
public index(Arg0: &KingFizh): u64 {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[74](KingFizh.index: u64)
2ReadRef
3Ret
}
public attributes(Arg0: &KingFizh): VecMap<String, String> {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[87](KingFizh.attributes: VecMap<String, String>)
2ReadRef
3Ret
}
public filler_len(Arg0: &KingFizh): u64 {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[88](KingFizh.filler: VecMap<String, String>)
2Call vec_map::length<String, String>(&VecMap<String, String>): u64
3Ret
}
public media(Arg0: &KingFizh): String {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[78](KingFizh.media: String)
2ReadRef
3Ret
}
public position(Arg0: &KingFizh): u64 {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[89](KingFizh.position: u64)
2ReadRef
3Ret
}
public principal(Arg0: &KingFizh): u64 {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[71](KingFizh.principal: u64)
2ReadRef
3Ret
}
public item_validator(Arg0: &KingFizh): address {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[72](KingFizh.validator: address)
2ReadRef
3Ret
}
public status(Arg0: &KingFizh): String {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[77](KingFizh.status: String)
2ReadRef
3Ret
}
public is_active(Arg0: &KingFizh): bool {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[77](KingFizh.status: String)
2ReadRef
3LdConst[22](vector<u8>: "Act..)
4Call string::utf8(vector<u8>): String
5Eq
6Ret
}
public has_stake(Arg0: &KingFizh): bool {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[70](KingFizh.stake: Option<StakedSui>)
2Call option::is_some<StakedSui>(&Option<StakedSui>): bool
3Ret
}
public item_vault(Arg0: &KingFizh): ID {
B0:
0MoveLoc[0](Arg0: &KingFizh)
1ImmBorrowField[69](KingFizh.vault: ID)
2ReadRef
3Ret
}
Constants [
0 => vector<u8>: "King Fizh" // interpreted as UTF8 string
1 => u64: 2100
2 => u64: 8000000000
3 => u64: 2000000000
4 => u64: 1500000000
5 => u16: 500
6 => u64: 0
7 => vector<u8>: "https://assets.alienz.tech/collections/05899071423146b3ec5c7b568067414eb0c3ac26e4a4ac951c3cbc36a0fd6a36/" // interpreted as UTF8 string
8 => vector<u8>: "webp" // interpreted as UTF8 string
9 => vector<u8>: "https://kingfizh.alienz.tech/" // interpreted as UTF8 string
10 => vector<u8>: "Alienztech" // interpreted as UTF8 string
11 => vector<u8>: "King Fizh #{index}" // interpreted as UTF8 string
12 => u64: 25
13 => u64: 1
14 => u128: 1000000000000
15 => u64: 1000000000
16 => u64: 1000
17 => u64: 100
18 => u64: 50
19 => u64: 2
20 => u32: 443636
21 => u128: 79226673515401279992447579055
22 => vector<u8>: "Active" // interpreted as UTF8 string
23 => vector<u8>: "Burned" // interpreted as UTF8 string
24 => vector<u8>: "tokens" // interpreted as UTF8 string
25 => vector<u8>: "burned" // interpreted as UTF8 string
26 => u64: 18446744073709551615
27 => u64: 400
28 => u64: 272
29 => u64: 15
30 => u64: 3
31 => u64: 127
32 => u64: 101
33 => u64: 102
34 => u64: 103
35 => u64: 104
36 => u64: 105
37 => u64: 106
38 => u64: 107
39 => u64: 108
40 => u64: 109
41 => u64: 110
42 => u64: 111
43 => u64: 112
44 => u64: 113
45 => u64: 114
46 => u64: 115
47 => u64: 116
48 => u64: 117
49 => u64: 118
50 => u64: 119
51 => u64: 120
52 => u64: 121
53 => u64: 122
54 => u64: 123
55 => u64: 124
56 => u64: 125
57 => u64: 126
58 => u64: 128
59 => u64: 129
60 => u64: 130
61 => u64: 131
62 => u64: 132
63 => u64: 133
64 => u64: 134
65 => u64: 135
66 => u64: 136
67 => u64: 137
68 => u64: 138
69 => u64: 139
70 => u64: 141
71 => u64: 142
72 => u64: 143
73 => u64: 144
74 => u64: 145
75 => u64: 146
76 => u64: 147
77 => u64: 148
78 => u64: 149
79 => u64: 150
80 => vector<u8>: "{media}/{index}." // interpreted as UTF8 string
81 => vector<u8>: "piece/{index}" // interpreted as UTF8 string
82 => vector<u8>: "name" // interpreted as UTF8 string
83 => vector<u8>: "description" // interpreted as UTF8 string
84 => vector<u8>: "image_url" // interpreted as UTF8 string
85 => vector<u8>: "thumbnail_url" // interpreted as UTF8 string
86 => vector<u8>: "link" // interpreted as UTF8 string
87 => vector<u8>: "project_url" // interpreted as UTF8 string
88 => vector<u8>: "creator" // interpreted as UTF8 string
89 => vector<u8>: "number" // interpreted as UTF8 string
90 => vector<u8>: "status" // interpreted as UTF8 string
91 => vector<u8>: "principal" // interpreted as UTF8 string
92 => vector<u8>: "validator" // interpreted as UTF8 string
93 => vector<u8>: "{number}" // interpreted as UTF8 string
94 => vector<u8>: "{status}" // interpreted as UTF8 string
95 => vector<u8>: "{principal}" // interpreted as UTF8 string
96 => vector<u8>: "{validator}" // interpreted as UTF8 string
97 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
98 => vector<u16>: 00
99 => vector<u8>: "" // interpreted as UTF8 string
100 => vector<u8>: "5fad71cd86dfb03f3941571835b54fb2a94364ae54ac7f816224837ff424b662::king::KING" // interpreted as UTF8 string
101 => vector<u8>: "https://" // interpreted as UTF8 string
102 => vector<u8>: ".invalid" // interpreted as UTF8 string
103 => vector<u8>: "{media}/{index}.webp" // interpreted as UTF8 string
104 => address: 0x000000000000000000000000000000000000000000000000000000000000000d
105 => vector<u8>: "0x" // interpreted as UTF8 string
106 => vector<u8>: "attributes" // interpreted as UTF8 string
107 => vector<u8>: "index" // interpreted as UTF8 string
108 => vector<u8>: "collection_name" // interpreted as UTF8 string
109 => vector<u8>: "collection_description" // interpreted as UTF8 string
110 => vector<u8>: "collection_cover_url" // interpreted as UTF8 string
111 => vector<u8>: "collection_id" // interpreted as UTF8 string
112 => vector<u8>: "{attributes:json}" // interpreted as UTF8 string
113 => vector<u8>: "{index}" // interpreted as UTF8 string
114 => vector<u8>: "tokens/0.webp" // interpreted as UTF8 string
]
}