access_policy
Module0x34a2…c82c
- Move path
- 0xbc3d…e5f9::access_policy
- Functions
- 1912 public, 3 entry
- Structs
- 4
- Friend modules
- None
access_policy
- 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
Bytecode388 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v6
module bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9.access_policy {
use bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9::collection;
use bc3df36be17f27ac98e3c839b2589db8475fa07b20657b08e8891e3aaf5ee5f9::nft_protocol;
use 16c5f17f2d55584a6e6daa442ccf83b4530d10546a8e7dedda9ba324e012fc40::witness;
use e2c7a6843cb13d9549a9d2dc1c266b572ead0b4b9f090e7c3c46de2714102b43::borrow_request;
use e2c7a6843cb13d9549a9d2dc1c266b572ead0b4b9f090e7c3c46de2714102b43::request;
use 859eb18bd5b5e8cc32deb6dfb1c39941008ab3c6e27f0b8ce2364be7102bb7cb::utils;
use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::package;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_set;
struct AccessPolicyRule has drop {
dummy_field: bool
}
struct AccessPolicy<phantom Ty0: store + key> has store, key {
id: UID,
version: u64,
parent_access: VecSet<address>,
field_access: Table<TypeName, VecSet<address>>
}
struct Witness has drop {
dummy_field: bool
}
struct NewPolicyEvent has copy, drop {
policy_id: ID,
type_name: TypeName
}
public create_new<Ty0: store + key>(Arg0: Witness<Ty0>, Arg1: &mut TxContext): AccessPolicy<Ty0> {
L2: loc0: Table<TypeName, VecSet<address>>
L3: loc1: UID
L4: loc2: VecSet<address>
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[3](loc1: UID)
3ImmBorrowLoc[3](loc1: UID)
4Call object::uid_to_inner(&UID): ID
5Call type_name::get<Ty0>(): TypeName
6Pack[3](NewPolicyEvent)
7Call event::emit<NewPolicyEvent>(NewPolicyEvent)
8Call empty_parent_access(): VecSet<address>
9StLoc[4](loc2: VecSet<address>)
10MoveLoc[1](Arg1: &mut TxContext)
11Call empty_field_access(&mut TxContext): Table<TypeName, VecSet<address>>
12StLoc[2](loc0: Table<TypeName, VecSet<address>>)
13MoveLoc[3](loc1: UID)
14LdConst[0](u64: 2)
15MoveLoc[4](loc2: VecSet<address>)
16MoveLoc[2](loc0: Table<TypeName, VecSet<address>>)
17PackGeneric[0](AccessPolicy<Ty0>)
18Ret
}
public add_new<Ty0: store + key>(Arg0: Witness<Ty0>, Arg1: &mut Collection<Ty0>, Arg2: &mut TxContext) {
L3: loc0: AccessPolicy<Ty0>
L4: loc1: Table<TypeName, VecSet<address>>
L5: loc2: UID
L6: loc3: VecSet<address>
B0:
0CopyLoc[2](Arg2: &mut TxContext)
1Call object::new(&mut TxContext): UID
2StLoc[5](loc2: UID)
3ImmBorrowLoc[5](loc2: UID)
4Call object::uid_to_inner(&UID): ID
5Call type_name::get<Ty0>(): TypeName
6Pack[3](NewPolicyEvent)
7Call event::emit<NewPolicyEvent>(NewPolicyEvent)
8Call empty_parent_access(): VecSet<address>
9StLoc[6](loc3: VecSet<address>)
10MoveLoc[2](Arg2: &mut TxContext)
11Call empty_field_access(&mut TxContext): Table<TypeName, VecSet<address>>
12StLoc[4](loc1: Table<TypeName, VecSet<address>>)
13MoveLoc[5](loc2: UID)
14LdConst[0](u64: 2)
15MoveLoc[6](loc3: VecSet<address>)
16MoveLoc[4](loc1: Table<TypeName, VecSet<address>>)
17PackGeneric[0](AccessPolicy<Ty0>)
18StLoc[3](loc0: AccessPolicy<Ty0>)
19MoveLoc[0](Arg0: Witness<Ty0>)
20MoveLoc[1](Arg1: &mut Collection<Ty0>)
21MoveLoc[3](loc0: AccessPolicy<Ty0>)
22Call collection::add_domain<Ty0, AccessPolicy<Ty0>>(Witness<Ty0>, &mut Collection<Ty0>, AccessPolicy<Ty0>)
23Ret
}
entry public enforce<Ty0, Ty1>(Arg0: &mut Policy<WithNft<Ty0, Ty1>>, Arg1: &PolicyCap) {
B0:
0MoveLoc[0](Arg0: &mut Policy<WithNft<Ty0, Ty1>>)
1MoveLoc[1](Arg1: &PolicyCap)
2Call request::enforce_rule_no_state<WithNft<Ty0, Ty1>, AccessPolicyRule>(&mut Policy<WithNft<Ty0, Ty1>>, &PolicyCap)
3Ret
}
public drop<Ty0, Ty1>(Arg0: &mut Policy<WithNft<Ty0, Ty1>>, Arg1: &PolicyCap) {
B0:
0MoveLoc[0](Arg0: &mut Policy<WithNft<Ty0, Ty1>>)
1MoveLoc[1](Arg1: &PolicyCap)
2Call request::drop_rule_no_state<WithNft<Ty0, Ty1>, AccessPolicyRule>(&mut Policy<WithNft<Ty0, Ty1>>, &PolicyCap)
3Ret
}
public confirm<Ty0: drop, Ty1: store + key>(Arg0: &AccessPolicy<Ty1>, Arg1: &mut BorrowRequest<Ty0, Ty1>, Arg2: &mut TxContext) {
L3: loc0: AccessPolicyRule
L4: loc1: &mut BorrowRequest<Ty0, Ty1>
L5: loc2: TypeName
B0:
0CopyLoc[0](Arg0: &AccessPolicy<Ty1>)
1Call assert_version<Ty1>(&AccessPolicy<Ty1>)
2CopyLoc[1](Arg1: &mut BorrowRequest<Ty0, Ty1>)
3FreezeRef
4Call borrow_request::is_borrow_field<Ty0, Ty1>(&BorrowRequest<Ty0, Ty1>): bool
5BrFalse(16)
B1:
6CopyLoc[1](Arg1: &mut BorrowRequest<Ty0, Ty1>)
7FreezeRef
8Call borrow_request::field<Ty0, Ty1>(&BorrowRequest<Ty0, Ty1>): TypeName
9StLoc[5](loc2: TypeName)
10MoveLoc[0](Arg0: &AccessPolicy<Ty1>)
11MoveLoc[5](loc2: TypeName)
12MoveLoc[2](Arg2: &mut TxContext)
13FreezeRef
14Call assert_field_auth<Ty1>(&AccessPolicy<Ty1>, TypeName, &TxContext)
15Branch(20)
B2:
16MoveLoc[0](Arg0: &AccessPolicy<Ty1>)
17MoveLoc[2](Arg2: &mut TxContext)
18FreezeRef
19Call assert_parent_auth<Ty1>(&AccessPolicy<Ty1>, &TxContext)
B3:
20MoveLoc[1](Arg1: &mut BorrowRequest<Ty0, Ty1>)
21StLoc[4](loc1: &mut BorrowRequest<Ty0, Ty1>)
22LdFalse
23Pack[0](AccessPolicyRule)
24StLoc[3](loc0: AccessPolicyRule)
25MoveLoc[4](loc1: &mut BorrowRequest<Ty0, Ty1>)
26ImmBorrowLoc[3](loc0: AccessPolicyRule)
27Call borrow_request::add_receipt<Ty0, Ty1, AccessPolicyRule>(&mut BorrowRequest<Ty0, Ty1>, &AccessPolicyRule)
28Ret
}
public confirm_from_collection<Ty0: drop, Ty1: store + key>(Arg0: &Collection<Ty1>, Arg1: &mut BorrowRequest<Ty0, Ty1>, Arg2: &mut TxContext) {
L3: loc0: &AccessPolicy<Ty1>
B0:
0MoveLoc[0](Arg0: &Collection<Ty1>)
1Call collection::borrow_domain<Ty1, AccessPolicy<Ty1>>(&Collection<Ty1>): &AccessPolicy<Ty1>
2StLoc[3](loc0: &AccessPolicy<Ty1>)
3CopyLoc[3](loc0: &AccessPolicy<Ty1>)
4Call assert_version<Ty1>(&AccessPolicy<Ty1>)
5MoveLoc[3](loc0: &AccessPolicy<Ty1>)
6MoveLoc[1](Arg1: &mut BorrowRequest<Ty0, Ty1>)
7MoveLoc[2](Arg2: &mut TxContext)
8Call confirm<Ty0, Ty1>(&AccessPolicy<Ty1>, &mut BorrowRequest<Ty0, Ty1>, &mut TxContext)
9Ret
}
public add_parent_access_to_policy<Ty0: store + key>(Arg0: Witness<Ty0>, Arg1: &mut AccessPolicy<Ty0>, Arg2: vector<address>) {
B0:
0CopyLoc[1](Arg1: &mut AccessPolicy<Ty0>)
1Call assert_version_and_upgrade<Ty0>(&mut AccessPolicy<Ty0>)
2MoveLoc[1](Arg1: &mut AccessPolicy<Ty0>)
3MutBorrowFieldGeneric[0](AccessPolicy.parent_access: VecSet<address>)
4MoveLoc[2](Arg2: vector<address>)
5Call utils::insert_vec_in_vec_set<address>(&mut VecSet<address>, vector<address>)
6Ret
}
public add_field_access_to_policy<Ty0: store + key, Ty1: store>(Arg0: Witness<Ty0>, Arg1: &mut AccessPolicy<Ty0>, Arg2: vector<address>) {
B0:
0CopyLoc[1](Arg1: &mut AccessPolicy<Ty0>)
1Call assert_version_and_upgrade<Ty0>(&mut AccessPolicy<Ty0>)
2MoveLoc[1](Arg1: &mut AccessPolicy<Ty0>)
3MutBorrowFieldGeneric[1](AccessPolicy.field_access: Table<TypeName, VecSet<address>>)
4Call type_name::get<Ty1>(): TypeName
5Call table::borrow_mut<TypeName, VecSet<address>>(&mut Table<TypeName, VecSet<address>>, TypeName): &mut VecSet<address>
6MoveLoc[2](Arg2: vector<address>)
7Call utils::insert_vec_in_vec_set<address>(&mut VecSet<address>, vector<address>)
8Ret
}
public add_parent_access<Ty0: store + key>(Arg0: Witness<Ty0>, Arg1: &mut Collection<Ty0>, Arg2: vector<address>) {
L3: loc0: &mut AccessPolicy<Ty0>
B0:
0LdFalse
1Pack[2](Witness)
2Call witness::from_witness<AccessPolicy<Ty0>, Witness>(Witness): Witness<AccessPolicy<Ty0>>
3MoveLoc[1](Arg1: &mut Collection<Ty0>)
4Call collection::borrow_domain_mut<Ty0, AccessPolicy<Ty0>>(Witness<AccessPolicy<Ty0>>, &mut Collection<Ty0>): &mut AccessPolicy<Ty0>
5StLoc[3](loc0: &mut AccessPolicy<Ty0>)
6CopyLoc[3](loc0: &mut AccessPolicy<Ty0>)
7Call assert_version_and_upgrade<Ty0>(&mut AccessPolicy<Ty0>)
8MoveLoc[3](loc0: &mut AccessPolicy<Ty0>)
9MutBorrowFieldGeneric[0](AccessPolicy.parent_access: VecSet<address>)
10MoveLoc[2](Arg2: vector<address>)
11Call utils::insert_vec_in_vec_set<address>(&mut VecSet<address>, vector<address>)
12Ret
}
public add_field_access<Ty0: store + key, Ty1: store>(Arg0: Witness<Ty0>, Arg1: &mut Collection<Ty0>, Arg2: vector<address>) {
L3: loc0: &mut AccessPolicy<Ty0>
B0:
0LdFalse
1Pack[2](Witness)
2Call witness::from_witness<AccessPolicy<Ty0>, Witness>(Witness): Witness<AccessPolicy<Ty0>>
3MoveLoc[1](Arg1: &mut Collection<Ty0>)
4Call collection::borrow_domain_mut<Ty0, AccessPolicy<Ty0>>(Witness<AccessPolicy<Ty0>>, &mut Collection<Ty0>): &mut AccessPolicy<Ty0>
5StLoc[3](loc0: &mut AccessPolicy<Ty0>)
6CopyLoc[3](loc0: &mut AccessPolicy<Ty0>)
7Call assert_version_and_upgrade<Ty0>(&mut AccessPolicy<Ty0>)
8MoveLoc[3](loc0: &mut AccessPolicy<Ty0>)
9MutBorrowFieldGeneric[1](AccessPolicy.field_access: Table<TypeName, VecSet<address>>)
10Call type_name::get<Ty1>(): TypeName
11Call table::borrow_mut<TypeName, VecSet<address>>(&mut Table<TypeName, VecSet<address>>, TypeName): &mut VecSet<address>
12MoveLoc[2](Arg2: vector<address>)
13Call utils::insert_vec_in_vec_set<address>(&mut VecSet<address>, vector<address>)
14Ret
}
public assert_field_auth<Ty0: store + key>(Arg0: &AccessPolicy<Ty0>, Arg1: TypeName, Arg2: &TxContext) {
L3: loc0: address
L4: loc1: &VecSet<address>
B0:
0MoveLoc[0](Arg0: &AccessPolicy<Ty0>)
1ImmBorrowFieldGeneric[1](AccessPolicy.field_access: Table<TypeName, VecSet<address>>)
2MoveLoc[1](Arg1: TypeName)
3Call table::borrow<TypeName, VecSet<address>>(&Table<TypeName, VecSet<address>>, TypeName): &VecSet<address>
4StLoc[4](loc1: &VecSet<address>)
5MoveLoc[2](Arg2: &TxContext)
6Call tx_context::sender(&TxContext): address
7StLoc[3](loc0: address)
8MoveLoc[4](loc1: &VecSet<address>)
9ImmBorrowLoc[3](loc0: address)
10Call vec_set::contains<address>(&VecSet<address>, &address): bool
11BrFalse(13)
B1:
12Branch(15)
B2:
13LdConst[0](u64: 2)
14Abort
B3:
15Ret
}
public assert_parent_auth<Ty0: store + key>(Arg0: &AccessPolicy<Ty0>, Arg1: &TxContext) {
L2: loc0: address
L3: loc1: &VecSet<address>
B0:
0MoveLoc[0](Arg0: &AccessPolicy<Ty0>)
1ImmBorrowFieldGeneric[0](AccessPolicy.parent_access: VecSet<address>)
2StLoc[3](loc1: &VecSet<address>)
3MoveLoc[1](Arg1: &TxContext)
4Call tx_context::sender(&TxContext): address
5StLoc[2](loc0: address)
6MoveLoc[3](loc1: &VecSet<address>)
7ImmBorrowLoc[2](loc0: address)
8Call vec_set::contains<address>(&VecSet<address>, &address): bool
9BrFalse(11)
B1:
10Branch(13)
B2:
11LdConst[4](u64: 3)
12Abort
B3:
13Ret
}
assert_no_access_policy<Ty0: drop, Ty1: store + key>(Arg0: &Collection<Ty0>) {
B0:
0MoveLoc[0](Arg0: &Collection<Ty0>)
1Call collection::has_domain<Ty0, AccessPolicy<Ty1>>(&Collection<Ty0>): bool
2Not
3BrFalse(5)
B1:
4Branch(7)
B2:
5LdConst[3](u64: 1)
6Abort
B3:
7Ret
}
empty_parent_access(): VecSet<address> {
B0:
0Call vec_set::empty<address>(): VecSet<address>
1Ret
}
empty_field_access(Arg0: &mut TxContext): Table<TypeName, VecSet<address>> {
B0:
0MoveLoc[0](Arg0: &mut TxContext)
1Call table::new<TypeName, VecSet<address>>(&mut TxContext): Table<TypeName, VecSet<address>>
2Ret
}
assert_version<Ty0: store + key>(Arg0: &AccessPolicy<Ty0>) {
B0:
0MoveLoc[0](Arg0: &AccessPolicy<Ty0>)
1ImmBorrowFieldGeneric[2](AccessPolicy.version: u64)
2ReadRef
3LdConst[0](u64: 2)
4Eq
5BrFalse(7)
B1:
6Branch(9)
B2:
7LdConst[2](u64: 1000)
8Abort
B3:
9Ret
}
assert_version_and_upgrade<Ty0: store + key>(Arg0: &mut AccessPolicy<Ty0>) {
B0:
0CopyLoc[0](Arg0: &mut AccessPolicy<Ty0>)
1ImmBorrowFieldGeneric[2](AccessPolicy.version: u64)
2ReadRef
3LdConst[0](u64: 2)
4Lt
5BrFalse(10)
B1:
6LdConst[0](u64: 2)
7CopyLoc[0](Arg0: &mut AccessPolicy<Ty0>)
8MutBorrowFieldGeneric[2](AccessPolicy.version: u64)
9WriteRef
B2:
10MoveLoc[0](Arg0: &mut AccessPolicy<Ty0>)
11FreezeRef
12Call assert_version<Ty0>(&AccessPolicy<Ty0>)
13Ret
}
entry migrate_as_creator<Ty0: store + key>(Arg0: &mut AccessPolicy<Ty0>, Arg1: &Publisher) {
B0:
0MoveLoc[1](Arg1: &Publisher)
1Call package::from_package<Ty0>(&Publisher): bool
2BrFalse(4)
B1:
3Branch(8)
B2:
4MoveLoc[0](Arg0: &mut AccessPolicy<Ty0>)
5Pop
6LdU64(0)
7Abort
B3:
8LdConst[0](u64: 2)
9MoveLoc[0](Arg0: &mut AccessPolicy<Ty0>)
10MutBorrowFieldGeneric[2](AccessPolicy.version: u64)
11WriteRef
12Ret
}
entry migrate_as_pub<Ty0: store + key>(Arg0: &mut AccessPolicy<Ty0>, Arg1: &Publisher) {
B0:
0MoveLoc[1](Arg1: &Publisher)
1Call package::from_package<NFT_PROTOCOL>(&Publisher): bool
2BrFalse(4)
B1:
3Branch(8)
B2:
4MoveLoc[0](Arg0: &mut AccessPolicy<Ty0>)
5Pop
6LdU64(0)
7Abort
B3:
8LdConst[0](u64: 2)
9MoveLoc[0](Arg0: &mut AccessPolicy<Ty0>)
10MutBorrowFieldGeneric[2](AccessPolicy.version: u64)
11WriteRef
12Ret
}
Constants [
0 => u64: 2
1 => u64: 999
2 => u64: 1000
3 => u64: 1
4 => u64: 3
]
}