Search by name, SuiNS, address, digest, object ID, coin type or checkpoint.

API

mint_pass

Module0x34a2…c82c
Move path
0xbc3d…e5f9::mint_pass
Functions
1212 public, 0 entry
Structs
3
Friend modules
None
mint_pass

Bytecode195 lines

The on-chain disassembly. Offsets are bytecode positions within each function.

// Move bytecode v6
module bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9.mint_pass {
use bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9::mint_cap;
use 16c5f17f2d55584a6e6daa442ccf83b4530d10546a8e7dedda9ba324e012fc40::frozen_publisher;
use 16c5f17f2d55584a6e6daa442ccf83b4530d10546a8e7dedda9ba324e012fc40::witness;
use 859eb18bd5b5e8cc32deb6dfb1c39941008ab3c6e27f0b8ce2364be7102bb7cb::utils_supply;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::bcs;
use 0000000000000000000000000000000000000000000000000000000000000002::display;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
 
struct Witness has drop {
dummy_field: bool
}
 
struct MintPass<phantom Ty0> has store, key {
id: UID,
supply: Supply
}
 
struct MetadataDfKey has copy, drop, store {
dummy_field: bool
}
 
public new<Ty0: key>(Arg0: &mut MintCap<Ty0>, Arg1: u64, Arg2: &mut TxContext): MintPass<Ty0> {
B0:
0CopyLoc[0](Arg0: &mut MintCap<Ty0>)
1FreezeRef
2Call mint_cap::assert_limited<Ty0>(&MintCap<Ty0>)
3MoveLoc[0](Arg0: &mut MintCap<Ty0>)
4CopyLoc[1](Arg1: u64)
5Call mint_cap::increment_supply<Ty0>(&mut MintCap<Ty0>, u64)
6MoveLoc[2](Arg2: &mut TxContext)
7Call object::new(&mut TxContext): UID
8MoveLoc[1](Arg1: u64)
9Call utils_supply::new(u64): Supply
10PackGeneric[0](MintPass<Ty0>)
11Ret
}
 
public new_<Ty0>(Arg0: &MintCap<Ty0>, Arg1: u64, Arg2: &mut TxContext): MintPass<Ty0> {
B0:
0MoveLoc[0](Arg0: &MintCap<Ty0>)
1Call mint_cap::assert_unlimited<Ty0>(&MintCap<Ty0>)
2MoveLoc[2](Arg2: &mut TxContext)
3Call object::new(&mut TxContext): UID
4MoveLoc[1](Arg1: u64)
5Call utils_supply::new(u64): Supply
6PackGeneric[0](MintPass<Ty0>)
7Ret
}
 
public new_with_metadata<Ty0: key>(Arg0: &mut MintCap<Ty0>, Arg1: u64, Arg2: &vector<u8>, Arg3: &mut TxContext): MintPass<Ty0> {
L4: loc0: BCS
L5: loc1: MintPass<Ty0>
B0:
0MoveLoc[2](Arg2: &vector<u8>)
1ReadRef
2Call bcs::new(vector<u8>): BCS
3StLoc[4](loc0: BCS)
4MoveLoc[0](Arg0: &mut MintCap<Ty0>)
5MoveLoc[1](Arg1: u64)
6MoveLoc[3](Arg3: &mut TxContext)
7Call new<Ty0>(&mut MintCap<Ty0>, u64, &mut TxContext): MintPass<Ty0>
8StLoc[5](loc1: MintPass<Ty0>)
9MutBorrowLoc[5](loc1: MintPass<Ty0>)
10MutBorrowFieldGeneric[0](MintPass.id: UID)
11LdFalse
12Pack[2](MetadataDfKey)
13MoveLoc[4](loc0: BCS)
14Call dynamic_field::add<MetadataDfKey, BCS>(&mut UID, MetadataDfKey, BCS)
15MoveLoc[5](loc1: MintPass<Ty0>)
16Ret
}
 
public new_with_metadata_<Ty0: key>(Arg0: &MintCap<Ty0>, Arg1: u64, Arg2: &vector<u8>, Arg3: &mut TxContext): MintPass<Ty0> {
L4: loc0: BCS
L5: loc1: MintPass<Ty0>
B0:
0MoveLoc[2](Arg2: &vector<u8>)
1ReadRef
2Call bcs::new(vector<u8>): BCS
3StLoc[4](loc0: BCS)
4MoveLoc[0](Arg0: &MintCap<Ty0>)
5MoveLoc[1](Arg1: u64)
6MoveLoc[3](Arg3: &mut TxContext)
7Call new_<Ty0>(&MintCap<Ty0>, u64, &mut TxContext): MintPass<Ty0>
8StLoc[5](loc1: MintPass<Ty0>)
9MutBorrowLoc[5](loc1: MintPass<Ty0>)
10MutBorrowFieldGeneric[0](MintPass.id: UID)
11LdFalse
12Pack[2](MetadataDfKey)
13MoveLoc[4](loc0: BCS)
14Call dynamic_field::add<MetadataDfKey, BCS>(&mut UID, MetadataDfKey, BCS)
15MoveLoc[5](loc1: MintPass<Ty0>)
16Ret
}
 
public supply<Ty0>(Arg0: &MintPass<Ty0>): u64 {
B0:
0MoveLoc[0](Arg0: &MintPass<Ty0>)
1ImmBorrowFieldGeneric[1](MintPass.supply: Supply)
2Call utils_supply::get_current(&Supply): u64
3Ret
}
 
public get_supply<Ty0>(Arg0: &MintPass<Ty0>): &Supply {
B0:
0MoveLoc[0](Arg0: &MintPass<Ty0>)
1ImmBorrowFieldGeneric[1](MintPass.supply: Supply)
2Ret
}
 
public borrow_supply<Ty0>(Arg0: &MintPass<Ty0>): &Supply {
B0:
0MoveLoc[0](Arg0: &MintPass<Ty0>)
1ImmBorrowFieldGeneric[1](MintPass.supply: Supply)
2Ret
}
 
public increment_supply<Ty0>(Arg0: &mut MintPass<Ty0>, Arg1: u64) {
B0:
0MoveLoc[0](Arg0: &mut MintPass<Ty0>)
1MutBorrowFieldGeneric[1](MintPass.supply: Supply)
2MoveLoc[1](Arg1: u64)
3Call utils_supply::increment(&mut Supply, u64)
4Ret
}
 
public split<Ty0: key>(Arg0: &mut MintPass<Ty0>, Arg1: u64, Arg2: &mut TxContext): MintPass<Ty0> {
B0:
0MoveLoc[0](Arg0: &mut MintPass<Ty0>)
1CopyLoc[1](Arg1: u64)
2Call increment_supply<Ty0>(&mut MintPass<Ty0>, u64)
3MoveLoc[2](Arg2: &mut TxContext)
4Call object::new(&mut TxContext): UID
5MoveLoc[1](Arg1: u64)
6Call utils_supply::new(u64): Supply
7PackGeneric[0](MintPass<Ty0>)
8Ret
}
 
public merge<Ty0: key>(Arg0: &mut MintPass<Ty0>, Arg1: MintPass<Ty0>) {
L2: loc0: UID
L3: loc1: Supply
B0:
0MoveLoc[1](Arg1: MintPass<Ty0>)
1UnpackGeneric[0](MintPass<Ty0>)
2StLoc[3](loc1: Supply)
3StLoc[2](loc0: UID)
4MoveLoc[0](Arg0: &mut MintPass<Ty0>)
5MutBorrowFieldGeneric[1](MintPass.supply: Supply)
6MoveLoc[3](loc1: Supply)
7Call utils_supply::merge(&mut Supply, Supply)
8MoveLoc[2](loc0: UID)
9Call object::delete(UID)
10Ret
}
 
public delete_mint_pass<Ty0>(Arg0: MintPass<Ty0>) {
B0:
0MoveLoc[0](Arg0: MintPass<Ty0>)
1UnpackGeneric[0](MintPass<Ty0>)
2Pop
3Call object::delete(UID)
4Ret
}
 
public new_display<Ty0: store + key>(Arg0: Witness<Ty0>, Arg1: &FrozenPublisher, Arg2: &mut TxContext): Display<MintPass<Ty0>> {
L3: loc0: Display<MintPass<Ty0>>
B0:
0LdFalse
1Pack[0](Witness)
2MoveLoc[1](Arg1: &FrozenPublisher)
3MoveLoc[2](Arg2: &mut TxContext)
4Call frozen_publisher::new_display<Witness, MintPass<Ty0>>(Witness, &FrozenPublisher, &mut TxContext): Display<MintPass<Ty0>>
5StLoc[3](loc0: Display<MintPass<Ty0>>)
6MutBorrowLoc[3](loc0: Display<MintPass<Ty0>>)
7LdConst[0](vector<u8>: "typ..)
8Call string::utf8(vector<u8>): String
9LdConst[1](vector<u8>: "Min..)
10Call string::utf8(vector<u8>): String
11Call display::add<MintPass<Ty0>>(&mut Display<MintPass<Ty0>>, String, String)
12MoveLoc[3](loc0: Display<MintPass<Ty0>>)
13Ret
}
 
Constants [
0 => vector<u8>: "type" // interpreted as UTF8 string
1 => vector<u8>: "MintPass" // interpreted as UTF8 string
]
}