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

API

domain

Module0x5580…2003
Move path
0xd22b…08f0::domain
Functions
129 public, 0 entry
Structs
1
Friend modules
None
domain

Bytecode452 lines

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

// Move bytecode v7
module d22b24490e0bae52676651b4f56660a5ff8022a2576e0089f79b3c88d44e08f0.domain {
use 0000000000000000000000000000000000000000000000000000000000000001::string;
use 0000000000000000000000000000000000000000000000000000000000000001::vector;
 
struct Domain has copy, drop, store {
labels: vector<String>
}
 
public new(Arg0: String): Domain {
L1: loc0: vector<String>
B0:
0ImmBorrowLoc[0](Arg0: String)
1Call string::length(&String): u64
2LdConst[1](u64: 235)
3Le
4BrFalse(6)
B1:
5Branch(8)
B2:
6LdConst[0](u64: 0)
7Abort
B3:
8MoveLoc[0](Arg0: String)
9Call split_by_dot(String): vector<String>
10StLoc[1](loc0: vector<String>)
11ImmBorrowLoc[1](loc0: vector<String>)
12Call validate_labels(&vector<String>)
13MutBorrowLoc[1](loc0: vector<String>)
14Call vector::reverse<String>(&mut vector<String>)
15MoveLoc[1](loc0: vector<String>)
16Pack[0](Domain)
17Ret
}
 
public to_string(Arg0: &Domain): String {
L1: loc0: String
L2: loc1: u64
L3: loc2: u64
L4: loc3: String
L5: loc4: &String
B0:
0LdConst[4](vector<u8>: "." ..)
1Call string::utf8(vector<u8>): String
2StLoc[1](loc0: String)
3CopyLoc[0](Arg0: &Domain)
4ImmBorrowField[0](Domain.labels: vector<String>)
5VecLen(0)
6StLoc[3](loc2: u64)
7LdU64(0)
8StLoc[2](loc1: u64)
9VecPack(14, 0)
10Call string::utf8(vector<u8>): String
11StLoc[4](loc3: String)
B1:
12CopyLoc[2](loc1: u64)
13CopyLoc[3](loc2: u64)
14Lt
15BrFalse(42)
B2:
16Branch(17)
B3:
17CopyLoc[0](Arg0: &Domain)
18ImmBorrowField[0](Domain.labels: vector<String>)
19CopyLoc[3](loc2: u64)
20CopyLoc[2](loc1: u64)
21Sub
22LdU64(1)
23Sub
24VecImmBorrow(0)
25StLoc[5](loc4: &String)
26MutBorrowLoc[4](loc3: String)
27MoveLoc[5](loc4: &String)
28ReadRef
29Call string::append(&mut String, String)
30MoveLoc[2](loc1: u64)
31LdU64(1)
32Add
33StLoc[2](loc1: u64)
34CopyLoc[2](loc1: u64)
35CopyLoc[3](loc2: u64)
36Neq
37BrFalse(12)
B4:
38MutBorrowLoc[4](loc3: String)
39CopyLoc[1](loc0: String)
40Call string::append(&mut String, String)
41Branch(12)
B5:
42MoveLoc[0](Arg0: &Domain)
43Pop
44MoveLoc[4](loc3: String)
45Ret
}
 
public label(Arg0: &Domain, Arg1: u64): &String {
B0:
0MoveLoc[0](Arg0: &Domain)
1ImmBorrowField[0](Domain.labels: vector<String>)
2MoveLoc[1](Arg1: u64)
3VecImmBorrow(0)
4Ret
}
 
public tld(Arg0: &Domain): &String {
B0:
0MoveLoc[0](Arg0: &Domain)
1LdU64(0)
2Call label(&Domain, u64): &String
3Ret
}
 
public sld(Arg0: &Domain): &String {
B0:
0MoveLoc[0](Arg0: &Domain)
1LdU64(1)
2Call label(&Domain, u64): &String
3Ret
}
 
public number_of_levels(Arg0: &Domain): u64 {
B0:
0MoveLoc[0](Arg0: &Domain)
1ImmBorrowField[0](Domain.labels: vector<String>)
2VecLen(0)
3Ret
}
 
public is_subdomain(Arg0: &Domain): bool {
B0:
0MoveLoc[0](Arg0: &Domain)
1Call number_of_levels(&Domain): u64
2LdU64(2)
3Gt
4Ret
}
 
public parent(Arg0: &Domain): Domain {
L1: loc0: vector<String>
B0:
0MoveLoc[0](Arg0: &Domain)
1ImmBorrowField[0](Domain.labels: vector<String>)
2ReadRef
3StLoc[1](loc0: vector<String>)
4MutBorrowLoc[1](loc0: vector<String>)
5VecPopBack(0)
6Pop
7MoveLoc[1](loc0: vector<String>)
8Pack[0](Domain)
9Ret
}
 
public is_parent_of(Arg0: &Domain, Arg1: &Domain): bool {
L2: loc0: bool
L3: loc1: Domain
B0:
0CopyLoc[0](Arg0: &Domain)
1Call number_of_levels(&Domain): u64
2CopyLoc[1](Arg1: &Domain)
3Call number_of_levels(&Domain): u64
4Lt
5BrFalse(16)
B1:
6MoveLoc[1](Arg1: &Domain)
7Call parent(&Domain): Domain
8StLoc[3](loc1: Domain)
9ImmBorrowLoc[3](loc1: Domain)
10ImmBorrowField[0](Domain.labels: vector<String>)
11MoveLoc[0](Arg0: &Domain)
12ImmBorrowField[0](Domain.labels: vector<String>)
13Eq
14StLoc[2](loc0: bool)
15Branch(22)
B2:
16MoveLoc[0](Arg0: &Domain)
17Pop
18MoveLoc[1](Arg1: &Domain)
19Pop
20LdFalse
21StLoc[2](loc0: bool)
B3:
22MoveLoc[2](loc0: bool)
23Ret
}
 
validate_labels(Arg0: &vector<String>) {
L1: loc0: u64
L2: loc1: u64
B0:
0CopyLoc[0](Arg0: &vector<String>)
1Call vector::is_empty<String>(&vector<String>): bool
2Not
3BrFalse(5)
B1:
4Branch(9)
B2:
5MoveLoc[0](Arg0: &vector<String>)
6Pop
7LdConst[0](u64: 0)
8Abort
B3:
9CopyLoc[0](Arg0: &vector<String>)
10VecLen(0)
11StLoc[2](loc1: u64)
12LdU64(0)
13StLoc[1](loc0: u64)
B4:
14CopyLoc[1](loc0: u64)
15CopyLoc[2](loc1: u64)
16Lt
17BrFalse(33)
B5:
18CopyLoc[0](Arg0: &vector<String>)
19CopyLoc[1](loc0: u64)
20VecImmBorrow(0)
21Call is_valid_label(&String): bool
22BrFalse(24)
B6:
23Branch(28)
B7:
24MoveLoc[0](Arg0: &vector<String>)
25Pop
26LdConst[0](u64: 0)
27Abort
B8:
28MoveLoc[1](loc0: u64)
29LdU64(1)
30Add
31StLoc[1](loc0: u64)
32Branch(14)
B9:
33MoveLoc[0](Arg0: &vector<String>)
34Pop
35Ret
}
 
is_valid_label(Arg0: &String): bool {
L1: loc0: bool
L2: loc1: bool
L3: loc2: bool
L4: loc3: bool
L5: loc4: bool
L6: loc5: u8
L7: loc6: u64
L8: loc7: &vector<u8>
L9: loc8: u64
B0:
0CopyLoc[0](Arg0: &String)
1Call string::length(&String): u64
2StLoc[9](loc8: u64)
3MoveLoc[0](Arg0: &String)
4Call string::as_bytes(&String): &vector<u8>
5StLoc[8](loc7: &vector<u8>)
6LdU64(0)
7StLoc[7](loc6: u64)
8CopyLoc[9](loc8: u64)
9LdConst[2](u64: 1)
10Ge
11BrFalse(17)
B1:
12CopyLoc[9](loc8: u64)
13LdConst[3](u64: 63)
14Le
15StLoc[1](loc0: bool)
16Branch(19)
B2:
17LdFalse
18StLoc[1](loc0: bool)
B3:
19MoveLoc[1](loc0: bool)
20Not
21BrFalse(26)
B4:
22MoveLoc[8](loc7: &vector<u8>)
23Pop
24LdFalse
25Ret
B5:
26CopyLoc[7](loc6: u64)
27CopyLoc[9](loc8: u64)
28Lt
29BrFalse(101)
B6:
30CopyLoc[8](loc7: &vector<u8>)
31CopyLoc[7](loc6: u64)
32VecImmBorrow(14)
33ReadRef
34StLoc[6](loc5: u8)
35LdU8(97)
36CopyLoc[6](loc5: u8)
37Le
38BrFalse(44)
B7:
39CopyLoc[6](loc5: u8)
40LdU8(122)
41Le
42StLoc[5](loc4: bool)
43Branch(46)
B8:
44LdFalse
45StLoc[5](loc4: bool)
B9:
46MoveLoc[5](loc4: bool)
47BrFalse(51)
B10:
48LdTrue
49StLoc[2](loc1: bool)
50Branch(89)
B11:
51LdU8(48)
52CopyLoc[6](loc5: u8)
53Le
54BrFalse(60)
B12:
55CopyLoc[6](loc5: u8)
56LdU8(57)
57Le
58StLoc[4](loc3: bool)
59Branch(62)
B13:
60LdFalse
61StLoc[4](loc3: bool)
B14:
62MoveLoc[4](loc3: bool)
63BrFalse(67)
B15:
64LdTrue
65StLoc[2](loc1: bool)
66Branch(89)
B16:
67MoveLoc[6](loc5: u8)
68LdU8(45)
69Eq
70BrFalse(85)
B17:
71CopyLoc[7](loc6: u64)
72LdU64(0)
73Neq
74BrFalse(82)
B18:
75CopyLoc[7](loc6: u64)
76CopyLoc[9](loc8: u64)
77LdU64(1)
78Sub
79Neq
80StLoc[3](loc2: bool)
81Branch(87)
B19:
82LdFalse
83StLoc[3](loc2: bool)
84Branch(87)
B20:
85LdFalse
86StLoc[3](loc2: bool)
B21:
87MoveLoc[3](loc2: bool)
88StLoc[2](loc1: bool)
B22:
89MoveLoc[2](loc1: bool)
90Not
91BrFalse(96)
B23:
92MoveLoc[8](loc7: &vector<u8>)
93Pop
94LdFalse
95Ret
B24:
96MoveLoc[7](loc6: u64)
97LdU64(1)
98Add
99StLoc[7](loc6: u64)
100Branch(26)
B25:
101MoveLoc[8](loc7: &vector<u8>)
102Pop
103LdTrue
104Ret
}
 
split_by_dot(Arg0: String): vector<String> {
L1: loc0: u64
L2: loc1: String
L3: loc2: u64
L4: loc3: u64
L5: loc4: String
L6: loc5: vector<String>
L7: loc6: u64
B0:
0LdConst[4](vector<u8>: "." ..)
1Call string::utf8(vector<u8>): String
2StLoc[2](loc1: String)
3VecPack(0, 0)
4StLoc[6](loc5: vector<String>)
B1:
5ImmBorrowLoc[0](Arg0: String)
6Call string::is_empty(&String): bool
7Not
8BrFalse(44)
B2:
9Branch(10)
B3:
10ImmBorrowLoc[0](Arg0: String)
11ImmBorrowLoc[2](loc1: String)
12Call string::index_of(&String, &String): u64
13StLoc[3](loc2: u64)
14ImmBorrowLoc[0](Arg0: String)
15LdU64(0)
16CopyLoc[3](loc2: u64)
17Call string::substring(&String, u64, u64): String
18StLoc[5](loc4: String)
19MutBorrowLoc[6](loc5: vector<String>)
20MoveLoc[5](loc4: String)
21VecPushBack(0)
22ImmBorrowLoc[0](Arg0: String)
23Call string::length(&String): u64
24StLoc[4](loc3: u64)
25CopyLoc[3](loc2: u64)
26CopyLoc[4](loc3: u64)
27Eq
28BrFalse(32)
B4:
29CopyLoc[4](loc3: u64)
30StLoc[1](loc0: u64)
31Branch(36)
B5:
32MoveLoc[3](loc2: u64)
33LdU64(1)
34Add
35StLoc[1](loc0: u64)
B6:
36MoveLoc[1](loc0: u64)
37StLoc[7](loc6: u64)
38ImmBorrowLoc[0](Arg0: String)
39MoveLoc[7](loc6: u64)
40MoveLoc[4](loc3: u64)
41Call string::substring(&String, u64, u64): String
42StLoc[0](Arg0: String)
43Branch(5)
B7:
44MoveLoc[6](loc5: vector<String>)
45Ret
}
 
Constants [
0 => u64: 0
1 => u64: 235
2 => u64: 1
3 => u64: 63
4 => vector<u8>: "." // interpreted as UTF8 string
]
}