composable_nft
Module0x34a2…c82c
- Move path
- 0xbc3d…e5f9::composable_nft
- Functions
- 2825 public, 0 entry
- Structs
- 2
- Friend modules
- None
composable_nft
- access_policy19
- attributes18
- collection19
- composable_nft28
- composable_svg27
- composable_url10
- creators16
- display_info14
- frozen_pub1
- mint_cap15
- mint_event3
- mint_pass12
- mint_supply19
- nft18
- nft_bag28
- nft_protocol5
- p2p_list8
- p2p_list_domain13
- plugins14
- royalty29
- royalty_strategy_bps23
- session_token8
- supply27
- svg13
- symbol10
- tags11
- transfer_allowlist6
- transfer_allowlist_domain13
- transfer_token5
- url7
Bytecode414 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9.composable_nft {
use bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9::collection;
use bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9::nft_bag;
use 859eb18bd5b5e8cc32deb6dfb1c39941008ab3c6e27f0b8ce2364be7102bb7cb::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
struct Key<phantom Ty0> has drop, store {
dummy_field: bool
}
struct Composition<phantom Ty0> has store {
limits: VecMap<TypeName, u64>
}
public new_composition<Ty0>(): Composition<Ty0> {
B0:
0Call vec_map::empty<TypeName, u64>(): VecMap<TypeName, u64>
1PackGeneric[0](Composition<Ty0>)
2Ret
}
public has_child<Ty0>(Arg0: &Composition<Ty0>, Arg1: &TypeName): bool {
B0:
0MoveLoc[0](Arg0: &Composition<Ty0>)
1ImmBorrowFieldGeneric[0](Composition.limits: VecMap<TypeName, u64>)
2MoveLoc[1](Arg1: &TypeName)
3Call vec_map::contains<TypeName, u64>(&VecMap<TypeName, u64>, &TypeName): bool
4Ret
}
public get_limit<Ty0>(Arg0: &Composition<Ty0>, Arg1: &TypeName): u64 {
B0:
0CopyLoc[0](Arg0: &Composition<Ty0>)
1CopyLoc[1](Arg1: &TypeName)
2Call assert_composable<Ty0>(&Composition<Ty0>, &TypeName)
3MoveLoc[0](Arg0: &Composition<Ty0>)
4Call borrow_limits<Ty0>(&Composition<Ty0>): &VecMap<TypeName, u64>
5MoveLoc[1](Arg1: &TypeName)
6Call vec_map::get<TypeName, u64>(&VecMap<TypeName, u64>, &TypeName): &u64
7ReadRef
8Ret
}
public borrow_limit_mut<Ty0>(Arg0: &mut Composition<Ty0>, Arg1: &TypeName): &mut u64 {
L2: loc0: &TypeName
B0:
0CopyLoc[0](Arg0: &mut Composition<Ty0>)
1CopyLoc[1](Arg1: &TypeName)
2StLoc[2](loc0: &TypeName)
3FreezeRef
4MoveLoc[2](loc0: &TypeName)
5Call assert_composable<Ty0>(&Composition<Ty0>, &TypeName)
6MoveLoc[0](Arg0: &mut Composition<Ty0>)
7MutBorrowFieldGeneric[0](Composition.limits: VecMap<TypeName, u64>)
8MoveLoc[1](Arg1: &TypeName)
9Call vec_map::get_mut<TypeName, u64>(&mut VecMap<TypeName, u64>, &TypeName): &mut u64
10Ret
}
public borrow_limits<Ty0>(Arg0: &Composition<Ty0>): &VecMap<TypeName, u64> {
B0:
0MoveLoc[0](Arg0: &Composition<Ty0>)
1ImmBorrowFieldGeneric[0](Composition.limits: VecMap<TypeName, u64>)
2Ret
}
public add_relationship<Ty0, Ty1>(Arg0: &mut Composition<Ty0>, Arg1: u64) {
L2: loc0: &TypeName
L3: loc1: TypeName
B0:
0Call type_name::get<Ty1>(): TypeName
1StLoc[3](loc1: TypeName)
2CopyLoc[0](Arg0: &mut Composition<Ty0>)
3ImmBorrowLoc[3](loc1: TypeName)
4StLoc[2](loc0: &TypeName)
5FreezeRef
6MoveLoc[2](loc0: &TypeName)
7Call has_child<Ty0>(&Composition<Ty0>, &TypeName): bool
8Not
9BrFalse(11)
B1:
10Branch(15)
B2:
11MoveLoc[0](Arg0: &mut Composition<Ty0>)
12Pop
13LdConst[3](u64: 4)
14Abort
B3:
15MoveLoc[0](Arg0: &mut Composition<Ty0>)
16MutBorrowFieldGeneric[0](Composition.limits: VecMap<TypeName, u64>)
17MoveLoc[3](loc1: TypeName)
18MoveLoc[1](Arg1: u64)
19Call vec_map::insert<TypeName, u64>(&mut VecMap<TypeName, u64>, TypeName, u64)
20Ret
}
public drop_relationship<Ty0, Ty1>(Arg0: &mut Composition<Ty0>) {
L1: loc0: &TypeName
L2: loc1: TypeName
B0:
0Call type_name::get<Ty1>(): TypeName
1StLoc[2](loc1: TypeName)
2CopyLoc[0](Arg0: &mut Composition<Ty0>)
3ImmBorrowLoc[2](loc1: TypeName)
4StLoc[1](loc0: &TypeName)
5FreezeRef
6MoveLoc[1](loc0: &TypeName)
7Call assert_composable<Ty0>(&Composition<Ty0>, &TypeName)
8MoveLoc[0](Arg0: &mut Composition<Ty0>)
9MutBorrowFieldGeneric[0](Composition.limits: VecMap<TypeName, u64>)
10ImmBorrowLoc[2](loc1: TypeName)
11Call vec_map::remove<TypeName, u64>(&mut VecMap<TypeName, u64>, &TypeName): TypeName * u64
12Pop
13Pop
14Ret
}
public compose<Ty0, Ty1: store + key>(Arg0: &Composition<Ty0>, Arg1: &mut NftBag, Arg2: Ty1) {
L3: loc0: u64
B0:
0MoveLoc[1](Arg1: &mut NftBag)
1MoveLoc[2](Arg2: Ty1)
2Call compose_<Ty1>(&mut NftBag, Ty1): u64
3StLoc[3](loc0: u64)
4MoveLoc[0](Arg0: &Composition<Ty0>)
5MoveLoc[3](loc0: u64)
6Call assert_insertable<Ty0, Ty1>(&Composition<Ty0>, u64)
7Ret
}
compose_<Ty0: store + key>(Arg0: &mut NftBag, Arg1: Ty0): u64 {
B0:
0LdFalse
1PackGeneric[1](Key<Ty0>)
2CopyLoc[0](Arg0: &mut NftBag)
3MoveLoc[1](Arg1: Ty0)
4Call nft_bag::compose<Ty0, Key<Ty0>>(Key<Ty0>, &mut NftBag, Ty0)
5MoveLoc[0](Arg0: &mut NftBag)
6FreezeRef
7Call nft_bag::count<Key<Ty0>>(&NftBag): u64
8Ret
}
public compose_into_nft<Ty0, Ty1: store + key>(Arg0: &Composition<Ty0>, Arg1: &mut UID, Arg2: Ty1) {
L3: loc0: &mut NftBag
B0:
0MoveLoc[1](Arg1: &mut UID)
1Call nft_bag::borrow_domain_mut(&mut UID): &mut NftBag
2StLoc[3](loc0: &mut NftBag)
3MoveLoc[0](Arg0: &Composition<Ty0>)
4MoveLoc[3](loc0: &mut NftBag)
5MoveLoc[2](Arg2: Ty1)
6Call compose<Ty0, Ty1>(&Composition<Ty0>, &mut NftBag, Ty1)
7Ret
}
public compose_with_nft_schema<Ty0, Ty1: store + key>(Arg0: &mut UID, Arg1: Ty1) {
L2: loc0: u64
B0:
0CopyLoc[0](Arg0: &mut UID)
1Call nft_bag::borrow_domain_mut(&mut UID): &mut NftBag
2MoveLoc[1](Arg1: Ty1)
3Call compose_<Ty1>(&mut NftBag, Ty1): u64
4StLoc[2](loc0: u64)
5MoveLoc[0](Arg0: &mut UID)
6FreezeRef
7Call borrow_domain<Ty0>(&UID): &Composition<Ty0>
8MoveLoc[2](loc0: u64)
9Call assert_insertable<Ty0, Ty1>(&Composition<Ty0>, u64)
10Ret
}
public compose_with_collection_schema<Ty0, Ty1, Ty2: store + key>(Arg0: &Collection<Ty0>, Arg1: &mut UID, Arg2: Ty2) {
L3: loc0: &Composition<Ty1>
L4: loc1: &mut NftBag
B0:
0MoveLoc[0](Arg0: &Collection<Ty0>)
1Call collection::borrow_domain<Ty0, Composition<Ty1>>(&Collection<Ty0>): &Composition<Ty1>
2StLoc[3](loc0: &Composition<Ty1>)
3MoveLoc[1](Arg1: &mut UID)
4Call nft_bag::borrow_domain_mut(&mut UID): &mut NftBag
5StLoc[4](loc1: &mut NftBag)
6MoveLoc[3](loc0: &Composition<Ty1>)
7MoveLoc[4](loc1: &mut NftBag)
8MoveLoc[2](Arg2: Ty2)
9Call compose<Ty1, Ty2>(&Composition<Ty1>, &mut NftBag, Ty2)
10Ret
}
public decompose<Ty0, Ty1: store + key>(Arg0: &Composition<Ty0>, Arg1: &mut NftBag, Arg2: ID): Ty1 {
L3: loc0: TypeName
L4: loc1: &Composition<Ty0>
B0:
0MoveLoc[0](Arg0: &Composition<Ty0>)
1StLoc[4](loc1: &Composition<Ty0>)
2Call type_name::get<Ty1>(): TypeName
3StLoc[3](loc0: TypeName)
4MoveLoc[4](loc1: &Composition<Ty0>)
5ImmBorrowLoc[3](loc0: TypeName)
6Call assert_composable<Ty0>(&Composition<Ty0>, &TypeName)
7MoveLoc[1](Arg1: &mut NftBag)
8MoveLoc[2](Arg2: ID)
9Call decompose_<Ty1>(&mut NftBag, ID): Ty1
10Ret
}
decompose_<Ty0: store + key>(Arg0: &mut NftBag, Arg1: ID): Ty0 {
B0:
0LdFalse
1PackGeneric[1](Key<Ty0>)
2MoveLoc[0](Arg0: &mut NftBag)
3MoveLoc[1](Arg1: ID)
4Call nft_bag::decompose<Ty0, Key<Ty0>>(Key<Ty0>, &mut NftBag, ID): Ty0
5Ret
}
public decompose_from_nft<Ty0, Ty1: store + key>(Arg0: &Composition<Ty0>, Arg1: &mut UID, Arg2: ID): Ty1 {
L3: loc0: &mut NftBag
B0:
0MoveLoc[1](Arg1: &mut UID)
1Call nft_bag::borrow_domain_mut(&mut UID): &mut NftBag
2StLoc[3](loc0: &mut NftBag)
3MoveLoc[0](Arg0: &Composition<Ty0>)
4MoveLoc[3](loc0: &mut NftBag)
5MoveLoc[2](Arg2: ID)
6Call decompose<Ty0, Ty1>(&Composition<Ty0>, &mut NftBag, ID): Ty1
7Ret
}
public decompose_with_nft_schema<Ty0, Ty1: store + key>(Arg0: &mut UID, Arg1: ID): Ty1 {
L2: loc0: TypeName
L3: loc1: &Composition<Ty0>
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call borrow_domain<Ty0>(&UID): &Composition<Ty0>
3StLoc[3](loc1: &Composition<Ty0>)
4Call type_name::get<Ty1>(): TypeName
5StLoc[2](loc0: TypeName)
6MoveLoc[3](loc1: &Composition<Ty0>)
7ImmBorrowLoc[2](loc0: TypeName)
8Call assert_composable<Ty0>(&Composition<Ty0>, &TypeName)
9MoveLoc[0](Arg0: &mut UID)
10Call nft_bag::borrow_domain_mut(&mut UID): &mut NftBag
11MoveLoc[1](Arg1: ID)
12Call decompose_<Ty1>(&mut NftBag, ID): Ty1
13Ret
}
public decompose_with_collection_schema<Ty0, Ty1, Ty2: store + key>(Arg0: &Collection<Ty0>, Arg1: &mut UID, Arg2: ID): Ty2 {
L3: loc0: &Composition<Ty1>
L4: loc1: &mut NftBag
B0:
0MoveLoc[0](Arg0: &Collection<Ty0>)
1Call collection::borrow_domain<Ty0, Composition<Ty1>>(&Collection<Ty0>): &Composition<Ty1>
2StLoc[3](loc0: &Composition<Ty1>)
3MoveLoc[1](Arg1: &mut UID)
4Call nft_bag::borrow_domain_mut(&mut UID): &mut NftBag
5StLoc[4](loc1: &mut NftBag)
6MoveLoc[3](loc0: &Composition<Ty1>)
7MoveLoc[4](loc1: &mut NftBag)
8MoveLoc[2](Arg2: ID)
9Call decompose<Ty1, Ty2>(&Composition<Ty1>, &mut NftBag, ID): Ty2
10Ret
}
public has_domain<Ty0>(Arg0: &UID): bool {
B0:
0MoveLoc[0](Arg0: &UID)
1Call utils::marker<Composition<Ty0>>(): Marker<Composition<Ty0>>
2Call dynamic_field::exists_with_type<Marker<Composition<Ty0>>, Composition<Ty0>>(&UID, Marker<Composition<Ty0>>): bool
3Ret
}
public borrow_domain<Ty0>(Arg0: &UID): &Composition<Ty0> {
B0:
0CopyLoc[0](Arg0: &UID)
1Call assert_composition<Ty0>(&UID)
2MoveLoc[0](Arg0: &UID)
3Call utils::marker<Composition<Ty0>>(): Marker<Composition<Ty0>>
4Call dynamic_field::borrow<Marker<Composition<Ty0>>, Composition<Ty0>>(&UID, Marker<Composition<Ty0>>): &Composition<Ty0>
5Ret
}
public borrow_domain_mut<Ty0>(Arg0: &mut UID): &mut Composition<Ty0> {
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call assert_composition<Ty0>(&UID)
3MoveLoc[0](Arg0: &mut UID)
4Call utils::marker<Composition<Ty0>>(): Marker<Composition<Ty0>>
5Call dynamic_field::borrow_mut<Marker<Composition<Ty0>>, Composition<Ty0>>(&mut UID, Marker<Composition<Ty0>>): &mut Composition<Ty0>
6Ret
}
public add_domain<Ty0>(Arg0: &mut UID, Arg1: Composition<Ty0>) {
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call assert_no_composition<Ty0>(&UID)
3MoveLoc[0](Arg0: &mut UID)
4Call utils::marker<Composition<Ty0>>(): Marker<Composition<Ty0>>
5MoveLoc[1](Arg1: Composition<Ty0>)
6Call dynamic_field::add<Marker<Composition<Ty0>>, Composition<Ty0>>(&mut UID, Marker<Composition<Ty0>>, Composition<Ty0>)
7Ret
}
public add_new_composition<Ty0>(Arg0: &mut UID) {
B0:
0MoveLoc[0](Arg0: &mut UID)
1Call new_composition<Ty0>(): Composition<Ty0>
2Call add_domain<Ty0>(&mut UID, Composition<Ty0>)
3Ret
}
public remove_domain<Ty0>(Arg0: &mut UID): Composition<Ty0> {
B0:
0CopyLoc[0](Arg0: &mut UID)
1FreezeRef
2Call assert_composition<Ty0>(&UID)
3MoveLoc[0](Arg0: &mut UID)
4Call utils::marker<Composition<Ty0>>(): Marker<Composition<Ty0>>
5Call dynamic_field::remove<Marker<Composition<Ty0>>, Composition<Ty0>>(&mut UID, Marker<Composition<Ty0>>): Composition<Ty0>
6Ret
}
public delete<Ty0>(Arg0: Composition<Ty0>) {
B0:
0MoveLoc[0](Arg0: Composition<Ty0>)
1UnpackGeneric[0](Composition<Ty0>)
2Pop
3Ret
}
assert_insertable<Ty0, Ty1: store + key>(Arg0: &Composition<Ty0>, Arg1: u64) {
L2: loc0: TypeName
L3: loc1: u64
B0:
0Call type_name::get<Ty1>(): TypeName
1StLoc[2](loc0: TypeName)
2MoveLoc[0](Arg0: &Composition<Ty0>)
3ImmBorrowLoc[2](loc0: TypeName)
4Call get_limit<Ty0>(&Composition<Ty0>, &TypeName): u64
5StLoc[3](loc1: u64)
6MoveLoc[1](Arg1: u64)
7MoveLoc[3](loc1: u64)
8Le
9BrFalse(11)
B1:
10Branch(13)
B2:
11LdConst[4](u64: 5)
12Abort
B3:
13Ret
}
public assert_composable<Ty0>(Arg0: &Composition<Ty0>, Arg1: &TypeName) {
B0:
0MoveLoc[0](Arg0: &Composition<Ty0>)
1MoveLoc[1](Arg1: &TypeName)
2Call has_child<Ty0>(&Composition<Ty0>, &TypeName): bool
3BrFalse(5)
B1:
4Branch(7)
B2:
5LdConst[2](u64: 3)
6Abort
B3:
7Ret
}
public assert_composition<Ty0>(Arg0: &UID) {
B0:
0MoveLoc[0](Arg0: &UID)
1Call has_domain<Ty0>(&UID): bool
2BrFalse(4)
B1:
3Branch(6)
B2:
4LdConst[0](u64: 1)
5Abort
B3:
6Ret
}
public assert_no_composition<Ty0>(Arg0: &UID) {
B0:
0MoveLoc[0](Arg0: &UID)
1Call has_domain<Ty0>(&UID): bool
2Not
3BrFalse(5)
B1:
4Branch(7)
B2:
5LdConst[1](u64: 2)
6Abort
B3:
7Ret
}
Constants [
0 => u64: 1
1 => u64: 2
2 => u64: 3
3 => u64: 4
4 => u64: 5
]
}