phase
Module0xea36…3e21
- Move path
- 0x60e6…fb75::phase
- Functions
- 3833 public, 0 entry
- Structs
- 11
Bytecode1442 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module 60e688bb4071cd6ea5aed6f22b2dc717e067bbcbe60b73c931a0be728c3cfb75.phase {
use 60e688bb4071cd6ea5aed6f22b2dc717e067bbcbe60b73c931a0be728c3cfb75::launch;
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::table_vec;
use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
struct PHASE has drop {
dummy_field: bool
}
struct Phase<phantom Ty0: store + key> has key {
id: UID,
kind: PhaseKind,
state: PhaseState,
launch_id: ID,
name: Option<String>,
description: Option<String>,
start_ts: u64,
end_ts: u64,
is_allow_bulk_mint: bool,
max_mint_count_addr: u64,
max_mint_count_phase: u64,
current_mint_count: u64,
participants: Table<address, u64>,
payment_types: VecMap<TypeName, u64>
}
struct RegisterPhasePromise {
phase_id: ID
}
struct PhaseCreatedEvent has copy, drop, store {
phase_id: ID,
name: Option<String>,
description: Option<String>,
is_allow_bulk_mint: bool,
max_mint_count_addr: u64,
max_mint_count_phase: u64
}
struct PhaseDestroyedEvent has copy, drop, store {
launch_id: ID,
phase_id: ID
}
struct PhaseRegisteredEvent has copy, drop, store {
launch_id: ID,
phase_id: ID
}
struct PaymentOptionAddedEvent has copy, drop, store {
phase_id: ID,
payment_type: TypeName,
payment_value: u64
}
struct PaymentOptionRemovedEvent has copy, drop, store {
phase_id: ID,
payment_type: TypeName
}
struct PaymentOptionUpdatedEvent has copy, drop, store {
phase_id: ID,
payment_type: TypeName,
payment_value: u64
}
enum PhaseKind has copy, drop, store {
PUBLIC { },
WHITELIST { count: u64 }
}
enum PhaseState has copy, drop, store {
CREATED { },
READY { },
ENDED { }
}
init(Arg0: PHASE, Arg1: &mut TxContext) {
B0:
0MoveLoc[0](Arg0: PHASE)
1CopyLoc[1](Arg1: &mut TxContext)
2Call package::claim<PHASE>(PHASE, &mut TxContext): Publisher
3MoveLoc[1](Arg1: &mut TxContext)
4FreezeRef
5Call tx_context::sender(&TxContext): address
6Call transfer::public_transfer<Publisher>(Publisher, address)
7Ret
}
public new<Ty0: store + key>(Arg0: &LaunchOperatorCap, Arg1: &Launch<Ty0>, Arg2: PhaseKind, Arg3: Option<String>, Arg4: Option<String>, Arg5: u64, Arg6: u64, Arg7: u64, Arg8: u64, Arg9: bool, Arg10: &mut TxContext): Phase<Ty0> * RegisterPhasePromise {
L11: loc0: Phase<Ty0>
L12: loc1: RegisterPhasePromise
B0:
0CopyLoc[0](Arg0: &LaunchOperatorCap)
1CopyLoc[1](Arg1: &Launch<Ty0>)
2Call launch::id<Ty0>(&Launch<Ty0>): ID
3Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
4MoveLoc[1](Arg1: &Launch<Ty0>)
5Call launch::assert_is_active_state<Ty0>(&Launch<Ty0>)
6CopyLoc[8](Arg8: u64)
7LdU64(0)
8Gt
9BrFalse(11)
B1:
10Branch(17)
B2:
11MoveLoc[10](Arg10: &mut TxContext)
12Pop
13MoveLoc[0](Arg0: &LaunchOperatorCap)
14Pop
15LdConst[4](u64: 20004)
16Abort
B3:
17CopyLoc[7](Arg7: u64)
18LdU64(0)
19Gt
20BrFalse(22)
B4:
21Branch(28)
B5:
22MoveLoc[10](Arg10: &mut TxContext)
23Pop
24MoveLoc[0](Arg0: &LaunchOperatorCap)
25Pop
26LdConst[3](u64: 20003)
27Abort
B6:
28CopyLoc[7](Arg7: u64)
29CopyLoc[8](Arg8: u64)
30Le
31BrFalse(33)
B7:
32Branch(39)
B8:
33MoveLoc[10](Arg10: &mut TxContext)
34Pop
35MoveLoc[0](Arg0: &LaunchOperatorCap)
36Pop
37LdConst[3](u64: 20003)
38Abort
B9:
39CopyLoc[6](Arg6: u64)
40CopyLoc[5](Arg5: u64)
41Gt
42BrFalse(44)
B10:
43Branch(50)
B11:
44MoveLoc[10](Arg10: &mut TxContext)
45Pop
46MoveLoc[0](Arg0: &LaunchOperatorCap)
47Pop
48LdConst[13](u64: 20013)
49Abort
B12:
50CopyLoc[10](Arg10: &mut TxContext)
51Call object::new(&mut TxContext): UID
52MoveLoc[2](Arg2: PhaseKind)
53PackVariant(VariantHandleIndex(0))
54MoveLoc[0](Arg0: &LaunchOperatorCap)
55Call launch::launch_operator_cap_launch_id(&LaunchOperatorCap): ID
56MoveLoc[3](Arg3: Option<String>)
57MoveLoc[4](Arg4: Option<String>)
58MoveLoc[5](Arg5: u64)
59MoveLoc[6](Arg6: u64)
60MoveLoc[9](Arg9: bool)
61MoveLoc[7](Arg7: u64)
62MoveLoc[8](Arg8: u64)
63LdU64(0)
64MoveLoc[10](Arg10: &mut TxContext)
65Call table::new<address, u64>(&mut TxContext): Table<address, u64>
66Call vec_map::empty<TypeName, u64>(): VecMap<TypeName, u64>
67PackGeneric[0](Phase<Ty0>)
68StLoc[11](loc0: Phase<Ty0>)
69ImmBorrowLoc[11](loc0: Phase<Ty0>)
70Call id<Ty0>(&Phase<Ty0>): ID
71Pack[2](RegisterPhasePromise)
72StLoc[12](loc1: RegisterPhasePromise)
73ImmBorrowLoc[11](loc0: Phase<Ty0>)
74Call id<Ty0>(&Phase<Ty0>): ID
75ImmBorrowLoc[11](loc0: Phase<Ty0>)
76ImmBorrowFieldGeneric[0](Phase.name: Option<String>)
77ReadRef
78ImmBorrowLoc[11](loc0: Phase<Ty0>)
79ImmBorrowFieldGeneric[1](Phase.description: Option<String>)
80ReadRef
81ImmBorrowLoc[11](loc0: Phase<Ty0>)
82ImmBorrowFieldGeneric[2](Phase.is_allow_bulk_mint: bool)
83ReadRef
84ImmBorrowLoc[11](loc0: Phase<Ty0>)
85ImmBorrowFieldGeneric[3](Phase.max_mint_count_addr: u64)
86ReadRef
87ImmBorrowLoc[11](loc0: Phase<Ty0>)
88ImmBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
89ReadRef
90Pack[3](PhaseCreatedEvent)
91Call event::emit<PhaseCreatedEvent>(PhaseCreatedEvent)
92MoveLoc[11](loc0: Phase<Ty0>)
93MoveLoc[12](loc1: RegisterPhasePromise)
94Ret
}
public new_phase_kind_public(): PhaseKind {
B0:
0PackVariant(VariantHandleIndex(1))
1Ret
}
public new_phase_kind_whitelist(): PhaseKind {
B0:
0LdU64(0)
1PackVariant(VariantHandleIndex(2))
2Ret
}
public register<Ty0: store + key>(Arg0: Phase<Ty0>, Arg1: RegisterPhasePromise, Arg2: &LaunchOperatorCap, Arg3: &mut Launch<Ty0>) {
L4: loc0: &PhaseState
L5: loc1: PhaseState
B0:
0MoveLoc[2](Arg2: &LaunchOperatorCap)
1CopyLoc[3](Arg3: &mut Launch<Ty0>)
2FreezeRef
3Call launch::id<Ty0>(&Launch<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5ImmBorrowLoc[0](Arg0: Phase<Ty0>)
6ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
7ReadRef
8StLoc[5](loc1: PhaseState)
9ImmBorrowLoc[5](loc1: PhaseState)
10StLoc[4](loc0: &PhaseState)
11CopyLoc[4](loc0: &PhaseState)
12VariantSwitch(VariantJumpTableIndex(0))
B1:
13MoveLoc[4](loc0: &PhaseState)
14UnpackVariantImmRef(VariantHandleIndex(0))
15MoveLoc[5](loc1: PhaseState)
16UnpackVariant(VariantHandleIndex(0))
17ImmBorrowLoc[0](Arg0: Phase<Ty0>)
18Call id<Ty0>(&Phase<Ty0>): ID
19ImmBorrowLoc[1](Arg1: RegisterPhasePromise)
20ImmBorrowField[6](RegisterPhasePromise.phase_id: ID)
21ReadRef
22Eq
23BrFalse(25)
B2:
24Branch(29)
B3:
25MoveLoc[3](Arg3: &mut Launch<Ty0>)
26Pop
27LdConst[6](u64: 20006)
28Abort
B4:
29ImmBorrowLoc[0](Arg0: Phase<Ty0>)
30ImmBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
31ReadRef
32CopyLoc[3](Arg3: &mut Launch<Ty0>)
33FreezeRef
34Call launch::supply<Ty0>(&Launch<Ty0>): u64
35Le
36BrFalse(38)
B5:
37Branch(42)
B6:
38MoveLoc[3](Arg3: &mut Launch<Ty0>)
39Pop
40LdConst[11](u64: 20011)
41Abort
B7:
42ImmBorrowLoc[0](Arg0: Phase<Ty0>)
43ImmBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
44Call vec_map::is_empty<TypeName, u64>(&VecMap<TypeName, u64>): bool
45Not
46BrFalse(48)
B8:
47Branch(64)
B9:
48MoveLoc[3](Arg3: &mut Launch<Ty0>)
49Pop
50LdConst[8](u64: 20008)
51Abort
B10:
52MoveLoc[3](Arg3: &mut Launch<Ty0>)
53Pop
54MoveLoc[4](loc0: &PhaseState)
55Pop
56LdConst[5](u64: 20005)
57Abort
B11:
58MoveLoc[3](Arg3: &mut Launch<Ty0>)
59Pop
60MoveLoc[4](loc0: &PhaseState)
61Pop
62LdConst[5](u64: 20005)
63Abort
B12:
64CopyLoc[3](Arg3: &mut Launch<Ty0>)
65ImmBorrowLoc[0](Arg0: Phase<Ty0>)
66Call id<Ty0>(&Phase<Ty0>): ID
67Call launch::register_phase<Ty0>(&mut Launch<Ty0>, ID)
68MoveLoc[1](Arg1: RegisterPhasePromise)
69Unpack[2](RegisterPhasePromise)
70Pop
71MoveLoc[3](Arg3: &mut Launch<Ty0>)
72FreezeRef
73Call launch::id<Ty0>(&Launch<Ty0>): ID
74ImmBorrowLoc[0](Arg0: Phase<Ty0>)
75Call id<Ty0>(&Phase<Ty0>): ID
76Pack[5](PhaseRegisteredEvent)
77Call event::emit<PhaseRegisteredEvent>(PhaseRegisteredEvent)
78PackVariant(VariantHandleIndex(3))
79MutBorrowLoc[0](Arg0: Phase<Ty0>)
80MutBorrowFieldGeneric[5](Phase.state: PhaseState)
81WriteRef
82MoveLoc[0](Arg0: Phase<Ty0>)
83Call transfer::share_object<Phase<Ty0>>(Phase<Ty0>)
84Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 13
Variant1 => jump 52
Variant2 => jump 58
}
}
public destroy<Ty0: store + key>(Arg0: Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: &mut Launch<Ty0>) {
L3: loc0: &PhaseState
L4: loc1: PhaseState
L5: loc2: Table<address, u64>
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1ImmBorrowLoc[0](Arg0: Phase<Ty0>)
2Call launch_id<Ty0>(&Phase<Ty0>): ID
3Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
4ImmBorrowLoc[0](Arg0: Phase<Ty0>)
5ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
6ReadRef
7StLoc[4](loc1: PhaseState)
8ImmBorrowLoc[4](loc1: PhaseState)
9StLoc[3](loc0: &PhaseState)
10CopyLoc[3](loc0: &PhaseState)
11VariantSwitch(VariantJumpTableIndex(0))
B1:
12MoveLoc[2](Arg2: &mut Launch<Ty0>)
13Pop
14MoveLoc[3](loc0: &PhaseState)
15UnpackVariantImmRef(VariantHandleIndex(0))
16MoveLoc[4](loc1: PhaseState)
17UnpackVariant(VariantHandleIndex(0))
18Branch(44)
B2:
19MoveLoc[3](loc0: &PhaseState)
20UnpackVariantImmRef(VariantHandleIndex(3))
21MoveLoc[4](loc1: PhaseState)
22UnpackVariant(VariantHandleIndex(3))
23MoveLoc[2](Arg2: &mut Launch<Ty0>)
24ImmBorrowLoc[0](Arg0: Phase<Ty0>)
25Call id<Ty0>(&Phase<Ty0>): ID
26Call launch::unregister_phase<Ty0>(&mut Launch<Ty0>, ID)
27ImmBorrowLoc[0](Arg0: Phase<Ty0>)
28ImmBorrowFieldGeneric[7](Phase.current_mint_count: u64)
29ReadRef
30LdU64(0)
31Eq
32BrFalse(34)
B3:
33Branch(44)
B4:
34LdConst[17](u64: 20017)
35Abort
B5:
36MoveLoc[3](loc0: &PhaseState)
37UnpackVariantImmRef(VariantHandleIndex(4))
38MoveLoc[4](loc1: PhaseState)
39UnpackVariant(VariantHandleIndex(4))
40MoveLoc[2](Arg2: &mut Launch<Ty0>)
41ImmBorrowLoc[0](Arg0: Phase<Ty0>)
42Call id<Ty0>(&Phase<Ty0>): ID
43Call launch::unregister_phase<Ty0>(&mut Launch<Ty0>, ID)
B6:
44ImmBorrowLoc[0](Arg0: Phase<Ty0>)
45Call launch_id<Ty0>(&Phase<Ty0>): ID
46ImmBorrowLoc[0](Arg0: Phase<Ty0>)
47Call id<Ty0>(&Phase<Ty0>): ID
48Pack[4](PhaseDestroyedEvent)
49Call event::emit<PhaseDestroyedEvent>(PhaseDestroyedEvent)
50MoveLoc[0](Arg0: Phase<Ty0>)
51UnpackGeneric[0](Phase<Ty0>)
52Pop
53StLoc[5](loc2: Table<address, u64>)
54Pop
55Pop
56Pop
57Pop
58Pop
59Pop
60Pop
61Pop
62Pop
63Pop
64Pop
65Call object::delete(UID)
66MoveLoc[5](loc2: Table<address, u64>)
67Call table::drop<address, u64>(Table<address, u64>)
68Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 12
Variant1 => jump 19
Variant2 => jump 36
}
}
public add_payment_type<Ty0: store + key, Ty1>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: u64) {
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5CopyLoc[0](Arg0: &mut Phase<Ty0>)
6ImmBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
7Call vec_map::size<TypeName, u64>(&VecMap<TypeName, u64>): u64
8LdConst[0](u64: 50)
9Lt
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut Phase<Ty0>)
13Pop
14LdConst[2](u64: 20002)
15Abort
B3:
16CopyLoc[0](Arg0: &mut Phase<Ty0>)
17MutBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
18Call type_name::get<Ty1>(): TypeName
19CopyLoc[2](Arg2: u64)
20Call vec_map::insert<TypeName, u64>(&mut VecMap<TypeName, u64>, TypeName, u64)
21MoveLoc[0](Arg0: &mut Phase<Ty0>)
22FreezeRef
23Call id<Ty0>(&Phase<Ty0>): ID
24Call type_name::get<Ty1>(): TypeName
25MoveLoc[2](Arg2: u64)
26Pack[6](PaymentOptionAddedEvent)
27Call event::emit<PaymentOptionAddedEvent>(PaymentOptionAddedEvent)
28Ret
}
public remove_payment_type<Ty0: store + key, Ty1>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap) {
L2: loc0: TypeName
L3: loc1: &mut VecMap<TypeName, u64>
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5CopyLoc[0](Arg0: &mut Phase<Ty0>)
6ImmBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
7Call vec_map::size<TypeName, u64>(&VecMap<TypeName, u64>): u64
8LdU64(1)
9Gt
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut Phase<Ty0>)
13Pop
14LdConst[8](u64: 20008)
15Abort
B3:
16CopyLoc[0](Arg0: &mut Phase<Ty0>)
17MutBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
18StLoc[3](loc1: &mut VecMap<TypeName, u64>)
19Call type_name::get<Ty1>(): TypeName
20StLoc[2](loc0: TypeName)
21MoveLoc[3](loc1: &mut VecMap<TypeName, u64>)
22ImmBorrowLoc[2](loc0: TypeName)
23Call vec_map::remove<TypeName, u64>(&mut VecMap<TypeName, u64>, &TypeName): TypeName * u64
24Pop
25Pop
26MoveLoc[0](Arg0: &mut Phase<Ty0>)
27FreezeRef
28Call id<Ty0>(&Phase<Ty0>): ID
29Call type_name::get<Ty1>(): TypeName
30Pack[7](PaymentOptionRemovedEvent)
31Call event::emit<PaymentOptionRemovedEvent>(PaymentOptionRemovedEvent)
32Ret
}
public update_payment_type<Ty0: store + key, Ty1>(Arg0: &mut Phase<Ty0>, Arg1: u64, Arg2: &LaunchOperatorCap) {
L3: loc0: &mut u64
L4: loc1: TypeName
B0:
0MoveLoc[2](Arg2: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5Call type_name::get<Ty1>(): TypeName
6StLoc[4](loc1: TypeName)
7CopyLoc[0](Arg0: &mut Phase<Ty0>)
8ImmBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
9ImmBorrowLoc[4](loc1: TypeName)
10Call vec_map::contains<TypeName, u64>(&VecMap<TypeName, u64>, &TypeName): bool
11BrFalse(13)
B1:
12Branch(17)
B2:
13MoveLoc[0](Arg0: &mut Phase<Ty0>)
14Pop
15LdConst[9](u64: 20009)
16Abort
B3:
17CopyLoc[0](Arg0: &mut Phase<Ty0>)
18MutBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
19ImmBorrowLoc[4](loc1: TypeName)
20Call vec_map::get_mut<TypeName, u64>(&mut VecMap<TypeName, u64>, &TypeName): &mut u64
21StLoc[3](loc0: &mut u64)
22CopyLoc[1](Arg1: u64)
23MoveLoc[3](loc0: &mut u64)
24WriteRef
25MoveLoc[0](Arg0: &mut Phase<Ty0>)
26FreezeRef
27Call id<Ty0>(&Phase<Ty0>): ID
28MoveLoc[4](loc1: TypeName)
29MoveLoc[1](Arg1: u64)
30Pack[8](PaymentOptionUpdatedEvent)
31Call event::emit<PaymentOptionUpdatedEvent>(PaymentOptionUpdatedEvent)
32Ret
}
public set_name<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: String) {
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5MoveLoc[0](Arg0: &mut Phase<Ty0>)
6MutBorrowFieldGeneric[0](Phase.name: Option<String>)
7MoveLoc[2](Arg2: String)
8Call option::swap_or_fill<String>(&mut Option<String>, String): Option<String>
9Pop
10Ret
}
public set_description<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: String) {
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5MoveLoc[0](Arg0: &mut Phase<Ty0>)
6MutBorrowFieldGeneric[1](Phase.description: Option<String>)
7MoveLoc[2](Arg2: String)
8Call option::swap_or_fill<String>(&mut Option<String>, String): Option<String>
9Pop
10Ret
}
public set_is_allow_bulk_mint<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: bool) {
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5MoveLoc[2](Arg2: bool)
6MoveLoc[0](Arg0: &mut Phase<Ty0>)
7MutBorrowFieldGeneric[2](Phase.is_allow_bulk_mint: bool)
8WriteRef
9Ret
}
public set_max_mint_count_addr<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: u64) {
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5CopyLoc[2](Arg2: u64)
6CopyLoc[0](Arg0: &mut Phase<Ty0>)
7ImmBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
8ReadRef
9Le
10BrFalse(12)
B1:
11Branch(16)
B2:
12MoveLoc[0](Arg0: &mut Phase<Ty0>)
13Pop
14LdConst[3](u64: 20003)
15Abort
B3:
16MoveLoc[2](Arg2: u64)
17MoveLoc[0](Arg0: &mut Phase<Ty0>)
18MutBorrowFieldGeneric[3](Phase.max_mint_count_addr: u64)
19WriteRef
20Ret
}
public set_max_mint_count_phase<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: u64, Arg3: &mut Launch<Ty0>) {
B0:
0CopyLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5MoveLoc[1](Arg1: &LaunchOperatorCap)
6CopyLoc[3](Arg3: &mut Launch<Ty0>)
7FreezeRef
8Call launch::id<Ty0>(&Launch<Ty0>): ID
9Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
10CopyLoc[2](Arg2: u64)
11MoveLoc[3](Arg3: &mut Launch<Ty0>)
12FreezeRef
13Call launch::items<Ty0>(&Launch<Ty0>): &TableVec<Ty0>
14Call table_vec::length<Ty0>(&TableVec<Ty0>): u64
15Le
16BrFalse(18)
B1:
17Branch(22)
B2:
18MoveLoc[0](Arg0: &mut Phase<Ty0>)
19Pop
20LdConst[1](u64: 20001)
21Abort
B3:
22CopyLoc[2](Arg2: u64)
23CopyLoc[0](Arg0: &mut Phase<Ty0>)
24ImmBorrowFieldGeneric[3](Phase.max_mint_count_addr: u64)
25ReadRef
26Gt
27BrFalse(29)
B4:
28Branch(33)
B5:
29MoveLoc[0](Arg0: &mut Phase<Ty0>)
30Pop
31LdConst[7](u64: 20007)
32Abort
B6:
33MoveLoc[2](Arg2: u64)
34MoveLoc[0](Arg0: &mut Phase<Ty0>)
35MutBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
36WriteRef
37Ret
}
public set_start_ts<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: u64, Arg3: &Clock) {
L4: loc0: &PhaseState
L5: loc1: PhaseState
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5CopyLoc[0](Arg0: &mut Phase<Ty0>)
6ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
7ReadRef
8StLoc[5](loc1: PhaseState)
9ImmBorrowLoc[5](loc1: PhaseState)
10StLoc[4](loc0: &PhaseState)
11CopyLoc[4](loc0: &PhaseState)
12VariantSwitch(VariantJumpTableIndex(0))
B1:
13MoveLoc[0](Arg0: &mut Phase<Ty0>)
14Pop
15MoveLoc[3](Arg3: &Clock)
16Pop
17MoveLoc[4](loc0: &PhaseState)
18Pop
19LdConst[5](u64: 20005)
20Abort
B2:
21MoveLoc[4](loc0: &PhaseState)
22UnpackVariantImmRef(VariantHandleIndex(3))
23MoveLoc[5](loc1: PhaseState)
24UnpackVariant(VariantHandleIndex(3))
25CopyLoc[2](Arg2: u64)
26MoveLoc[3](Arg3: &Clock)
27Call clock::timestamp_ms(&Clock): u64
28Gt
29BrFalse(31)
B3:
30Branch(35)
B4:
31MoveLoc[0](Arg0: &mut Phase<Ty0>)
32Pop
33LdConst[15](u64: 20015)
34Abort
B5:
35CopyLoc[2](Arg2: u64)
36CopyLoc[0](Arg0: &mut Phase<Ty0>)
37ImmBorrowFieldGeneric[8](Phase.end_ts: u64)
38ReadRef
39Lt
40BrFalse(42)
B6:
41Branch(54)
B7:
42MoveLoc[0](Arg0: &mut Phase<Ty0>)
43Pop
44LdConst[13](u64: 20013)
45Abort
B8:
46MoveLoc[0](Arg0: &mut Phase<Ty0>)
47Pop
48MoveLoc[3](Arg3: &Clock)
49Pop
50MoveLoc[4](loc0: &PhaseState)
51Pop
52LdConst[5](u64: 20005)
53Abort
B9:
54MoveLoc[2](Arg2: u64)
55MoveLoc[0](Arg0: &mut Phase<Ty0>)
56MutBorrowFieldGeneric[9](Phase.start_ts: u64)
57WriteRef
58Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 13
Variant1 => jump 21
Variant2 => jump 46
}
}
public set_end_ts<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: u64, Arg3: &Clock) {
L4: loc0: &PhaseState
L5: loc1: PhaseState
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5CopyLoc[0](Arg0: &mut Phase<Ty0>)
6ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
7ReadRef
8StLoc[5](loc1: PhaseState)
9ImmBorrowLoc[5](loc1: PhaseState)
10StLoc[4](loc0: &PhaseState)
11CopyLoc[4](loc0: &PhaseState)
12VariantSwitch(VariantJumpTableIndex(0))
B1:
13MoveLoc[0](Arg0: &mut Phase<Ty0>)
14Pop
15MoveLoc[3](Arg3: &Clock)
16Pop
17MoveLoc[4](loc0: &PhaseState)
18Pop
19LdConst[5](u64: 20005)
20Abort
B2:
21MoveLoc[4](loc0: &PhaseState)
22UnpackVariantImmRef(VariantHandleIndex(3))
23MoveLoc[5](loc1: PhaseState)
24UnpackVariant(VariantHandleIndex(3))
25CopyLoc[2](Arg2: u64)
26MoveLoc[3](Arg3: &Clock)
27Call clock::timestamp_ms(&Clock): u64
28Gt
29BrFalse(31)
B3:
30Branch(35)
B4:
31MoveLoc[0](Arg0: &mut Phase<Ty0>)
32Pop
33LdConst[15](u64: 20015)
34Abort
B5:
35CopyLoc[2](Arg2: u64)
36CopyLoc[0](Arg0: &mut Phase<Ty0>)
37ImmBorrowFieldGeneric[9](Phase.start_ts: u64)
38ReadRef
39Gt
40BrFalse(42)
B6:
41Branch(54)
B7:
42MoveLoc[0](Arg0: &mut Phase<Ty0>)
43Pop
44LdConst[14](u64: 20014)
45Abort
B8:
46MoveLoc[0](Arg0: &mut Phase<Ty0>)
47Pop
48MoveLoc[3](Arg3: &Clock)
49Pop
50MoveLoc[4](loc0: &PhaseState)
51Pop
52LdConst[5](u64: 20005)
53Abort
B9:
54MoveLoc[2](Arg2: u64)
55MoveLoc[0](Arg0: &mut Phase<Ty0>)
56MutBorrowFieldGeneric[8](Phase.end_ts: u64)
57WriteRef
58Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 13
Variant1 => jump 21
Variant2 => jump 46
}
}
public set_ended_state<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &LaunchOperatorCap, Arg2: &Clock) {
L3: loc0: bool
L4: loc1: &PhaseState
L5: loc2: PhaseState
B0:
0MoveLoc[1](Arg1: &LaunchOperatorCap)
1CopyLoc[0](Arg0: &mut Phase<Ty0>)
2FreezeRef
3Call launch_id<Ty0>(&Phase<Ty0>): ID
4Call launch::launch_operator_cap_authorize(&LaunchOperatorCap, ID)
5CopyLoc[0](Arg0: &mut Phase<Ty0>)
6ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
7ReadRef
8StLoc[5](loc2: PhaseState)
9ImmBorrowLoc[5](loc2: PhaseState)
10StLoc[4](loc1: &PhaseState)
11CopyLoc[4](loc1: &PhaseState)
12VariantSwitch(VariantJumpTableIndex(0))
B1:
13MoveLoc[0](Arg0: &mut Phase<Ty0>)
14Pop
15MoveLoc[2](Arg2: &Clock)
16Pop
17MoveLoc[4](loc1: &PhaseState)
18Pop
19LdConst[5](u64: 20005)
20Abort
B2:
21MoveLoc[4](loc1: &PhaseState)
22UnpackVariantImmRef(VariantHandleIndex(3))
23MoveLoc[5](loc2: PhaseState)
24UnpackVariant(VariantHandleIndex(3))
25MoveLoc[2](Arg2: &Clock)
26Call clock::timestamp_ms(&Clock): u64
27CopyLoc[0](Arg0: &mut Phase<Ty0>)
28ImmBorrowFieldGeneric[8](Phase.end_ts: u64)
29ReadRef
30Gt
31BrFalse(35)
B3:
32LdTrue
33StLoc[3](loc0: bool)
34Branch(43)
B4:
35CopyLoc[0](Arg0: &mut Phase<Ty0>)
36ImmBorrowFieldGeneric[7](Phase.current_mint_count: u64)
37ReadRef
38CopyLoc[0](Arg0: &mut Phase<Ty0>)
39ImmBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
40ReadRef
41Eq
42StLoc[3](loc0: bool)
B5:
43MoveLoc[3](loc0: bool)
44BrFalse(46)
B6:
45Branch(58)
B7:
46MoveLoc[0](Arg0: &mut Phase<Ty0>)
47Pop
48LdConst[12](u64: 20012)
49Abort
B8:
50MoveLoc[0](Arg0: &mut Phase<Ty0>)
51Pop
52MoveLoc[2](Arg2: &Clock)
53Pop
54MoveLoc[4](loc1: &PhaseState)
55Pop
56LdConst[5](u64: 20005)
57Abort
B9:
58PackVariant(VariantHandleIndex(4))
59MoveLoc[0](Arg0: &mut Phase<Ty0>)
60MutBorrowFieldGeneric[5](Phase.state: PhaseState)
61WriteRef
62Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 13
Variant1 => jump 21
Variant2 => jump 50
}
}
public(friend) participant_mint_count<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: address): u64 {
B0:
0CopyLoc[0](Arg0: &mut Phase<Ty0>)
1ImmBorrowFieldGeneric[10](Phase.participants: Table<address, u64>)
2CopyLoc[1](Arg1: address)
3Call table::contains<address, u64>(&Table<address, u64>, address): bool
4Not
5BrFalse(11)
B1:
6CopyLoc[0](Arg0: &mut Phase<Ty0>)
7MutBorrowFieldGeneric[10](Phase.participants: Table<address, u64>)
8CopyLoc[1](Arg1: address)
9LdU64(0)
10Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
B2:
11MoveLoc[0](Arg0: &mut Phase<Ty0>)
12ImmBorrowFieldGeneric[10](Phase.participants: Table<address, u64>)
13MoveLoc[1](Arg1: address)
14Call table::borrow<address, u64>(&Table<address, u64>, address): &u64
15ReadRef
16Ret
}
public(friend) increment_mint_count<Ty0: store + key>(Arg0: &mut Phase<Ty0>, Arg1: &TxContext) {
L2: loc0: &mut u64
B0:
0CopyLoc[0](Arg0: &mut Phase<Ty0>)
1ImmBorrowFieldGeneric[10](Phase.participants: Table<address, u64>)
2CopyLoc[1](Arg1: &TxContext)
3Call tx_context::sender(&TxContext): address
4Call table::contains<address, u64>(&Table<address, u64>, address): bool
5Not
6BrFalse(13)
B1:
7CopyLoc[0](Arg0: &mut Phase<Ty0>)
8MutBorrowFieldGeneric[10](Phase.participants: Table<address, u64>)
9CopyLoc[1](Arg1: &TxContext)
10Call tx_context::sender(&TxContext): address
11LdU64(0)
12Call table::add<address, u64>(&mut Table<address, u64>, address, u64)
B2:
13CopyLoc[0](Arg0: &mut Phase<Ty0>)
14MutBorrowFieldGeneric[10](Phase.participants: Table<address, u64>)
15MoveLoc[1](Arg1: &TxContext)
16Call tx_context::sender(&TxContext): address
17Call table::borrow_mut<address, u64>(&mut Table<address, u64>, address): &mut u64
18StLoc[2](loc0: &mut u64)
19CopyLoc[2](loc0: &mut u64)
20ReadRef
21LdU64(1)
22Add
23MoveLoc[2](loc0: &mut u64)
24WriteRef
25CopyLoc[0](Arg0: &mut Phase<Ty0>)
26ImmBorrowFieldGeneric[7](Phase.current_mint_count: u64)
27ReadRef
28LdU64(1)
29Add
30MoveLoc[0](Arg0: &mut Phase<Ty0>)
31MutBorrowFieldGeneric[7](Phase.current_mint_count: u64)
32WriteRef
33Ret
}
public(friend) increment_whitelist_count<Ty0: store + key>(Arg0: &mut Phase<Ty0>) {
L1: loc0: &PhaseKind
L2: loc1: &mut PhaseKind
L3: loc2: &mut u64
B0:
0MoveLoc[0](Arg0: &mut Phase<Ty0>)
1MutBorrowFieldGeneric[11](Phase.kind: PhaseKind)
2StLoc[2](loc1: &mut PhaseKind)
3CopyLoc[2](loc1: &mut PhaseKind)
4FreezeRef
5StLoc[1](loc0: &PhaseKind)
6CopyLoc[1](loc0: &PhaseKind)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[2](loc1: &mut PhaseKind)
9Pop
10MoveLoc[1](loc0: &PhaseKind)
11Pop
12LdConst[10](u64: 20010)
13Abort
B2:
14MoveLoc[1](loc0: &PhaseKind)
15UnpackVariantImmRef(VariantHandleIndex(2))
16Pop
17MoveLoc[2](loc1: &mut PhaseKind)
18UnpackVariantMutRef(VariantHandleIndex(2))
19StLoc[3](loc2: &mut u64)
20CopyLoc[3](loc2: &mut u64)
21ReadRef
22LdU64(1)
23Add
24MoveLoc[3](loc2: &mut u64)
25WriteRef
26Ret
Jump tables:
[0]: variant_switch PhaseKind {
Variant0 => jump 8
Variant1 => jump 14
}
}
public(friend) remaining_mint_count<Ty0: store + key>(Arg0: &Phase<Ty0>): u64 {
B0:
0CopyLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
2ReadRef
3MoveLoc[0](Arg0: &Phase<Ty0>)
4ImmBorrowFieldGeneric[7](Phase.current_mint_count: u64)
5ReadRef
6Sub
7Ret
}
public is_public_kind<Ty0: store + key>(Arg0: &Phase<Ty0>): bool {
L1: loc0: bool
L2: loc1: &PhaseKind
L3: loc2: PhaseKind
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[11](Phase.kind: PhaseKind)
2ReadRef
3StLoc[3](loc2: PhaseKind)
4ImmBorrowLoc[3](loc2: PhaseKind)
5StLoc[2](loc1: &PhaseKind)
6CopyLoc[2](loc1: &PhaseKind)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[2](loc1: &PhaseKind)
9UnpackVariantImmRef(VariantHandleIndex(1))
10MoveLoc[3](loc2: PhaseKind)
11UnpackVariant(VariantHandleIndex(1))
12LdTrue
13StLoc[1](loc0: bool)
14Branch(19)
B2:
15MoveLoc[2](loc1: &PhaseKind)
16Pop
17LdFalse
18StLoc[1](loc0: bool)
B3:
19MoveLoc[1](loc0: bool)
20Ret
Jump tables:
[0]: variant_switch PhaseKind {
Variant0 => jump 8
Variant1 => jump 15
}
}
public is_whitelist_kind<Ty0: store + key>(Arg0: &Phase<Ty0>): bool {
L1: loc0: bool
L2: loc1: &PhaseKind
L3: loc2: PhaseKind
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[11](Phase.kind: PhaseKind)
2ReadRef
3StLoc[3](loc2: PhaseKind)
4ImmBorrowLoc[3](loc2: PhaseKind)
5StLoc[2](loc1: &PhaseKind)
6CopyLoc[2](loc1: &PhaseKind)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[2](loc1: &PhaseKind)
9Pop
10LdFalse
11StLoc[1](loc0: bool)
12Branch(21)
B2:
13MoveLoc[2](loc1: &PhaseKind)
14UnpackVariantImmRef(VariantHandleIndex(2))
15Pop
16MoveLoc[3](loc2: PhaseKind)
17UnpackVariant(VariantHandleIndex(2))
18Pop
19LdTrue
20StLoc[1](loc0: bool)
B3:
21MoveLoc[1](loc0: bool)
22Ret
Jump tables:
[0]: variant_switch PhaseKind {
Variant0 => jump 8
Variant1 => jump 13
}
}
public is_created_state<Ty0: store + key>(Arg0: &Phase<Ty0>): bool {
L1: loc0: bool
L2: loc1: &PhaseState
L3: loc2: PhaseState
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
2ReadRef
3StLoc[3](loc2: PhaseState)
4ImmBorrowLoc[3](loc2: PhaseState)
5StLoc[2](loc1: &PhaseState)
6CopyLoc[2](loc1: &PhaseState)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[2](loc1: &PhaseState)
9UnpackVariantImmRef(VariantHandleIndex(0))
10MoveLoc[3](loc2: PhaseState)
11UnpackVariant(VariantHandleIndex(0))
12LdTrue
13StLoc[1](loc0: bool)
14Branch(24)
B2:
15MoveLoc[2](loc1: &PhaseState)
16Pop
17LdFalse
18StLoc[1](loc0: bool)
19Branch(24)
B3:
20MoveLoc[2](loc1: &PhaseState)
21Pop
22LdFalse
23StLoc[1](loc0: bool)
B4:
24MoveLoc[1](loc0: bool)
25Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 8
Variant1 => jump 15
Variant2 => jump 20
}
}
public is_ready_state<Ty0: store + key>(Arg0: &Phase<Ty0>): bool {
L1: loc0: bool
L2: loc1: &PhaseState
L3: loc2: PhaseState
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
2ReadRef
3StLoc[3](loc2: PhaseState)
4ImmBorrowLoc[3](loc2: PhaseState)
5StLoc[2](loc1: &PhaseState)
6CopyLoc[2](loc1: &PhaseState)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[2](loc1: &PhaseState)
9Pop
10LdFalse
11StLoc[1](loc0: bool)
12Branch(24)
B2:
13MoveLoc[2](loc1: &PhaseState)
14UnpackVariantImmRef(VariantHandleIndex(3))
15MoveLoc[3](loc2: PhaseState)
16UnpackVariant(VariantHandleIndex(3))
17LdTrue
18StLoc[1](loc0: bool)
19Branch(24)
B3:
20MoveLoc[2](loc1: &PhaseState)
21Pop
22LdFalse
23StLoc[1](loc0: bool)
B4:
24MoveLoc[1](loc0: bool)
25Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 8
Variant1 => jump 13
Variant2 => jump 20
}
}
public is_ended_state<Ty0: store + key>(Arg0: &Phase<Ty0>): bool {
L1: loc0: bool
L2: loc1: &PhaseState
L3: loc2: PhaseState
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
2ReadRef
3StLoc[3](loc2: PhaseState)
4ImmBorrowLoc[3](loc2: PhaseState)
5StLoc[2](loc1: &PhaseState)
6CopyLoc[2](loc1: &PhaseState)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[2](loc1: &PhaseState)
9Pop
10LdFalse
11StLoc[1](loc0: bool)
12Branch(24)
B2:
13MoveLoc[2](loc1: &PhaseState)
14Pop
15LdFalse
16StLoc[1](loc0: bool)
17Branch(24)
B3:
18MoveLoc[2](loc1: &PhaseState)
19UnpackVariantImmRef(VariantHandleIndex(4))
20MoveLoc[3](loc2: PhaseState)
21UnpackVariant(VariantHandleIndex(4))
22LdTrue
23StLoc[1](loc0: bool)
B4:
24MoveLoc[1](loc0: bool)
25Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 8
Variant1 => jump 13
Variant2 => jump 18
}
}
public id<Ty0: store + key>(Arg0: &Phase<Ty0>): ID {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[12](Phase.id: UID)
2Call object::uid_to_inner(&UID): ID
3Ret
}
public current_mint_count<Ty0: store + key>(Arg0: &Phase<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[7](Phase.current_mint_count: u64)
2ReadRef
3Ret
}
public launch_id<Ty0: store + key>(Arg0: &Phase<Ty0>): ID {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[13](Phase.launch_id: ID)
2ReadRef
3Ret
}
public name<Ty0: store + key>(Arg0: &Phase<Ty0>): Option<String> {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[0](Phase.name: Option<String>)
2ReadRef
3Ret
}
public description<Ty0: store + key>(Arg0: &Phase<Ty0>): Option<String> {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[1](Phase.description: Option<String>)
2ReadRef
3Ret
}
public is_allow_bulk_mint<Ty0: store + key>(Arg0: &Phase<Ty0>): bool {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[2](Phase.is_allow_bulk_mint: bool)
2ReadRef
3Ret
}
public max_mint_count_addr<Ty0: store + key>(Arg0: &Phase<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[3](Phase.max_mint_count_addr: u64)
2ReadRef
3Ret
}
public max_mint_count_phase<Ty0: store + key>(Arg0: &Phase<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
2ReadRef
3Ret
}
public payment_types<Ty0: store + key>(Arg0: &Phase<Ty0>): &VecMap<TypeName, u64> {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[6](Phase.payment_types: VecMap<TypeName, u64>)
2Ret
}
public assert_is_mintable<Ty0: store + key>(Arg0: &Phase<Ty0>, Arg1: &Clock) {
L2: loc0: bool
L3: loc1: &PhaseState
L4: loc2: PhaseState
B0:
0CopyLoc[0](Arg0: &Phase<Ty0>)
1ImmBorrowFieldGeneric[5](Phase.state: PhaseState)
2ReadRef
3StLoc[4](loc2: PhaseState)
4ImmBorrowLoc[4](loc2: PhaseState)
5StLoc[3](loc1: &PhaseState)
6CopyLoc[3](loc1: &PhaseState)
7VariantSwitch(VariantJumpTableIndex(0))
B1:
8MoveLoc[0](Arg0: &Phase<Ty0>)
9Pop
10MoveLoc[1](Arg1: &Clock)
11Pop
12MoveLoc[3](loc1: &PhaseState)
13Pop
14LdConst[5](u64: 20005)
15Abort
B2:
16MoveLoc[3](loc1: &PhaseState)
17UnpackVariantImmRef(VariantHandleIndex(3))
18MoveLoc[4](loc2: PhaseState)
19UnpackVariant(VariantHandleIndex(3))
20CopyLoc[1](Arg1: &Clock)
21Call clock::timestamp_ms(&Clock): u64
22CopyLoc[0](Arg0: &Phase<Ty0>)
23ImmBorrowFieldGeneric[9](Phase.start_ts: u64)
24ReadRef
25Ge
26BrFalse(35)
B3:
27MoveLoc[1](Arg1: &Clock)
28Call clock::timestamp_ms(&Clock): u64
29CopyLoc[0](Arg0: &Phase<Ty0>)
30ImmBorrowFieldGeneric[8](Phase.end_ts: u64)
31ReadRef
32Lt
33StLoc[2](loc0: bool)
34Branch(39)
B4:
35MoveLoc[1](Arg1: &Clock)
36Pop
37LdFalse
38StLoc[2](loc0: bool)
B5:
39MoveLoc[2](loc0: bool)
40BrFalse(42)
B6:
41Branch(46)
B7:
42MoveLoc[0](Arg0: &Phase<Ty0>)
43Pop
44LdConst[19](u64: 20019)
45Abort
B8:
46CopyLoc[0](Arg0: &Phase<Ty0>)
47ImmBorrowFieldGeneric[7](Phase.current_mint_count: u64)
48ReadRef
49MoveLoc[0](Arg0: &Phase<Ty0>)
50ImmBorrowFieldGeneric[4](Phase.max_mint_count_phase: u64)
51ReadRef
52Lt
53BrFalse(55)
B9:
54Branch(65)
B10:
55LdConst[18](u64: 20018)
56Abort
B11:
57MoveLoc[0](Arg0: &Phase<Ty0>)
58Pop
59MoveLoc[1](Arg1: &Clock)
60Pop
61MoveLoc[3](loc1: &PhaseState)
62Pop
63LdConst[5](u64: 20005)
64Abort
B12:
65Ret
Jump tables:
[0]: variant_switch PhaseState {
Variant0 => jump 8
Variant1 => jump 16
Variant2 => jump 57
}
}
public assert_is_public<Ty0: store + key>(Arg0: &Phase<Ty0>) {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1Call is_public_kind<Ty0>(&Phase<Ty0>): bool
2BrFalse(4)
B1:
3Branch(6)
B2:
4LdConst[16](u64: 20016)
5Abort
B3:
6Ret
}
public assert_is_whitelist<Ty0: store + key>(Arg0: &Phase<Ty0>) {
B0:
0MoveLoc[0](Arg0: &Phase<Ty0>)
1Call is_whitelist_kind<Ty0>(&Phase<Ty0>): bool
2BrFalse(4)
B1:
3Branch(6)
B2:
4LdConst[10](u64: 20010)
5Abort
B3:
6Ret
}
Constants [
0 => u64: 50
1 => u64: 20001
2 => u64: 20002
3 => u64: 20003
4 => u64: 20004
5 => u64: 20005
6 => u64: 20006
7 => u64: 20007
8 => u64: 20008
9 => u64: 20009
10 => u64: 20010
11 => u64: 20011
12 => u64: 20012
13 => u64: 20013
14 => u64: 20014
15 => u64: 20015
16 => u64: 20016
17 => u64: 20017
18 => u64: 20018
19 => u64: 20019
]
}