controller
Module0x00c2…d6f5
- Move path
- 0xd22b…08f0::controller
- Functions
- 50 public, 5 entry
- Structs
- 1
- Friend modules
- None
controller
Bytecode416 lines
The on-chain disassembly. Offsets are bytecode positions within each function.
// Move bytecode v7
module d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0.controller {
use 0000000000000000000000000000000000000000000000000000000000000001::option;
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
use 0000000000000000000000000000000000000000000000000000000000000002::clock;
use 0000000000000000000000000000000000000000000000000000000000000002::event;
use 0000000000000000000000000000000000000000000000000000000000000002::object;
use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
use 0000000000000000000000000000000000000000000000000000000000000002::vec_map;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::domain;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::registry;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::subdomain_registration;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins;
use d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0::suins_registration;
struct SubnamePrunedEvent has copy, drop {
subdomain: Domain,
parent_domain: Domain
}
struct ControllerV2 has drop {
dummy_field: bool
}
struct Controller has drop {
dummy_field: bool
}
public set_target_address(Arg0: &mut SuiNS, Arg1: &SuinsRegistration, Arg2: Option<address>, Arg3: &Clock) {
L4: loc0: Domain
L5: loc1: &mut Registry
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2StLoc[5](loc1: &mut Registry)
3CopyLoc[5](loc1: &mut Registry)
4FreezeRef
5CopyLoc[1](Arg1: &SuinsRegistration)
6MoveLoc[3](Arg3: &Clock)
7Call registry::assert_nft_is_authorized(&Registry, &SuinsRegistration, &Clock)
8MoveLoc[1](Arg1: &SuinsRegistration)
9Call suins_registration::domain(&SuinsRegistration): Domain
10StLoc[4](loc0: Domain)
11MoveLoc[5](loc1: &mut Registry)
12MoveLoc[4](loc0: Domain)
13MoveLoc[2](Arg2: Option<address>)
14Call registry::set_target_address(&mut Registry, Domain, Option<address>)
15Ret
}
public set_reverse_lookup(Arg0: &mut SuiNS, Arg1: String, Arg2: &TxContext) {
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2MoveLoc[2](Arg2: &TxContext)
3Call tx_context::sender(&TxContext): address
4MoveLoc[1](Arg1: String)
5Call domain::new(String): Domain
6Call registry::set_reverse_lookup(&mut Registry, address, Domain)
7Ret
}
public unset_reverse_lookup(Arg0: &mut SuiNS, Arg1: &TxContext) {
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2MoveLoc[1](Arg1: &TxContext)
3Call tx_context::sender(&TxContext): address
4Call registry::unset_reverse_lookup(&mut Registry, address)
5Ret
}
public set_object_reverse_lookup(Arg0: &mut SuiNS, Arg1: &mut UID, Arg2: String) {
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2MoveLoc[1](Arg1: &mut UID)
3FreezeRef
4Call object::uid_to_address(&UID): address
5MoveLoc[2](Arg2: String)
6Call domain::new(String): Domain
7Call registry::set_reverse_lookup(&mut Registry, address, Domain)
8Ret
}
public unset_object_reverse_lookup(Arg0: &mut SuiNS, Arg1: &mut UID) {
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2MoveLoc[1](Arg1: &mut UID)
3FreezeRef
4Call object::uid_to_address(&UID): address
5Call registry::unset_reverse_lookup(&mut Registry, address)
6Ret
}
public set_user_data(Arg0: &mut SuiNS, Arg1: &SuinsRegistration, Arg2: String, Arg3: String, Arg4: &Clock) {
L5: loc0: bool
L6: loc1: VecMap<String, String>
L7: loc2: Domain
L8: loc3: vector<u8>
L9: loc4: &mut Registry
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2StLoc[9](loc4: &mut Registry)
3CopyLoc[9](loc4: &mut Registry)
4FreezeRef
5CopyLoc[1](Arg1: &SuinsRegistration)
6Call suins_registration::domain(&SuinsRegistration): Domain
7Call registry::get_data(&Registry, Domain): &VecMap<String, String>
8ReadRef
9StLoc[6](loc1: VecMap<String, String>)
10CopyLoc[1](Arg1: &SuinsRegistration)
11Call suins_registration::domain(&SuinsRegistration): Domain
12StLoc[7](loc2: Domain)
13CopyLoc[9](loc4: &mut Registry)
14FreezeRef
15MoveLoc[1](Arg1: &SuinsRegistration)
16MoveLoc[4](Arg4: &Clock)
17Call registry::assert_nft_is_authorized(&Registry, &SuinsRegistration, &Clock)
18ImmBorrowLoc[2](Arg2: String)
19Call string::as_bytes(&String): &vector<u8>
20ReadRef
21StLoc[8](loc3: vector<u8>)
22CopyLoc[8](loc3: vector<u8>)
23LdConst[0](vector<u8>: "ava..)
24Eq
25BrFalse(29)
B1:
26LdTrue
27StLoc[5](loc0: bool)
28Branch(40)
B2:
29CopyLoc[8](loc3: vector<u8>)
30LdConst[1](vector<u8>: "con..)
31Eq
32BrFalse(36)
B3:
33LdTrue
34StLoc[5](loc0: bool)
35Branch(40)
B4:
36MoveLoc[8](loc3: vector<u8>)
37LdConst[2](vector<u8>: "wal..)
38Eq
39StLoc[5](loc0: bool)
B5:
40MoveLoc[5](loc0: bool)
41BrFalse(43)
B6:
42Branch(47)
B7:
43MoveLoc[9](loc4: &mut Registry)
44Pop
45LdConst[3](u64: 0)
46Abort
B8:
47ImmBorrowLoc[6](loc1: VecMap<String, String>)
48ImmBorrowLoc[2](Arg2: String)
49Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
50BrFalse(56)
B9:
51MutBorrowLoc[6](loc1: VecMap<String, String>)
52ImmBorrowLoc[2](Arg2: String)
53Call vec_map::remove<String, String>(&mut VecMap<String, String>, &String): String * String
54Pop
55Pop
B10:
56MutBorrowLoc[6](loc1: VecMap<String, String>)
57MoveLoc[2](Arg2: String)
58MoveLoc[3](Arg3: String)
59Call vec_map::insert<String, String>(&mut VecMap<String, String>, String, String)
60MoveLoc[9](loc4: &mut Registry)
61MoveLoc[7](loc2: Domain)
62MoveLoc[6](loc1: VecMap<String, String>)
63Call registry::set_data(&mut Registry, Domain, VecMap<String, String>)
64Ret
}
public unset_user_data(Arg0: &mut SuiNS, Arg1: &SuinsRegistration, Arg2: String, Arg3: &Clock) {
L4: loc0: VecMap<String, String>
L5: loc1: Domain
L6: loc2: &mut Registry
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2StLoc[6](loc2: &mut Registry)
3CopyLoc[6](loc2: &mut Registry)
4FreezeRef
5CopyLoc[1](Arg1: &SuinsRegistration)
6Call suins_registration::domain(&SuinsRegistration): Domain
7Call registry::get_data(&Registry, Domain): &VecMap<String, String>
8ReadRef
9StLoc[4](loc0: VecMap<String, String>)
10CopyLoc[1](Arg1: &SuinsRegistration)
11Call suins_registration::domain(&SuinsRegistration): Domain
12StLoc[5](loc1: Domain)
13CopyLoc[6](loc2: &mut Registry)
14FreezeRef
15MoveLoc[1](Arg1: &SuinsRegistration)
16MoveLoc[3](Arg3: &Clock)
17Call registry::assert_nft_is_authorized(&Registry, &SuinsRegistration, &Clock)
18ImmBorrowLoc[4](loc0: VecMap<String, String>)
19ImmBorrowLoc[2](Arg2: String)
20Call vec_map::contains<String, String>(&VecMap<String, String>, &String): bool
21BrFalse(27)
B1:
22MutBorrowLoc[4](loc0: VecMap<String, String>)
23ImmBorrowLoc[2](Arg2: String)
24Call vec_map::remove<String, String>(&mut VecMap<String, String>, &String): String * String
25Pop
26Pop
B2:
27MoveLoc[6](loc2: &mut Registry)
28MoveLoc[5](loc1: Domain)
29MoveLoc[4](loc0: VecMap<String, String>)
30Call registry::set_data(&mut Registry, Domain, VecMap<String, String>)
31Ret
}
public burn_expired(Arg0: &mut SuiNS, Arg1: SuinsRegistration, Arg2: &Clock) {
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2MoveLoc[1](Arg1: SuinsRegistration)
3MoveLoc[2](Arg2: &Clock)
4Call registry::burn_registration_object(&mut Registry, SuinsRegistration, &Clock)
5Ret
}
public burn_expired_subname(Arg0: &mut SuiNS, Arg1: SubDomainRegistration, Arg2: &Clock) {
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2MoveLoc[1](Arg1: SubDomainRegistration)
3MoveLoc[2](Arg2: &Clock)
4Call registry::burn_subdomain_object(&mut Registry, SubDomainRegistration, &Clock)
5Ret
}
public prune_expired_subname(Arg0: &mut SuiNS, Arg1: &SuinsRegistration, Arg2: String, Arg3: &Clock) {
L4: loc0: Domain
L5: loc1: &mut Registry
L6: loc2: Domain
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2StLoc[5](loc1: &mut Registry)
3CopyLoc[5](loc1: &mut Registry)
4FreezeRef
5CopyLoc[1](Arg1: &SuinsRegistration)
6CopyLoc[3](Arg3: &Clock)
7Call registry::assert_nft_is_authorized(&Registry, &SuinsRegistration, &Clock)
8MoveLoc[1](Arg1: &SuinsRegistration)
9Call suins_registration::domain(&SuinsRegistration): Domain
10StLoc[4](loc0: Domain)
11MoveLoc[2](Arg2: String)
12Call domain::new(String): Domain
13StLoc[6](loc2: Domain)
14ImmBorrowLoc[6](loc2: Domain)
15Call domain::is_subdomain(&Domain): bool
16BrFalse(18)
B1:
17Branch(24)
B2:
18MoveLoc[5](loc1: &mut Registry)
19Pop
20MoveLoc[3](Arg3: &Clock)
21Pop
22LdConst[5](u64: 2)
23Abort
B3:
24ImmBorrowLoc[4](loc0: Domain)
25ImmBorrowLoc[6](loc2: Domain)
26Call domain::is_parent_of(&Domain, &Domain): bool
27BrFalse(29)
B4:
28Branch(35)
B5:
29MoveLoc[5](loc1: &mut Registry)
30Pop
31MoveLoc[3](Arg3: &Clock)
32Pop
33LdConst[4](u64: 1)
34Abort
B6:
35MoveLoc[5](loc1: &mut Registry)
36CopyLoc[6](loc2: Domain)
37MoveLoc[3](Arg3: &Clock)
38Call registry::prune_expired_subdomain_record(&mut Registry, Domain, &Clock)
39MoveLoc[6](loc2: Domain)
40MoveLoc[4](loc0: Domain)
41Pack[0](SubnamePrunedEvent)
42Call event::emit<SubnamePrunedEvent>(SubnamePrunedEvent)
43Ret
}
public prune_expired_subnames(Arg0: &mut SuiNS, Arg1: &SuinsRegistration, Arg2: vector<String>, Arg3: &Clock): u64 {
L4: loc0: u64
L5: loc1: bool
L6: loc2: u64
L7: loc3: Domain
L8: loc4: u64
L9: loc5: &mut Registry
L10: loc6: u64
L11: loc7: Domain
L12: loc8: vector<String>
B0:
0MoveLoc[0](Arg0: &mut SuiNS)
1Call registry_mut(&mut SuiNS): &mut Registry
2StLoc[9](loc5: &mut Registry)
3CopyLoc[9](loc5: &mut Registry)
4FreezeRef
5CopyLoc[1](Arg1: &SuinsRegistration)
6CopyLoc[3](Arg3: &Clock)
7Call registry::assert_nft_is_authorized(&Registry, &SuinsRegistration, &Clock)
8MoveLoc[1](Arg1: &SuinsRegistration)
9Call suins_registration::domain(&SuinsRegistration): Domain
10StLoc[7](loc3: Domain)
11LdU64(0)
12StLoc[8](loc4: u64)
13MoveLoc[2](Arg2: vector<String>)
14StLoc[12](loc8: vector<String>)
15MutBorrowLoc[12](loc8: vector<String>)
16Call vector::reverse<String>(&mut vector<String>)
17ImmBorrowLoc[12](loc8: vector<String>)
18VecLen(21)
19StLoc[4](loc0: u64)
20LdU64(0)
21StLoc[6](loc2: u64)
22MoveLoc[4](loc0: u64)
23StLoc[10](loc6: u64)
B1:
24CopyLoc[6](loc2: u64)
25CopyLoc[10](loc6: u64)
26Lt
27BrFalse(67)
B2:
28CopyLoc[6](loc2: u64)
29Pop
30MutBorrowLoc[12](loc8: vector<String>)
31VecPopBack(21)
32Call domain::new(String): Domain
33StLoc[11](loc7: Domain)
34ImmBorrowLoc[11](loc7: Domain)
35Call domain::is_subdomain(&Domain): bool
36Not
37BrFalse(41)
B3:
38LdTrue
39StLoc[5](loc1: bool)
40Branch(46)
B4:
41ImmBorrowLoc[7](loc3: Domain)
42ImmBorrowLoc[11](loc7: Domain)
43Call domain::is_parent_of(&Domain, &Domain): bool
44Not
45StLoc[5](loc1: bool)
B5:
46MoveLoc[5](loc1: bool)
47BrFalse(49)
B6:
48Branch(62)
B7:
49CopyLoc[9](loc5: &mut Registry)
50CopyLoc[11](loc7: Domain)
51CopyLoc[3](Arg3: &Clock)
52Call registry::try_prune_expired_subdomain_record(&mut Registry, Domain, &Clock): bool
53BrFalse(62)
B8:
54MoveLoc[8](loc4: u64)
55LdU64(1)
56Add
57StLoc[8](loc4: u64)
58MoveLoc[11](loc7: Domain)
59CopyLoc[7](loc3: Domain)
60Pack[0](SubnamePrunedEvent)
61Call event::emit<SubnamePrunedEvent>(SubnamePrunedEvent)
B9:
62MoveLoc[6](loc2: u64)
63LdU64(1)
64Add
65StLoc[6](loc2: u64)
66Branch(24)
B10:
67MoveLoc[9](loc5: &mut Registry)
68Pop
69MoveLoc[3](Arg3: &Clock)
70Pop
71MoveLoc[12](loc8: vector<String>)
72VecUnpack(21, 0)
73MoveLoc[8](loc4: u64)
74Ret
}
registry_mut(Arg0: &mut SuiNS): &mut Registry {
B0:
0LdFalse
1Pack[1](ControllerV2)
2MoveLoc[0](Arg0: &mut SuiNS)
3Call suins::app_registry_mut<ControllerV2, Registry>(ControllerV2, &mut SuiNS): &mut Registry
4Ret
}
Constants [
0 => vector<u8>: "avatar" // interpreted as UTF8 string
1 => vector<u8>: "content_hash" // interpreted as UTF8 string
2 => vector<u8>: "walrus_site_id" // interpreted as UTF8 string
3 => u64: 0
4 => u64: 1
5 => u64: 2
]
}