registry
Module0x5580…2003
- Move path
- 0xd22b…08f0::registry
- Functions
- 2218 public, 0 entry
- Structs
- 1
- Friend modules
- controller
registry
Bytecode894 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0.registry {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::table;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::domain;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::name_record;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::subdomain_registration;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins_registration;
struct Registry has store {
registry: Table<Domain, NameRecord>,
reverse_registry: Table<address, Domain>
}
public new(Arg0: &AdminCap, Arg1: &mut TxContext): Registry {
B0:
0CopyLoc[1](Arg1: &mut TxContext)
1Call table::new<Domain, NameRecord>(&mut TxContext): Table<Domain, NameRecord>
2MoveLoc[1](Arg1: &mut TxContext)
3Call table::new<address, Domain>(&mut TxContext): Table<address, Domain>
4Pack[0](Registry)
5Ret
}
public add_record_ignoring_grace_period(Arg0: &mut Registry, Arg1: Domain, Arg2: u8, Arg3: &Clock, Arg4: &mut TxContext): SuinsRegistration {
B0:
0MoveLoc[0](Arg0: &mut Registry)
1MoveLoc[1](Arg1: Domain)
2MoveLoc[2](Arg2: u8)
3MoveLoc[3](Arg3: &Clock)
4LdFalse
5MoveLoc[4](Arg4: &mut TxContext)
6Call internal_add_record(&mut Registry, Domain, u8, &Clock, bool, &mut TxContext): SuinsRegistration
7Ret
}
public add_record(Arg0: &mut Registry, Arg1: Domain, Arg2: u8, Arg3: &Clock, Arg4: &mut TxContext): SuinsRegistration {
B0:
0MoveLoc[0](Arg0: &mut Registry)
1MoveLoc[1](Arg1: Domain)
2MoveLoc[2](Arg2: u8)
3MoveLoc[3](Arg3: &Clock)
4LdTrue
5MoveLoc[4](Arg4: &mut TxContext)
6Call internal_add_record(&mut Registry, Domain, u8, &Clock, bool, &mut TxContext): SuinsRegistration
7Ret
}
public burn_registration_object(Arg0: &mut Registry, Arg1: SuinsRegistration, Arg2: &Clock) {
L3: loc0: Domain
L4: loc1: NameRecord
B0:
0ImmBorrowLoc[1](Arg1: SuinsRegistration)
1MoveLoc[2](Arg2: &Clock)
2Call suins_registration::has_expired(&SuinsRegistration, &Clock): bool
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &mut Registry)
6Pop
7LdConst[1](u64: 1)
8Abort
B3:
9ImmBorrowLoc[1](Arg1: SuinsRegistration)
10Call suins_registration::domain(&SuinsRegistration): Domain
11StLoc[3](loc0: Domain)
12CopyLoc[0](Arg0: &mut Registry)
13ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
14CopyLoc[3](loc0: Domain)
15Call table::contains<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): bool
16BrFalse(41)
B4:
17CopyLoc[0](Arg0: &mut Registry)
18ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
19CopyLoc[3](loc0: Domain)
20Call table::borrow<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): &NameRecord
21Call name_record::nft_id(&NameRecord): ID
22ImmBorrowLoc[1](Arg1: SuinsRegistration)
23Call object::id<SuinsRegistration>(&SuinsRegistration): ID
24Eq
25BrFalse(38)
B5:
26CopyLoc[0](Arg0: &mut Registry)
27MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
28CopyLoc[3](loc0: Domain)
29Call table::remove<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain): NameRecord
30StLoc[4](loc1: NameRecord)
31MoveLoc[0](Arg0: &mut Registry)
32ImmBorrowLoc[3](loc0: Domain)
33ImmBorrowLoc[4](loc1: NameRecord)
34Call name_record::target_address(&NameRecord): Option<address>
35Call option::none<address>(): Option<address>
36Call handle_invalidate_reverse_record(&mut Registry, &Domain, Option<address>, Option<address>)
37Branch(43)
B6:
38MoveLoc[0](Arg0: &mut Registry)
39Pop
40Branch(43)
B7:
41MoveLoc[0](Arg0: &mut Registry)
42Pop
B8:
43MoveLoc[1](Arg1: SuinsRegistration)
44Call suins_registration::burn(SuinsRegistration)
45Ret
}
public wrap_subdomain(Arg0: &mut Registry, Arg1: SuinsRegistration, Arg2: &Clock, Arg3: &mut TxContext): SubDomainRegistration {
B0:
0MoveLoc[1](Arg1: SuinsRegistration)
1MoveLoc[2](Arg2: &Clock)
2MoveLoc[3](Arg3: &mut TxContext)
3Call subdomain_registration::new(SuinsRegistration, &Clock, &mut TxContext): SubDomainRegistration
4Ret
}
public burn_subdomain_object(Arg0: &mut Registry, Arg1: SubDomainRegistration, Arg2: &Clock) {
L3: loc0: SuinsRegistration
B0:
0MoveLoc[1](Arg1: SubDomainRegistration)
1CopyLoc[2](Arg2: &Clock)
2Call subdomain_registration::burn(SubDomainRegistration, &Clock): SuinsRegistration
3StLoc[3](loc0: SuinsRegistration)
4MoveLoc[0](Arg0: &mut Registry)
5MoveLoc[3](loc0: SuinsRegistration)
6MoveLoc[2](Arg2: &Clock)
7Call burn_registration_object(&mut Registry, SuinsRegistration, &Clock)
8Ret
}
public(friend) prune_expired_subdomain_record(Arg0: &mut Registry, Arg1: Domain, Arg2: &Clock) {
L3: loc0: &NameRecord
B0:
0CopyLoc[0](Arg0: &mut Registry)
1ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2CopyLoc[1](Arg1: Domain)
3Call table::contains<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): bool
4BrFalse(6)
B1:
5Branch(12)
B2:
6MoveLoc[0](Arg0: &mut Registry)
7Pop
8MoveLoc[2](Arg2: &Clock)
9Pop
10LdConst[8](u64: 8)
11Abort
B3:
12CopyLoc[0](Arg0: &mut Registry)
13ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
14CopyLoc[1](Arg1: Domain)
15Call table::borrow<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): &NameRecord
16StLoc[3](loc0: &NameRecord)
17CopyLoc[3](loc0: &NameRecord)
18Call name_record::is_leaf_record(&NameRecord): bool
19Not
20BrFalse(22)
B4:
21Branch(30)
B5:
22MoveLoc[0](Arg0: &mut Registry)
23Pop
24MoveLoc[3](loc0: &NameRecord)
25Pop
26MoveLoc[2](Arg2: &Clock)
27Pop
28LdConst[6](u64: 6)
29Abort
B6:
30MoveLoc[3](loc0: &NameRecord)
31MoveLoc[2](Arg2: &Clock)
32Call name_record::has_expired(&NameRecord, &Clock): bool
33BrFalse(35)
B7:
34Branch(39)
B8:
35MoveLoc[0](Arg0: &mut Registry)
36Pop
37LdConst[1](u64: 1)
38Abort
B9:
39MoveLoc[0](Arg0: &mut Registry)
40MoveLoc[1](Arg1: Domain)
41Call remove_record_and_invalidate_reverse(&mut Registry, Domain)
42Ret
}
public(friend) try_prune_expired_subdomain_record(Arg0: &mut Registry, Arg1: Domain, Arg2: &Clock): bool {
L3: loc0: &NameRecord
B0:
0ImmBorrowLoc[1](Arg1: Domain)
1Call domain::is_subdomain(&Domain): bool
2Not
3BrFalse(10)
B1:
4MoveLoc[0](Arg0: &mut Registry)
5Pop
6MoveLoc[2](Arg2: &Clock)
7Pop
8LdFalse
9Ret
B2:
10CopyLoc[0](Arg0: &mut Registry)
11ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
12CopyLoc[1](Arg1: Domain)
13Call table::contains<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): bool
14Not
15BrFalse(22)
B3:
16MoveLoc[0](Arg0: &mut Registry)
17Pop
18MoveLoc[2](Arg2: &Clock)
19Pop
20LdFalse
21Ret
B4:
22CopyLoc[0](Arg0: &mut Registry)
23ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
24CopyLoc[1](Arg1: Domain)
25Call table::borrow<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): &NameRecord
26StLoc[3](loc0: &NameRecord)
27CopyLoc[3](loc0: &NameRecord)
28Call name_record::is_leaf_record(&NameRecord): bool
29BrFalse(38)
B5:
30MoveLoc[0](Arg0: &mut Registry)
31Pop
32MoveLoc[3](loc0: &NameRecord)
33Pop
34MoveLoc[2](Arg2: &Clock)
35Pop
36LdFalse
37Ret
B6:
38MoveLoc[3](loc0: &NameRecord)
39MoveLoc[2](Arg2: &Clock)
40Call name_record::has_expired(&NameRecord, &Clock): bool
41Not
42BrFalse(47)
B7:
43MoveLoc[0](Arg0: &mut Registry)
44Pop
45LdFalse
46Ret
B8:
47MoveLoc[0](Arg0: &mut Registry)
48MoveLoc[1](Arg1: Domain)
49Call remove_record_and_invalidate_reverse(&mut Registry, Domain)
50LdTrue
51Ret
}
public add_leaf_record(Arg0: &mut Registry, Arg1: Domain, Arg2: &Clock, Arg3: address, Arg4: &mut TxContext) {
L5: loc0: Option<NameRecord>
L6: loc1: Domain
L7: loc2: &NameRecord
B0:
0ImmBorrowLoc[1](Arg1: Domain)
1Call domain::is_subdomain(&Domain): bool
2BrFalse(4)
B1:
3Branch(10)
B2:
4MoveLoc[0](Arg0: &mut Registry)
5Pop
6MoveLoc[2](Arg2: &Clock)
7Pop
8LdConst[7](u64: 7)
9Abort
B3:
10ImmBorrowLoc[1](Arg1: Domain)
11Call domain::parent(&Domain): Domain
12StLoc[6](loc1: Domain)
13CopyLoc[0](Arg0: &mut Registry)
14FreezeRef
15MoveLoc[6](loc1: Domain)
16Call lookup(&Registry, Domain): Option<NameRecord>
17StLoc[5](loc0: Option<NameRecord>)
18ImmBorrowLoc[5](loc0: Option<NameRecord>)
19Call option::is_some<NameRecord>(&Option<NameRecord>): bool
20BrFalse(22)
B4:
21Branch(28)
B5:
22MoveLoc[0](Arg0: &mut Registry)
23Pop
24MoveLoc[2](Arg2: &Clock)
25Pop
26LdConst[8](u64: 8)
27Abort
B6:
28ImmBorrowLoc[5](loc0: Option<NameRecord>)
29Call option::borrow<NameRecord>(&Option<NameRecord>): &NameRecord
30StLoc[7](loc2: &NameRecord)
31CopyLoc[7](loc2: &NameRecord)
32CopyLoc[2](Arg2: &Clock)
33Call name_record::has_expired(&NameRecord, &Clock): bool
34Not
35BrFalse(37)
B7:
36Branch(45)
B8:
37MoveLoc[0](Arg0: &mut Registry)
38Pop
39MoveLoc[7](loc2: &NameRecord)
40Pop
41MoveLoc[2](Arg2: &Clock)
42Pop
43LdConst[3](u64: 3)
44Abort
B9:
45CopyLoc[0](Arg0: &mut Registry)
46CopyLoc[1](Arg1: Domain)
47MoveLoc[2](Arg2: &Clock)
48LdFalse
49Call remove_existing_record_if_expired(&mut Registry, Domain, &Clock, bool)
50MoveLoc[0](Arg0: &mut Registry)
51MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
52MoveLoc[1](Arg1: Domain)
53MoveLoc[7](loc2: &NameRecord)
54Call name_record::nft_id(&NameRecord): ID
55MoveLoc[3](Arg3: address)
56Call option::some<address>(address): Option<address>
57Call name_record::new_leaf(ID, Option<address>): NameRecord
58Call table::add<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain, NameRecord)
59Ret
}
public remove_leaf_record(Arg0: &mut Registry, Arg1: Domain) {
L2: loc0: Option<address>
L3: loc1: NameRecord
B0:
0CopyLoc[0](Arg0: &mut Registry)
1FreezeRef
2CopyLoc[1](Arg1: Domain)
3Call is_leaf_record(&Registry, Domain): bool
4BrFalse(6)
B1:
5Branch(10)
B2:
6MoveLoc[0](Arg0: &mut Registry)
7Pop
8LdConst[6](u64: 6)
9Abort
B3:
10CopyLoc[0](Arg0: &mut Registry)
11MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
12CopyLoc[1](Arg1: Domain)
13Call table::remove<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain): NameRecord
14StLoc[3](loc1: NameRecord)
15ImmBorrowLoc[3](loc1: NameRecord)
16Call name_record::target_address(&NameRecord): Option<address>
17StLoc[2](loc0: Option<address>)
18MoveLoc[0](Arg0: &mut Registry)
19ImmBorrowLoc[1](Arg1: Domain)
20MoveLoc[2](loc0: Option<address>)
21Call option::none<address>(): Option<address>
22Call handle_invalidate_reverse_record(&mut Registry, &Domain, Option<address>, Option<address>)
23Ret
}
public set_target_address(Arg0: &mut Registry, Arg1: Domain, Arg2: Option<address>) {
L3: loc0: Option<address>
L4: loc1: &mut NameRecord
B0:
0CopyLoc[0](Arg0: &mut Registry)
1MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2CopyLoc[1](Arg1: Domain)
3Call table::borrow_mut<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain): &mut NameRecord
4StLoc[4](loc1: &mut NameRecord)
5CopyLoc[4](loc1: &mut NameRecord)
6FreezeRef
7Call name_record::target_address(&NameRecord): Option<address>
8StLoc[3](loc0: Option<address>)
9MoveLoc[4](loc1: &mut NameRecord)
10CopyLoc[2](Arg2: Option<address>)
11Call name_record::set_target_address(&mut NameRecord, Option<address>)
12MoveLoc[0](Arg0: &mut Registry)
13ImmBorrowLoc[1](Arg1: Domain)
14MoveLoc[3](loc0: Option<address>)
15MoveLoc[2](Arg2: Option<address>)
16Call handle_invalidate_reverse_record(&mut Registry, &Domain, Option<address>, Option<address>)
17Ret
}
public unset_reverse_lookup(Arg0: &mut Registry, Arg1: address) {
B0:
0MoveLoc[0](Arg0: &mut Registry)
1MutBorrowField[1](Registry.reverse_registry: Table<address, Domain>)
2MoveLoc[1](Arg1: address)
3Call table::remove<address, Domain>(&mut Table<address, Domain>, address): Domain
4Pop
5Ret
}
public set_reverse_lookup(Arg0: &mut Registry, Arg1: address, Arg2: Domain) {
L3: loc0: Option<address>
B0:
0CopyLoc[0](Arg0: &mut Registry)
1ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2CopyLoc[2](Arg2: Domain)
3Call table::borrow<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): &NameRecord
4Call name_record::target_address(&NameRecord): Option<address>
5StLoc[3](loc0: Option<address>)
6ImmBorrowLoc[3](loc0: Option<address>)
7Call option::is_some<address>(&Option<address>): bool
8BrFalse(10)
B1:
9Branch(14)
B2:
10MoveLoc[0](Arg0: &mut Registry)
11Pop
12LdConst[5](u64: 5)
13Abort
B3:
14CopyLoc[1](Arg1: address)
15Call option::some<address>(address): Option<address>
16MoveLoc[3](loc0: Option<address>)
17Eq
18BrFalse(20)
B4:
19Branch(24)
B5:
20MoveLoc[0](Arg0: &mut Registry)
21Pop
22LdConst[4](u64: 4)
23Abort
B6:
24CopyLoc[0](Arg0: &mut Registry)
25ImmBorrowField[1](Registry.reverse_registry: Table<address, Domain>)
26CopyLoc[1](Arg1: address)
27Call table::contains<address, Domain>(&Table<address, Domain>, address): bool
28BrFalse(36)
B7:
29MoveLoc[2](Arg2: Domain)
30MoveLoc[0](Arg0: &mut Registry)
31MutBorrowField[1](Registry.reverse_registry: Table<address, Domain>)
32MoveLoc[1](Arg1: address)
33Call table::borrow_mut<address, Domain>(&mut Table<address, Domain>, address): &mut Domain
34WriteRef
35Branch(41)
B8:
36MoveLoc[0](Arg0: &mut Registry)
37MutBorrowField[1](Registry.reverse_registry: Table<address, Domain>)
38MoveLoc[1](Arg1: address)
39MoveLoc[2](Arg2: Domain)
40Call table::add<address, Domain>(&mut Table<address, Domain>, address, Domain)
B9:
41Ret
}
public set_expiration_timestamp_ms(Arg0: &mut Registry, Arg1: &mut SuinsRegistration, Arg2: Domain, Arg3: u64) {
L4: loc0: &mut NameRecord
B0:
0MoveLoc[0](Arg0: &mut Registry)
1MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2MoveLoc[2](Arg2: Domain)
3Call table::borrow_mut<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain): &mut NameRecord
4StLoc[4](loc0: &mut NameRecord)
5CopyLoc[1](Arg1: &mut SuinsRegistration)
6FreezeRef
7Call object::id<SuinsRegistration>(&SuinsRegistration): ID
8CopyLoc[4](loc0: &mut NameRecord)
9FreezeRef
10Call name_record::nft_id(&NameRecord): ID
11Eq
12BrFalse(14)
B1:
13Branch(20)
B2:
14MoveLoc[4](loc0: &mut NameRecord)
15Pop
16MoveLoc[1](Arg1: &mut SuinsRegistration)
17Pop
18LdConst[2](u64: 2)
19Abort
B3:
20MoveLoc[4](loc0: &mut NameRecord)
21CopyLoc[3](Arg3: u64)
22Call name_record::set_expiration_timestamp_ms(&mut NameRecord, u64)
23MoveLoc[1](Arg1: &mut SuinsRegistration)
24MoveLoc[3](Arg3: u64)
25Call suins_registration::set_expiration_timestamp_ms(&mut SuinsRegistration, u64)
26Ret
}
public set_data(Arg0: &mut Registry, Arg1: Domain, Arg2: VecMap<String, String>) {
B0:
0MoveLoc[0](Arg0: &mut Registry)
1MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2MoveLoc[1](Arg1: Domain)
3Call table::borrow_mut<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain): &mut NameRecord
4MoveLoc[2](Arg2: VecMap<String, String>)
5Call name_record::set_data(&mut NameRecord, VecMap<String, String>)
6Ret
}
public has_record(Arg0: &Registry, Arg1: Domain): bool {
B0:
0MoveLoc[0](Arg0: &Registry)
1ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2MoveLoc[1](Arg1: Domain)
3Call table::contains<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): bool
4Ret
}
public lookup(Arg0: &Registry, Arg1: Domain): Option<NameRecord> {
L2: loc0: Option<NameRecord>
B0:
0CopyLoc[0](Arg0: &Registry)
1ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2CopyLoc[1](Arg1: Domain)
3Call table::contains<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): bool
4BrFalse(13)
B1:
5MoveLoc[0](Arg0: &Registry)
6ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
7MoveLoc[1](Arg1: Domain)
8Call table::borrow<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): &NameRecord
9ReadRef
10Call option::some<NameRecord>(NameRecord): Option<NameRecord>
11StLoc[2](loc0: Option<NameRecord>)
12Branch(17)
B2:
13MoveLoc[0](Arg0: &Registry)
14Pop
15Call option::none<NameRecord>(): Option<NameRecord>
16StLoc[2](loc0: Option<NameRecord>)
B3:
17MoveLoc[2](loc0: Option<NameRecord>)
18Ret
}
public reverse_lookup(Arg0: &Registry, Arg1: address): Option<Domain> {
L2: loc0: Option<Domain>
B0:
0CopyLoc[0](Arg0: &Registry)
1ImmBorrowField[1](Registry.reverse_registry: Table<address, Domain>)
2CopyLoc[1](Arg1: address)
3Call table::contains<address, Domain>(&Table<address, Domain>, address): bool
4BrFalse(13)
B1:
5MoveLoc[0](Arg0: &Registry)
6ImmBorrowField[1](Registry.reverse_registry: Table<address, Domain>)
7MoveLoc[1](Arg1: address)
8Call table::borrow<address, Domain>(&Table<address, Domain>, address): &Domain
9ReadRef
10Call option::some<Domain>(Domain): Option<Domain>
11StLoc[2](loc0: Option<Domain>)
12Branch(17)
B2:
13MoveLoc[0](Arg0: &Registry)
14Pop
15Call option::none<Domain>(): Option<Domain>
16StLoc[2](loc0: Option<Domain>)
B3:
17MoveLoc[2](loc0: Option<Domain>)
18Ret
}
public assert_nft_is_authorized(Arg0: &Registry, Arg1: &SuinsRegistration, Arg2: &Clock) {
L3: loc0: Domain
L4: loc1: &NameRecord
B0:
0CopyLoc[1](Arg1: &SuinsRegistration)
1Call suins_registration::domain(&SuinsRegistration): Domain
2StLoc[3](loc0: Domain)
3MoveLoc[0](Arg0: &Registry)
4ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
5MoveLoc[3](loc0: Domain)
6Call table::borrow<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): &NameRecord
7StLoc[4](loc1: &NameRecord)
8CopyLoc[1](Arg1: &SuinsRegistration)
9Call object::id<SuinsRegistration>(&SuinsRegistration): ID
10CopyLoc[4](loc1: &NameRecord)
11Call name_record::nft_id(&NameRecord): ID
12Eq
13BrFalse(15)
B1:
14Branch(23)
B2:
15MoveLoc[4](loc1: &NameRecord)
16Pop
17MoveLoc[1](Arg1: &SuinsRegistration)
18Pop
19MoveLoc[2](Arg2: &Clock)
20Pop
21LdConst[2](u64: 2)
22Abort
B3:
23MoveLoc[4](loc1: &NameRecord)
24CopyLoc[2](Arg2: &Clock)
25Call name_record::has_expired(&NameRecord, &Clock): bool
26Not
27BrFalse(29)
B4:
28Branch(35)
B5:
29MoveLoc[1](Arg1: &SuinsRegistration)
30Pop
31MoveLoc[2](Arg2: &Clock)
32Pop
33LdConst[3](u64: 3)
34Abort
B6:
35MoveLoc[1](Arg1: &SuinsRegistration)
36MoveLoc[2](Arg2: &Clock)
37Call suins_registration::has_expired(&SuinsRegistration, &Clock): bool
38Not
39BrFalse(41)
B7:
40Branch(43)
B8:
41LdConst[0](u64: 0)
42Abort
B9:
43Ret
}
public get_data(Arg0: &Registry, Arg1: Domain): &VecMap<String, String> {
B0:
0MoveLoc[0](Arg0: &Registry)
1ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2MoveLoc[1](Arg1: Domain)
3Call table::borrow<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): &NameRecord
4Call name_record::data(&NameRecord): &VecMap<String, String>
5Ret
}
is_leaf_record(Arg0: &Registry, Arg1: Domain): bool {
L2: loc0: Option<NameRecord>
B0:
0ImmBorrowLoc[1](Arg1: Domain)
1Call domain::is_subdomain(&Domain): bool
2Not
3BrFalse(8)
B1:
4MoveLoc[0](Arg0: &Registry)
5Pop
6LdFalse
7Ret
B2:
8MoveLoc[0](Arg0: &Registry)
9MoveLoc[1](Arg1: Domain)
10Call lookup(&Registry, Domain): Option<NameRecord>
11StLoc[2](loc0: Option<NameRecord>)
12ImmBorrowLoc[2](loc0: Option<NameRecord>)
13Call option::is_none<NameRecord>(&Option<NameRecord>): bool
14BrFalse(17)
B3:
15LdFalse
16Ret
B4:
17ImmBorrowLoc[2](loc0: Option<NameRecord>)
18Call option::borrow<NameRecord>(&Option<NameRecord>): &NameRecord
19Call name_record::is_leaf_record(&NameRecord): bool
20Ret
}
internal_add_record(Arg0: &mut Registry, Arg1: Domain, Arg2: u8, Arg3: &Clock, Arg4: bool, Arg5: &mut TxContext): SuinsRegistration {
L6: loc0: NameRecord
L7: loc1: SuinsRegistration
B0:
0CopyLoc[0](Arg0: &mut Registry)
1CopyLoc[1](Arg1: Domain)
2CopyLoc[3](Arg3: &Clock)
3MoveLoc[4](Arg4: bool)
4Call remove_existing_record_if_expired(&mut Registry, Domain, &Clock, bool)
5CopyLoc[1](Arg1: Domain)
6MoveLoc[2](Arg2: u8)
7MoveLoc[3](Arg3: &Clock)
8MoveLoc[5](Arg5: &mut TxContext)
9Call suins_registration::new(Domain, u8, &Clock, &mut TxContext): SuinsRegistration
10StLoc[7](loc1: SuinsRegistration)
11ImmBorrowLoc[7](loc1: SuinsRegistration)
12Call object::id<SuinsRegistration>(&SuinsRegistration): ID
13ImmBorrowLoc[7](loc1: SuinsRegistration)
14Call suins_registration::expiration_timestamp_ms(&SuinsRegistration): u64
15Call name_record::new(ID, u64): NameRecord
16StLoc[6](loc0: NameRecord)
17MoveLoc[0](Arg0: &mut Registry)
18MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
19MoveLoc[1](Arg1: Domain)
20MoveLoc[6](loc0: NameRecord)
21Call table::add<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain, NameRecord)
22MoveLoc[7](loc1: SuinsRegistration)
23Ret
}
remove_existing_record_if_expired(Arg0: &mut Registry, Arg1: Domain, Arg2: &Clock, Arg3: bool) {
L4: loc0: Option<NameRecord>
L5: loc1: &NameRecord
L6: loc2: NameRecord
B0:
0CopyLoc[0](Arg0: &mut Registry)
1ImmBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2CopyLoc[1](Arg1: Domain)
3Call table::contains<Domain, NameRecord>(&Table<Domain, NameRecord>, Domain): bool
4Not
5BrFalse(11)
B1:
6MoveLoc[0](Arg0: &mut Registry)
7Pop
8MoveLoc[2](Arg2: &Clock)
9Pop
10Ret
B2:
11CopyLoc[0](Arg0: &mut Registry)
12MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
13CopyLoc[1](Arg1: Domain)
14Call table::remove<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain): NameRecord
15StLoc[6](loc2: NameRecord)
16ImmBorrowLoc[6](loc2: NameRecord)
17Call name_record::is_leaf_record(&NameRecord): bool
18BrFalse(54)
B3:
19CopyLoc[0](Arg0: &mut Registry)
20FreezeRef
21ImmBorrowLoc[1](Arg1: Domain)
22Call domain::parent(&Domain): Domain
23Call lookup(&Registry, Domain): Option<NameRecord>
24StLoc[4](loc0: Option<NameRecord>)
25ImmBorrowLoc[4](loc0: Option<NameRecord>)
26Call option::is_some<NameRecord>(&Option<NameRecord>): bool
27BrFalse(51)
B4:
28ImmBorrowLoc[4](loc0: Option<NameRecord>)
29Call option::borrow<NameRecord>(&Option<NameRecord>): &NameRecord
30StLoc[5](loc1: &NameRecord)
31CopyLoc[5](loc1: &NameRecord)
32Call name_record::nft_id(&NameRecord): ID
33ImmBorrowLoc[6](loc2: NameRecord)
34Call name_record::nft_id(&NameRecord): ID
35Eq
36BrFalse(46)
B5:
37MoveLoc[5](loc1: &NameRecord)
38MoveLoc[2](Arg2: &Clock)
39Call name_record::has_expired(&NameRecord, &Clock): bool
40BrFalse(42)
B6:
41Branch(74)
B7:
42MoveLoc[0](Arg0: &mut Registry)
43Pop
44LdConst[1](u64: 1)
45Abort
B8:
46MoveLoc[5](loc1: &NameRecord)
47Pop
48MoveLoc[2](Arg2: &Clock)
49Pop
50Branch(74)
B9:
51MoveLoc[2](Arg2: &Clock)
52Pop
53Branch(74)
B10:
54MoveLoc[3](Arg3: bool)
55BrFalse(65)
B11:
56ImmBorrowLoc[6](loc2: NameRecord)
57MoveLoc[2](Arg2: &Clock)
58Call name_record::has_expired_past_grace_period(&NameRecord, &Clock): bool
59BrFalse(61)
B12:
60Branch(74)
B13:
61MoveLoc[0](Arg0: &mut Registry)
62Pop
63LdConst[1](u64: 1)
64Abort
B14:
65ImmBorrowLoc[6](loc2: NameRecord)
66MoveLoc[2](Arg2: &Clock)
67Call name_record::has_expired(&NameRecord, &Clock): bool
68BrFalse(70)
B15:
69Branch(74)
B16:
70MoveLoc[0](Arg0: &mut Registry)
71Pop
72LdConst[1](u64: 1)
73Abort
B17:
74MoveLoc[0](Arg0: &mut Registry)
75ImmBorrowLoc[1](Arg1: Domain)
76ImmBorrowLoc[6](loc2: NameRecord)
77Call name_record::target_address(&NameRecord): Option<address>
78Call option::none<address>(): Option<address>
79Call handle_invalidate_reverse_record(&mut Registry, &Domain, Option<address>, Option<address>)
80Ret
}
remove_record_and_invalidate_reverse(Arg0: &mut Registry, Arg1: Domain) {
L2: loc0: NameRecord
B0:
0CopyLoc[0](Arg0: &mut Registry)
1MutBorrowField[0](Registry.registry: Table<Domain, NameRecord>)
2CopyLoc[1](Arg1: Domain)
3Call table::remove<Domain, NameRecord>(&mut Table<Domain, NameRecord>, Domain): NameRecord
4StLoc[2](loc0: NameRecord)
5MoveLoc[0](Arg0: &mut Registry)
6ImmBorrowLoc[1](Arg1: Domain)
7ImmBorrowLoc[2](loc0: NameRecord)
8Call name_record::target_address(&NameRecord): Option<address>
9Call option::none<address>(): Option<address>
10Call handle_invalidate_reverse_record(&mut Registry, &Domain, Option<address>, Option<address>)
11Ret
}
handle_invalidate_reverse_record(Arg0: &mut Registry, Arg1: &Domain, Arg2: Option<address>, Arg3: Option<address>) {
L4: loc0: address
L5: loc1: &mut Table<address, Domain>
B0:
0CopyLoc[2](Arg2: Option<address>)
1MoveLoc[3](Arg3: Option<address>)
2Eq
3BrFalse(9)
B1:
4MoveLoc[0](Arg0: &mut Registry)
5Pop
6MoveLoc[1](Arg1: &Domain)
7Pop
8Ret
B2:
9ImmBorrowLoc[2](Arg2: Option<address>)
10Call option::is_none<address>(&Option<address>): bool
11BrFalse(17)
B3:
12MoveLoc[0](Arg0: &mut Registry)
13Pop
14MoveLoc[1](Arg1: &Domain)
15Pop
16Ret
B4:
17MoveLoc[2](Arg2: Option<address>)
18Call option::destroy_some<address>(Option<address>): address
19StLoc[4](loc0: address)
20MoveLoc[0](Arg0: &mut Registry)
21MutBorrowField[1](Registry.reverse_registry: Table<address, Domain>)
22StLoc[5](loc1: &mut Table<address, Domain>)
23CopyLoc[5](loc1: &mut Table<address, Domain>)
24FreezeRef
25CopyLoc[4](loc0: address)
26Call table::contains<address, Domain>(&Table<address, Domain>, address): bool
27BrFalse(43)
B5:
28CopyLoc[5](loc1: &mut Table<address, Domain>)
29FreezeRef
30CopyLoc[4](loc0: address)
31Call table::borrow<address, Domain>(&Table<address, Domain>, address): &Domain
32MoveLoc[1](Arg1: &Domain)
33Eq
34BrFalse(40)
B6:
35MoveLoc[5](loc1: &mut Table<address, Domain>)
36MoveLoc[4](loc0: address)
37Call table::remove<address, Domain>(&mut Table<address, Domain>, address): Domain
38Pop
39Branch(47)
B7:
40MoveLoc[5](loc1: &mut Table<address, Domain>)
41Pop
42Branch(47)
B8:
43MoveLoc[5](loc1: &mut Table<address, Domain>)
44Pop
45MoveLoc[1](Arg1: &Domain)
46Pop
B9:
47Ret
}
Constants [
0 => u64: 0
1 => u64: 1
2 => u64: 2
3 => u64: 3
4 => u64: 4
5 => u64: 5
6 => u64: 6
7 => u64: 7
8 => u64: 8
]
}