Sui mainnet
Home/sui/0x0000…0002/code
Verified source

0x0000…0002

0x0000000000000000000000000000000000000000000000000000000000000002

The pipeline is behind the chain tip0x0000000000000000000000000000000000000000000000000000000000000002

Everything already published is complete and correct; only newer blocks are missing. The chain summary reports this generation as behind the tip.

Verification

Code hash
0x0000000000000000000000000000000000000000000000000000000000000002
Status
full match
Provider
disassembly of package 0x0000000000000000000000000000000000000000000000000000000000000002 as `sui replay` fetched it at the version that executed
Compiler
Language
move-disassembly
Bundle
sha1:cc705040055e33ac64188620fe75641f60048764

Sources

0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/accumulator.mvb0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/accumulator_metadata.mvb0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/accumulator_settlement.mvb0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/dynamic_field.mvb0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/object.mvb0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/tx_context.mvb
0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/accumulator.mvb187 lines
1// Move bytecode v7
2module 2.accumulator {
3use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
4use 0000000000000000000000000000000000000000000000000000000000000002::object;
5use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
6use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
7
8struct AccumulatorRoot has key {
9 id: UID
10}
11
12struct U128 has store {
13 value: u128
14}
15
16struct Key<phantom Ty0> has copy, drop, store {
17 address: address
18}
19
20create(Arg0: &TxContext) {
21B0:
22 0: MoveLoc[0](Arg0: &TxContext)
23 1: Call tx_context::sender(&TxContext): address
24 2: LdConst[1](address: 0x00..)
25 3: Eq
26 4: BrFalse(6)
27B1:
28 5: Branch(8)
29B2:
30 6: LdConst[0](u64: 0)
31 7: Abort
32B3:
33 8: Call object::sui_accumulator_root_object_id(): UID
34 9: Pack[0](AccumulatorRoot)
35 10: Call transfer::share_object<AccumulatorRoot>(AccumulatorRoot)
36 11: Ret
37}
38
39public(friend) root_id(Arg0: &AccumulatorRoot): &UID {
40B0:
41 0: MoveLoc[0](Arg0: &AccumulatorRoot)
42 1: ImmBorrowField[0](AccumulatorRoot.id: UID)
43 2: Ret
44}
45
46public(friend) root_id_mut(Arg0: &mut AccumulatorRoot): &mut UID {
47B0:
48 0: MoveLoc[0](Arg0: &mut AccumulatorRoot)
49 1: MutBorrowField[0](AccumulatorRoot.id: UID)
50 2: Ret
51}
52
53public(friend) accumulator_u128_exists<Ty0>(Arg0: &AccumulatorRoot, Arg1: address): bool {
54B0:
55 0: MoveLoc[0](Arg0: &AccumulatorRoot)
56 1: MoveLoc[1](Arg1: address)
57 2: PackGeneric[0](Key<Ty0>)
58 3: Call root_has_accumulator<Ty0, U128>(&AccumulatorRoot, Key<Ty0>): bool
59 4: Ret
60}
61
62public(friend) accumulator_u128_read<Ty0>(Arg0: &AccumulatorRoot, Arg1: address): u128 {
63B0:
64 0: MoveLoc[0](Arg0: &AccumulatorRoot)
65 1: MoveLoc[1](Arg1: address)
66 2: PackGeneric[0](Key<Ty0>)
67 3: Call root_borrow_accumulator<Ty0, U128>(&AccumulatorRoot, Key<Ty0>): &U128
68 4: ImmBorrowField[1](U128.value: u128)
69 5: ReadRef
70 6: Ret
71}
72
73public(friend) create_u128(Arg0: u128): U128 {
74B0:
75 0: MoveLoc[0](Arg0: u128)
76 1: Pack[1](U128)
77 2: Ret
78}
79
80public(friend) destroy_u128(Arg0: U128) {
81B0:
82 0: MoveLoc[0](Arg0: U128)
83 1: Unpack[1](U128)
84 2: Pop
85 3: Ret
86}
87
88public(friend) update_u128(Arg0: &mut U128, Arg1: u128, Arg2: u128) {
89B0:
90 0: CopyLoc[0](Arg0: &mut U128)
91 1: ImmBorrowField[1](U128.value: u128)
92 2: ReadRef
93 3: MoveLoc[1](Arg1: u128)
94 4: Add
95 5: MoveLoc[2](Arg2: u128)
96 6: Sub
97 7: MoveLoc[0](Arg0: &mut U128)
98 8: MutBorrowField[1](U128.value: u128)
99 9: WriteRef
100 10: Ret
101}
102
103public(friend) is_zero_u128(Arg0: &U128): bool {
104B0:
105 0: MoveLoc[0](Arg0: &U128)
106 1: ImmBorrowField[1](U128.value: u128)
107 2: ReadRef
108 3: LdU128(0)
109 4: Eq
110 5: Ret
111}
112
113public(friend) accumulator_key<Ty0>(Arg0: address): Key<Ty0> {
114B0:
115 0: MoveLoc[0](Arg0: address)
116 1: PackGeneric[0](Key<Ty0>)
117 2: Ret
118}
119
120public(friend) accumulator_address<Ty0>(Arg0: address): address {
121L1: loc0: Key<Ty0>
122B0:
123 0: MoveLoc[0](Arg0: address)
124 1: PackGeneric[0](Key<Ty0>)
125 2: StLoc[1](loc0: Key<Ty0>)
126 3: Call object::sui_accumulator_root_address(): address
127 4: MoveLoc[1](loc0: Key<Ty0>)
128 5: Call dynamic_field::hash_type_and_key<Key<Ty0>>(address, Key<Ty0>): address
129 6: Ret
130}
131
132public(friend) root_has_accumulator<Ty0, Ty1: store>(Arg0: &AccumulatorRoot, Arg1: Key<Ty0>): bool {
133B0:
134 0: MoveLoc[0](Arg0: &AccumulatorRoot)
135 1: ImmBorrowField[0](AccumulatorRoot.id: UID)
136 2: MoveLoc[1](Arg1: Key<Ty0>)
137 3: Call dynamic_field::exists_with_type<Key<Ty0>, Ty1>(&UID, Key<Ty0>): bool
138 4: Ret
139}
140
141public(friend) root_add_accumulator<Ty0, Ty1: store>(Arg0: &mut AccumulatorRoot, Arg1: Key<Ty0>, Arg2: Ty1) {
142B0:
143 0: MoveLoc[0](Arg0: &mut AccumulatorRoot)
144 1: MutBorrowField[0](AccumulatorRoot.id: UID)
145 2: MoveLoc[1](Arg1: Key<Ty0>)
146 3: MoveLoc[2](Arg2: Ty1)
147 4: Call dynamic_field::add<Key<Ty0>, Ty1>(&mut UID, Key<Ty0>, Ty1)
148 5: Ret
149}
150
151public(friend) root_borrow_accumulator_mut<Ty0, Ty1: store>(Arg0: &mut AccumulatorRoot, Arg1: Key<Ty0>): &mut Ty1 {
152B0:
153 0: MoveLoc[0](Arg0: &mut AccumulatorRoot)
154 1: MutBorrowField[0](AccumulatorRoot.id: UID)
155 2: MoveLoc[1](Arg1: Key<Ty0>)
156 3: Call dynamic_field::borrow_mut<Key<Ty0>, Ty1>(&mut UID, Key<Ty0>): &mut Ty1
157 4: Ret
158}
159
160public(friend) root_borrow_accumulator<Ty0, Ty1: store>(Arg0: &AccumulatorRoot, Arg1: Key<Ty0>): &Ty1 {
161B0:
162 0: MoveLoc[0](Arg0: &AccumulatorRoot)
163 1: ImmBorrowField[0](AccumulatorRoot.id: UID)
164 2: MoveLoc[1](Arg1: Key<Ty0>)
165 3: Call dynamic_field::borrow<Key<Ty0>, Ty1>(&UID, Key<Ty0>): &Ty1
166 4: Ret
167}
168
169public(friend) root_remove_accumulator<Ty0, Ty1: store>(Arg0: &mut AccumulatorRoot, Arg1: Key<Ty0>): Ty1 {
170B0:
171 0: MoveLoc[0](Arg0: &mut AccumulatorRoot)
172 1: MutBorrowField[0](AccumulatorRoot.id: UID)
173 2: MoveLoc[1](Arg1: Key<Ty0>)
174 3: Call dynamic_field::remove<Key<Ty0>, Ty1>(&mut UID, Key<Ty0>): Ty1
175 4: Ret
176}
177
178native public(friend) emit_deposit_event<Ty0>(Arg0: address, Arg1: address, Arg2: u64);
179
180native public(friend) emit_withdraw_event<Ty0>(Arg0: address, Arg1: address, Arg2: u64);
181
182Constants [
183 0 => u64: 0
184 1 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
185]
186}
187
0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/accumulator_metadata.mvb130 lines
1// Move bytecode v7
2module 2.accumulator_metadata {
3use 0000000000000000000000000000000000000000000000000000000000000002::accumulator;
4use 0000000000000000000000000000000000000000000000000000000000000002::bag;
5use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
6use 0000000000000000000000000000000000000000000000000000000000000002::object;
7
8struct OwnerKey has copy, drop, store {
9 owner: address
10}
11
12struct Owner has store {
13 balances: Bag,
14 owner: address
15}
16
17struct MetadataKey<phantom Ty0> has copy, drop, store {
18 dummy_field: bool
19}
20
21struct Metadata<phantom Ty0> has store {
22 fields: Bag
23}
24
25struct AccumulatorObjectCountKey has copy, drop, store {
26 dummy_field: bool
27}
28
29record_accumulator_object_changes(Arg0: &mut AccumulatorRoot, Arg1: u64, Arg2: u64) {
30L3: loc0: &mut u64
31L4: loc1: AccumulatorObjectCountKey
32B0:
33 0: LdFalse
34 1: Pack[4](AccumulatorObjectCountKey)
35 2: StLoc[4](loc1: AccumulatorObjectCountKey)
36 3: CopyLoc[0](Arg0: &mut AccumulatorRoot)
37 4: Call accumulator::root_id_mut(&mut AccumulatorRoot): &mut UID
38 5: FreezeRef
39 6: CopyLoc[4](loc1: AccumulatorObjectCountKey)
40 7: Call dynamic_field::exists<AccumulatorObjectCountKey>(&UID, AccumulatorObjectCountKey): bool
41 8: BrFalse(35)
42B1:
43 9: MoveLoc[0](Arg0: &mut AccumulatorRoot)
44 10: Call accumulator::root_id_mut(&mut AccumulatorRoot): &mut UID
45 11: MoveLoc[4](loc1: AccumulatorObjectCountKey)
46 12: Call dynamic_field::borrow_mut<AccumulatorObjectCountKey, u64>(&mut UID, AccumulatorObjectCountKey): &mut u64
47 13: StLoc[3](loc0: &mut u64)
48 14: CopyLoc[3](loc0: &mut u64)
49 15: ReadRef
50 16: CopyLoc[1](Arg1: u64)
51 17: Add
52 18: CopyLoc[2](Arg2: u64)
53 19: Ge
54 20: BrFalse(22)
55B2:
56 21: Branch(26)
57B3:
58 22: MoveLoc[3](loc0: &mut u64)
59 23: Pop
60 24: LdConst[0](u64: 0)
61 25: Abort
62B4:
63 26: CopyLoc[3](loc0: &mut u64)
64 27: ReadRef
65 28: MoveLoc[1](Arg1: u64)
66 29: Add
67 30: MoveLoc[2](Arg2: u64)
68 31: Sub
69 32: MoveLoc[3](loc0: &mut u64)
70 33: WriteRef
71 34: Branch(51)
72B5:
73 35: CopyLoc[1](Arg1: u64)
74 36: CopyLoc[2](Arg2: u64)
75 37: Ge
76 38: BrFalse(40)
77B6:
78 39: Branch(44)
79B7:
80 40: MoveLoc[0](Arg0: &mut AccumulatorRoot)
81 41: Pop
82 42: LdConst[0](u64: 0)
83 43: Abort
84B8:
85 44: MoveLoc[0](Arg0: &mut AccumulatorRoot)
86 45: Call accumulator::root_id_mut(&mut AccumulatorRoot): &mut UID
87 46: MoveLoc[4](loc1: AccumulatorObjectCountKey)
88 47: MoveLoc[1](Arg1: u64)
89 48: MoveLoc[2](Arg2: u64)
90 49: Sub
91 50: Call dynamic_field::add<AccumulatorObjectCountKey, u64>(&mut UID, AccumulatorObjectCountKey, u64)
92B9:
93 51: Ret
94}
95
96get_accumulator_object_count(Arg0: &AccumulatorRoot): u64 {
97L1: loc0: u64
98L2: loc1: AccumulatorObjectCountKey
99B0:
100 0: LdFalse
101 1: Pack[4](AccumulatorObjectCountKey)
102 2: StLoc[2](loc1: AccumulatorObjectCountKey)
103 3: CopyLoc[0](Arg0: &AccumulatorRoot)
104 4: Call accumulator::root_id(&AccumulatorRoot): &UID
105 5: CopyLoc[2](loc1: AccumulatorObjectCountKey)
106 6: Call dynamic_field::exists<AccumulatorObjectCountKey>(&UID, AccumulatorObjectCountKey): bool
107 7: BrFalse(15)
108B1:
109 8: MoveLoc[0](Arg0: &AccumulatorRoot)
110 9: Call accumulator::root_id(&AccumulatorRoot): &UID
111 10: MoveLoc[2](loc1: AccumulatorObjectCountKey)
112 11: Call dynamic_field::borrow<AccumulatorObjectCountKey, u64>(&UID, AccumulatorObjectCountKey): &u64
113 12: ReadRef
114 13: StLoc[1](loc0: u64)
115 14: Branch(19)
116B2:
117 15: MoveLoc[0](Arg0: &AccumulatorRoot)
118 16: Pop
119 17: LdU64(0)
120 18: StLoc[1](loc0: u64)
121B3:
122 19: MoveLoc[1](loc0: u64)
123 20: Ret
124}
125
126Constants [
127 0 => u64: 0
128]
129}
130
0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/accumulator_settlement.mvb298 lines
1// Move bytecode v7
2module 2.accumulator_settlement {
3use 0000000000000000000000000000000000000000000000000000000000000001::vector;
4use 0000000000000000000000000000000000000000000000000000000000000002::accumulator;
5use 0000000000000000000000000000000000000000000000000000000000000002::bcs;
6use 0000000000000000000000000000000000000000000000000000000000000002::hash;
7use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
8
9struct EventStreamHead has store {
10 mmr: vector<u256>,
11 checkpoint_seq: u64,
12 num_events: u64
13}
14
15settlement_prologue(Arg0: &mut AccumulatorRoot, Arg1: u64, Arg2: u64, Arg3: u64, Arg4: u64, Arg5: u64, Arg6: &TxContext) {
16B0:
17 0: MoveLoc[6](Arg6: &TxContext)
18 1: Call tx_context::sender(&TxContext): address
19 2: LdConst[2](address: 0x00..)
20 3: Eq
21 4: BrFalse(6)
22B1:
23 5: Branch(8)
24B2:
25 6: LdConst[0](u64: 0)
26 7: Abort
27B3:
28 8: MoveLoc[4](Arg4: u64)
29 9: MoveLoc[5](Arg5: u64)
30 10: Call record_settlement_sui_conservation(u64, u64)
31 11: Ret
32}
33
34settle_u128<Ty0>(Arg0: &mut AccumulatorRoot, Arg1: address, Arg2: u128, Arg3: u128, Arg4: &TxContext) {
35L5: loc0: Key<Ty0>
36L6: loc1: &mut U128
37L7: loc2: U128
38B0:
39 0: MoveLoc[4](Arg4: &TxContext)
40 1: Call tx_context::sender(&TxContext): address
41 2: LdConst[2](address: 0x00..)
42 3: Eq
43 4: BrFalse(6)
44B1:
45 5: Branch(10)
46B2:
47 6: MoveLoc[0](Arg0: &mut AccumulatorRoot)
48 7: Pop
49 8: LdConst[0](u64: 0)
50 9: Abort
51B3:
52 10: CopyLoc[2](Arg2: u128)
53 11: LdU128(0)
54 12: Eq
55 13: CopyLoc[3](Arg3: u128)
56 14: LdU128(0)
57 15: Eq
58 16: Neq
59 17: BrFalse(19)
60B4:
61 18: Branch(23)
62B5:
63 19: MoveLoc[0](Arg0: &mut AccumulatorRoot)
64 20: Pop
65 21: LdConst[1](u64: 1)
66 22: Abort
67B6:
68 23: MoveLoc[1](Arg1: address)
69 24: Call accumulator::accumulator_key<Ty0>(address): Key<Ty0>
70 25: StLoc[5](loc0: Key<Ty0>)
71 26: CopyLoc[0](Arg0: &mut AccumulatorRoot)
72 27: FreezeRef
73 28: CopyLoc[5](loc0: Key<Ty0>)
74 29: Call accumulator::root_has_accumulator<Ty0, U128>(&AccumulatorRoot, Key<Ty0>): bool
75 30: BrFalse(51)
76B7:
77 31: CopyLoc[0](Arg0: &mut AccumulatorRoot)
78 32: CopyLoc[5](loc0: Key<Ty0>)
79 33: Call accumulator::root_borrow_accumulator_mut<Ty0, U128>(&mut AccumulatorRoot, Key<Ty0>): &mut U128
80 34: StLoc[6](loc1: &mut U128)
81 35: CopyLoc[6](loc1: &mut U128)
82 36: MoveLoc[2](Arg2: u128)
83 37: MoveLoc[3](Arg3: u128)
84 38: Call accumulator::update_u128(&mut U128, u128, u128)
85 39: MoveLoc[6](loc1: &mut U128)
86 40: FreezeRef
87 41: Call accumulator::is_zero_u128(&U128): bool
88 42: BrFalse(48)
89B8:
90 43: MoveLoc[0](Arg0: &mut AccumulatorRoot)
91 44: MoveLoc[5](loc0: Key<Ty0>)
92 45: Call accumulator::root_remove_accumulator<Ty0, U128>(&mut AccumulatorRoot, Key<Ty0>): U128
93 46: Call accumulator::destroy_u128(U128)
94 47: Branch(67)
95B9:
96 48: MoveLoc[0](Arg0: &mut AccumulatorRoot)
97 49: Pop
98 50: Branch(67)
99B10:
100 51: MoveLoc[3](Arg3: u128)
101 52: LdU128(0)
102 53: Eq
103 54: BrFalse(56)
104B11:
105 55: Branch(60)
106B12:
107 56: MoveLoc[0](Arg0: &mut AccumulatorRoot)
108 57: Pop
109 58: LdConst[1](u64: 1)
110 59: Abort
111B13:
112 60: MoveLoc[2](Arg2: u128)
113 61: Call accumulator::create_u128(u128): U128
114 62: StLoc[7](loc2: U128)
115 63: MoveLoc[0](Arg0: &mut AccumulatorRoot)
116 64: MoveLoc[5](loc0: Key<Ty0>)
117 65: MoveLoc[7](loc2: U128)
118 66: Call accumulator::root_add_accumulator<Ty0, U128>(&mut AccumulatorRoot, Key<Ty0>, U128)
119B14:
120 67: Ret
121}
122
123native record_settlement_sui_conservation(Arg0: u64, Arg1: u64);
124
125add_to_mmr(Arg0: u256, Arg1: &mut vector<u256>) {
126L2: loc0: u256
127L3: loc1: u64
128L4: loc2: &mut u256
129B0:
130 0: LdU64(0)
131 1: StLoc[3](loc1: u64)
132 2: MoveLoc[0](Arg0: u256)
133 3: StLoc[2](loc0: u256)
134B1:
135 4: CopyLoc[3](loc1: u64)
136 5: CopyLoc[1](Arg1: &mut vector<u256>)
137 6: FreezeRef
138 7: VecLen(6)
139 8: Lt
140 9: BrFalse(39)
141B2:
142 10: Branch(11)
143B3:
144 11: CopyLoc[1](Arg1: &mut vector<u256>)
145 12: CopyLoc[3](loc1: u64)
146 13: VecMutBorrow(6)
147 14: StLoc[4](loc2: &mut u256)
148 15: CopyLoc[4](loc2: &mut u256)
149 16: ReadRef
150 17: LdU256(0)
151 18: Eq
152 19: BrFalse(26)
153B4:
154 20: MoveLoc[1](Arg1: &mut vector<u256>)
155 21: Pop
156 22: MoveLoc[2](loc0: u256)
157 23: MoveLoc[4](loc2: &mut u256)
158 24: WriteRef
159 25: Ret
160B5:
161 26: CopyLoc[4](loc2: &mut u256)
162 27: ReadRef
163 28: MoveLoc[2](loc0: u256)
164 29: Call hash_two_to_one_u256(u256, u256): u256
165 30: StLoc[2](loc0: u256)
166 31: LdU256(0)
167 32: MoveLoc[4](loc2: &mut u256)
168 33: WriteRef
169 34: MoveLoc[3](loc1: u64)
170 35: LdU64(1)
171 36: Add
172 37: StLoc[3](loc1: u64)
173 38: Branch(4)
174B6:
175 39: MoveLoc[1](Arg1: &mut vector<u256>)
176 40: MoveLoc[2](loc0: u256)
177 41: VecPushBack(6)
178 42: Ret
179}
180
181u256_from_bytes(Arg0: vector<u8>): u256 {
182L1: loc0: BCS
183B0:
184 0: MoveLoc[0](Arg0: vector<u8>)
185 1: Call bcs::new(vector<u8>): BCS
186 2: StLoc[1](loc0: BCS)
187 3: MutBorrowLoc[1](loc0: BCS)
188 4: Call bcs::peel_u256(&mut BCS): u256
189 5: Ret
190}
191
192hash_two_to_one_u256(Arg0: u256, Arg1: u256): u256 {
193L2: loc0: vector<u8>
194L3: loc1: vector<u8>
195L4: loc2: vector<u8>
196B0:
197 0: ImmBorrowLoc[0](Arg0: u256)
198 1: Call bcs::to_bytes<u256>(&u256): vector<u8>
199 2: StLoc[3](loc1: vector<u8>)
200 3: ImmBorrowLoc[1](Arg1: u256)
201 4: Call bcs::to_bytes<u256>(&u256): vector<u8>
202 5: StLoc[4](loc2: vector<u8>)
203 6: MoveLoc[3](loc1: vector<u8>)
204 7: StLoc[2](loc0: vector<u8>)
205 8: MutBorrowLoc[2](loc0: vector<u8>)
206 9: MoveLoc[4](loc2: vector<u8>)
207 10: Call vector::append<u8>(&mut vector<u8>, vector<u8>)
208 11: ImmBorrowLoc[2](loc0: vector<u8>)
209 12: Call hash::blake2b256(&vector<u8>): vector<u8>
210 13: Call u256_from_bytes(vector<u8>): u256
211 14: Ret
212}
213
214new_stream_head(Arg0: u256, Arg1: u64, Arg2: u64): EventStreamHead {
215L3: loc0: vector<u256>
216B0:
217 0: LdConst[3](vector<u256>: 00)
218 1: StLoc[3](loc0: vector<u256>)
219 2: MoveLoc[0](Arg0: u256)
220 3: MutBorrowLoc[3](loc0: vector<u256>)
221 4: Call add_to_mmr(u256, &mut vector<u256>)
222 5: MoveLoc[3](loc0: vector<u256>)
223 6: MoveLoc[2](Arg2: u64)
224 7: MoveLoc[1](Arg1: u64)
225 8: Pack[0](EventStreamHead)
226 9: Ret
227}
228
229settle_events(Arg0: &mut AccumulatorRoot, Arg1: address, Arg2: u256, Arg3: u64, Arg4: u64, Arg5: &TxContext) {
230L6: loc0: &mut EventStreamHead
231L7: loc1: EventStreamHead
232L8: loc2: Key<EventStreamHead>
233B0:
234 0: MoveLoc[5](Arg5: &TxContext)
235 1: Call tx_context::sender(&TxContext): address
236 2: LdConst[2](address: 0x00..)
237 3: Eq
238 4: BrFalse(6)
239B1:
240 5: Branch(10)
241B2:
242 6: MoveLoc[0](Arg0: &mut AccumulatorRoot)
243 7: Pop
244 8: LdConst[0](u64: 0)
245 9: Abort
246B3:
247 10: MoveLoc[1](Arg1: address)
248 11: Call accumulator::accumulator_key<EventStreamHead>(address): Key<EventStreamHead>
249 12: StLoc[8](loc2: Key<EventStreamHead>)
250 13: CopyLoc[0](Arg0: &mut AccumulatorRoot)
251 14: FreezeRef
252 15: CopyLoc[8](loc2: Key<EventStreamHead>)
253 16: Call accumulator::root_has_accumulator<EventStreamHead, EventStreamHead>(&AccumulatorRoot, Key<EventStreamHead>): bool
254 17: BrFalse(39)
255B4:
256 18: MoveLoc[0](Arg0: &mut AccumulatorRoot)
257 19: MoveLoc[8](loc2: Key<EventStreamHead>)
258 20: Call accumulator::root_borrow_accumulator_mut<EventStreamHead, EventStreamHead>(&mut AccumulatorRoot, Key<EventStreamHead>): &mut EventStreamHead
259 21: StLoc[6](loc0: &mut EventStreamHead)
260 22: MoveLoc[2](Arg2: u256)
261 23: CopyLoc[6](loc0: &mut EventStreamHead)
262 24: MutBorrowField[0](EventStreamHead.mmr: vector<u256>)
263 25: Call add_to_mmr(u256, &mut vector<u256>)
264 26: CopyLoc[6](loc0: &mut EventStreamHead)
265 27: ImmBorrowField[1](EventStreamHead.num_events: u64)
266 28: ReadRef
267 29: MoveLoc[3](Arg3: u64)
268 30: Add
269 31: CopyLoc[6](loc0: &mut EventStreamHead)
270 32: MutBorrowField[1](EventStreamHead.num_events: u64)
271 33: WriteRef
272 34: MoveLoc[4](Arg4: u64)
273 35: MoveLoc[6](loc0: &mut EventStreamHead)
274 36: MutBorrowField[2](EventStreamHead.checkpoint_seq: u64)
275 37: WriteRef
276 38: Branch(48)
277B5:
278 39: MoveLoc[2](Arg2: u256)
279 40: MoveLoc[3](Arg3: u64)
280 41: MoveLoc[4](Arg4: u64)
281 42: Call new_stream_head(u256, u64, u64): EventStreamHead
282 43: StLoc[7](loc1: EventStreamHead)
283 44: MoveLoc[0](Arg0: &mut AccumulatorRoot)
284 45: MoveLoc[8](loc2: Key<EventStreamHead>)
285 46: MoveLoc[7](loc1: EventStreamHead)
286 47: Call accumulator::root_add_accumulator<EventStreamHead, EventStreamHead>(&mut AccumulatorRoot, Key<EventStreamHead>, EventStreamHead)
287B6:
288 48: Ret
289}
290
291Constants [
292 0 => u64: 0
293 1 => u64: 1
294 2 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
295 3 => vector<u256>: 00
296]
297}
298
0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/dynamic_field.mvb278 lines
1// Move bytecode v7
2module 2.dynamic_field {
3use 0000000000000000000000000000000000000000000000000000000000000001::option;
4use 0000000000000000000000000000000000000000000000000000000000000002::object;
5
6struct Field<Ty0: copy + drop + store, Ty1: store> has key {
7 id: UID,
8 name: Ty0,
9 value: Ty1
10}
11
12public add<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0, Arg2: Ty1) {
13L3: loc0: Field<Ty0, Ty1>
14L4: loc1: address
15L5: loc2: address
16B0:
17 0: MoveLoc[0](Arg0: &mut UID)
18 1: FreezeRef
19 2: Call object::uid_to_address(&UID): address
20 3: StLoc[5](loc2: address)
21 4: CopyLoc[5](loc2: address)
22 5: CopyLoc[1](Arg1: Ty0)
23 6: Call hash_type_and_key<Ty0>(address, Ty0): address
24 7: StLoc[4](loc1: address)
25 8: CopyLoc[5](loc2: address)
26 9: CopyLoc[4](loc1: address)
27 10: Call has_child_object(address, address): bool
28 11: Not
29 12: BrFalse(14)
30B1:
31 13: Branch(16)
32B2:
33 14: LdConst[0](u64: 0)
34 15: Abort
35B3:
36 16: CopyLoc[5](loc2: address)
37 17: MoveLoc[4](loc1: address)
38 18: Call object::new_uid_from_hash(address, address): UID
39 19: MoveLoc[1](Arg1: Ty0)
40 20: MoveLoc[2](Arg2: Ty1)
41 21: PackGeneric[0](Field<Ty0, Ty1>)
42 22: StLoc[3](loc0: Field<Ty0, Ty1>)
43 23: MoveLoc[5](loc2: address)
44 24: MoveLoc[3](loc0: Field<Ty0, Ty1>)
45 25: Call add_child_object<Field<Ty0, Ty1>>(address, Field<Ty0, Ty1>)
46 26: Ret
47}
48
49public borrow<Ty0: copy + drop + store, Ty1: store>(Arg0: &UID, Arg1: Ty0): &Ty1 {
50L2: loc0: address
51B0:
52 0: CopyLoc[0](Arg0: &UID)
53 1: Call object::uid_to_address(&UID): address
54 2: MoveLoc[1](Arg1: Ty0)
55 3: Call hash_type_and_key<Ty0>(address, Ty0): address
56 4: StLoc[2](loc0: address)
57 5: MoveLoc[0](Arg0: &UID)
58 6: MoveLoc[2](loc0: address)
59 7: Call borrow_child_object<Field<Ty0, Ty1>>(&UID, address): &Field<Ty0, Ty1>
60 8: ImmBorrowFieldGeneric[0](Field.value: Ty1)
61 9: Ret
62}
63
64public borrow_mut<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0): &mut Ty1 {
65L2: loc0: address
66B0:
67 0: CopyLoc[0](Arg0: &mut UID)
68 1: FreezeRef
69 2: Call object::uid_to_address(&UID): address
70 3: MoveLoc[1](Arg1: Ty0)
71 4: Call hash_type_and_key<Ty0>(address, Ty0): address
72 5: StLoc[2](loc0: address)
73 6: MoveLoc[0](Arg0: &mut UID)
74 7: MoveLoc[2](loc0: address)
75 8: Call borrow_child_object_mut<Field<Ty0, Ty1>>(&mut UID, address): &mut Field<Ty0, Ty1>
76 9: MutBorrowFieldGeneric[0](Field.value: Ty1)
77 10: Ret
78}
79
80public remove<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0): Ty1 {
81L2: loc0: address
82L3: loc1: address
83L4: loc2: Ty1
84B0:
85 0: MoveLoc[0](Arg0: &mut UID)
86 1: FreezeRef
87 2: Call object::uid_to_address(&UID): address
88 3: StLoc[3](loc1: address)
89 4: CopyLoc[3](loc1: address)
90 5: MoveLoc[1](Arg1: Ty0)
91 6: Call hash_type_and_key<Ty0>(address, Ty0): address
92 7: StLoc[2](loc0: address)
93 8: MoveLoc[3](loc1: address)
94 9: MoveLoc[2](loc0: address)
95 10: Call remove_child_object<Field<Ty0, Ty1>>(address, address): Field<Ty0, Ty1>
96 11: UnpackGeneric[0](Field<Ty0, Ty1>)
97 12: StLoc[4](loc2: Ty1)
98 13: Pop
99 14: Call object::delete(UID)
100 15: MoveLoc[4](loc2: Ty1)
101 16: Ret
102}
103
104public exists<Ty0: copy + drop + store>(Arg0: &UID, Arg1: Ty0): bool {
105L2: loc0: address
106L3: loc1: address
107B0:
108 0: MoveLoc[0](Arg0: &UID)
109 1: Call object::uid_to_address(&UID): address
110 2: StLoc[3](loc1: address)
111 3: CopyLoc[3](loc1: address)
112 4: MoveLoc[1](Arg1: Ty0)
113 5: Call hash_type_and_key<Ty0>(address, Ty0): address
114 6: StLoc[2](loc0: address)
115 7: MoveLoc[3](loc1: address)
116 8: MoveLoc[2](loc0: address)
117 9: Call has_child_object(address, address): bool
118 10: Ret
119}
120
121public remove_opt<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0): Option<Ty1> {
122L2: loc0: Option<Ty1>
123B0:
124 0: CopyLoc[0](Arg0: &mut UID)
125 1: FreezeRef
126 2: CopyLoc[1](Arg1: Ty0)
127 3: Call exists<Ty0>(&UID, Ty0): bool
128 4: BrFalse(11)
129B1:
130 5: MoveLoc[0](Arg0: &mut UID)
131 6: MoveLoc[1](Arg1: Ty0)
132 7: Call remove<Ty0, Ty1>(&mut UID, Ty0): Ty1
133 8: Call option::some<Ty1>(Ty1): Option<Ty1>
134 9: StLoc[2](loc0: Option<Ty1>)
135 10: Branch(15)
136B2:
137 11: MoveLoc[0](Arg0: &mut UID)
138 12: Pop
139 13: Call option::none<Ty1>(): Option<Ty1>
140 14: StLoc[2](loc0: Option<Ty1>)
141B3:
142 15: MoveLoc[2](loc0: Option<Ty1>)
143 16: Ret
144}
145
146public replace<Ty0: copy + drop + store, Ty1: store, Ty2: store>(Arg0: &mut UID, Arg1: Ty0, Arg2: Ty1): Option<Ty2> {
147L3: loc0: Option<Ty2>
148B0:
149 0: CopyLoc[0](Arg0: &mut UID)
150 1: CopyLoc[1](Arg1: Ty0)
151 2: Call remove_opt<Ty0, Ty2>(&mut UID, Ty0): Option<Ty2>
152 3: StLoc[3](loc0: Option<Ty2>)
153 4: MoveLoc[0](Arg0: &mut UID)
154 5: MoveLoc[1](Arg1: Ty0)
155 6: MoveLoc[2](Arg2: Ty1)
156 7: Call add<Ty0, Ty1>(&mut UID, Ty0, Ty1)
157 8: MoveLoc[3](loc0: Option<Ty2>)
158 9: Ret
159}
160
161public exists_with_type<Ty0: copy + drop + store, Ty1: store>(Arg0: &UID, Arg1: Ty0): bool {
162L2: loc0: address
163L3: loc1: address
164B0:
165 0: MoveLoc[0](Arg0: &UID)
166 1: Call object::uid_to_address(&UID): address
167 2: StLoc[3](loc1: address)
168 3: CopyLoc[3](loc1: address)
169 4: MoveLoc[1](Arg1: Ty0)
170 5: Call hash_type_and_key<Ty0>(address, Ty0): address
171 6: StLoc[2](loc0: address)
172 7: MoveLoc[3](loc1: address)
173 8: MoveLoc[2](loc0: address)
174 9: Call has_child_object_with_ty<Field<Ty0, Ty1>>(address, address): bool
175 10: Ret
176}
177
178public exists_<Ty0: copy + drop + store>(Arg0: &UID, Arg1: Ty0): bool {
179B0:
180 0: MoveLoc[0](Arg0: &UID)
181 1: MoveLoc[1](Arg1: Ty0)
182 2: Call exists<Ty0>(&UID, Ty0): bool
183 3: Ret
184}
185
186public remove_if_exists<Ty0: copy + drop + store, Ty1: store>(Arg0: &mut UID, Arg1: Ty0): Option<Ty1> {
187B0:
188 0: MoveLoc[0](Arg0: &mut UID)
189 1: MoveLoc[1](Arg1: Ty0)
190 2: Call remove_opt<Ty0, Ty1>(&mut UID, Ty0): Option<Ty1>
191 3: Ret
192}
193
194public(friend) field_info<Ty0: copy + drop + store>(Arg0: &UID, Arg1: Ty0): &UID * address {
195L2: loc0: &Field<Ty0, ID>
196L3: loc1: address
197L4: loc2: &UID
198L5: loc3: &ID
199B0:
200 0: CopyLoc[0](Arg0: &UID)
201 1: Call object::uid_to_address(&UID): address
202 2: MoveLoc[1](Arg1: Ty0)
203 3: Call hash_type_and_key<Ty0>(address, Ty0): address
204 4: StLoc[3](loc1: address)
205 5: MoveLoc[0](Arg0: &UID)
206 6: MoveLoc[3](loc1: address)
207 7: Call borrow_child_object<Field<Ty0, ID>>(&UID, address): &Field<Ty0, ID>
208 8: StLoc[2](loc0: &Field<Ty0, ID>)
209 9: CopyLoc[2](loc0: &Field<Ty0, ID>)
210 10: ImmBorrowFieldGeneric[1](Field.id: UID)
211 11: StLoc[4](loc2: &UID)
212 12: CopyLoc[2](loc0: &Field<Ty0, ID>)
213 13: ImmBorrowFieldGeneric[2](Field.name: Ty0)
214 14: Pop
215 15: MoveLoc[2](loc0: &Field<Ty0, ID>)
216 16: ImmBorrowFieldGeneric[3](Field.value: ID)
217 17: StLoc[5](loc3: &ID)
218 18: MoveLoc[4](loc2: &UID)
219 19: MoveLoc[5](loc3: &ID)
220 20: Call object::id_to_address(&ID): address
221 21: Ret
222}
223
224public(friend) field_info_mut<Ty0: copy + drop + store>(Arg0: &mut UID, Arg1: Ty0): &mut UID * address {
225L2: loc0: &mut Field<Ty0, ID>
226L3: loc1: address
227L4: loc2: &mut UID
228L5: loc3: &mut ID
229B0:
230 0: CopyLoc[0](Arg0: &mut UID)
231 1: FreezeRef
232 2: Call object::uid_to_address(&UID): address
233 3: MoveLoc[1](Arg1: Ty0)
234 4: Call hash_type_and_key<Ty0>(address, Ty0): address
235 5: StLoc[3](loc1: address)
236 6: MoveLoc[0](Arg0: &mut UID)
237 7: MoveLoc[3](loc1: address)
238 8: Call borrow_child_object_mut<Field<Ty0, ID>>(&mut UID, address): &mut Field<Ty0, ID>
239 9: StLoc[2](loc0: &mut Field<Ty0, ID>)
240 10: CopyLoc[2](loc0: &mut Field<Ty0, ID>)
241 11: MutBorrowFieldGeneric[1](Field.id: UID)
242 12: StLoc[4](loc2: &mut UID)
243 13: CopyLoc[2](loc0: &mut Field<Ty0, ID>)
244 14: MutBorrowFieldGeneric[2](Field.name: Ty0)
245 15: Pop
246 16: MoveLoc[2](loc0: &mut Field<Ty0, ID>)
247 17: MutBorrowFieldGeneric[3](Field.value: ID)
248 18: StLoc[5](loc3: &mut ID)
249 19: MoveLoc[4](loc2: &mut UID)
250 20: MoveLoc[5](loc3: &mut ID)
251 21: FreezeRef
252 22: Call object::id_to_address(&ID): address
253 23: Ret
254}
255
256native public(friend) hash_type_and_key<Ty0: copy + drop>(Arg0: address, Arg1: Ty0): address;
257
258native public(friend) add_child_object<Ty0: key>(Arg0: address, Arg1: Ty0);
259
260native public(friend) borrow_child_object<Ty0: key>(Arg0: &UID, Arg1: address): &Ty0;
261
262native public(friend) borrow_child_object_mut<Ty0: key>(Arg0: &mut UID, Arg1: address): &mut Ty0;
263
264native public(friend) remove_child_object<Ty0: key>(Arg0: address, Arg1: address): Ty0;
265
266native public(friend) has_child_object(Arg0: address, Arg1: address): bool;
267
268native public(friend) has_child_object_with_ty<Ty0: key>(Arg0: address, Arg1: address): bool;
269
270Constants [
271 0 => u64: 0
272 1 => u64: 1
273 2 => u64: 2
274 3 => u64: 3
275 4 => u64: 4
276]
277}
278
0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/object.mvb283 lines
1// Move bytecode v7
2module 2.object {
3use 0000000000000000000000000000000000000000000000000000000000000001::bcs;
4use 0000000000000000000000000000000000000000000000000000000000000002::address;
5use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
6
7struct ID has copy, drop, store {
8 bytes: address
9}
10
11struct UID has store {
12 id: ID
13}
14
15public id_to_bytes(Arg0: &ID): vector<u8> {
16B0:
17 0: MoveLoc[0](Arg0: &ID)
18 1: ImmBorrowField[0](ID.bytes: address)
19 2: Call bcs::to_bytes<address>(&address): vector<u8>
20 3: Ret
21}
22
23public id_to_address(Arg0: &ID): address {
24B0:
25 0: MoveLoc[0](Arg0: &ID)
26 1: ImmBorrowField[0](ID.bytes: address)
27 2: ReadRef
28 3: Ret
29}
30
31public id_from_bytes(Arg0: vector<u8>): ID {
32B0:
33 0: MoveLoc[0](Arg0: vector<u8>)
34 1: Call address::from_bytes(vector<u8>): address
35 2: Call id_from_address(address): ID
36 3: Ret
37}
38
39public id_from_address(Arg0: address): ID {
40B0:
41 0: MoveLoc[0](Arg0: address)
42 1: Pack[0](ID)
43 2: Ret
44}
45
46sui_system_state(Arg0: &TxContext): UID {
47B0:
48 0: MoveLoc[0](Arg0: &TxContext)
49 1: Call tx_context::sender(&TxContext): address
50 2: LdConst[12](address: 0x00..)
51 3: Eq
52 4: BrFalse(6)
53B1:
54 5: Branch(8)
55B2:
56 6: LdConst[11](u64: 0)
57 7: Abort
58B3:
59 8: LdConst[0](address: 0x00..)
60 9: Pack[0](ID)
61 10: Pack[1](UID)
62 11: Ret
63}
64
65public(friend) clock(): UID {
66B0:
67 0: LdConst[1](address: 0x00..)
68 1: Pack[0](ID)
69 2: Pack[1](UID)
70 3: Ret
71}
72
73public(friend) authenticator_state(): UID {
74B0:
75 0: LdConst[2](address: 0x00..)
76 1: Pack[0](ID)
77 2: Pack[1](UID)
78 3: Ret
79}
80
81public(friend) randomness_state(): UID {
82B0:
83 0: LdConst[3](address: 0x00..)
84 1: Pack[0](ID)
85 2: Pack[1](UID)
86 3: Ret
87}
88
89public(friend) sui_deny_list_object_id(): UID {
90B0:
91 0: LdConst[4](address: 0x00..)
92 1: Pack[0](ID)
93 2: Pack[1](UID)
94 3: Ret
95}
96
97public(friend) sui_accumulator_root_object_id(): UID {
98B0:
99 0: LdConst[5](address: 0x00..)
100 1: Pack[0](ID)
101 2: Pack[1](UID)
102 3: Ret
103}
104
105public(friend) sui_accumulator_root_address(): address {
106B0:
107 0: LdConst[5](address: 0x00..)
108 1: Ret
109}
110
111public(friend) sui_coin_registry_object_id(): UID {
112B0:
113 0: LdConst[7](address: 0x00..)
114 1: Pack[0](ID)
115 2: Pack[1](UID)
116 3: Ret
117}
118
119public(friend) sui_coin_registry_address(): address {
120B0:
121 0: LdConst[7](address: 0x00..)
122 1: Ret
123}
124
125public(friend) sui_display_registry_object_id(): UID {
126B0:
127 0: LdConst[8](address: 0x00..)
128 1: Pack[0](ID)
129 2: Pack[1](UID)
130 3: Ret
131}
132
133public(friend) sui_display_registry_address(): address {
134B0:
135 0: LdConst[8](address: 0x00..)
136 1: Ret
137}
138
139bridge(): UID {
140B0:
141 0: LdConst[6](address: 0x00..)
142 1: Pack[0](ID)
143 2: Pack[1](UID)
144 3: Ret
145}
146
147public(friend) address_alias_state(): UID {
148B0:
149 0: LdConst[9](address: 0x00..)
150 1: Pack[0](ID)
151 2: Pack[1](UID)
152 3: Ret
153}
154
155public(friend) forwarding_address_registry(): UID {
156B0:
157 0: LdConst[10](address: 0x00..)
158 1: Pack[0](ID)
159 2: Pack[1](UID)
160 3: Ret
161}
162
163public uid_as_inner(Arg0: &UID): &ID {
164B0:
165 0: MoveLoc[0](Arg0: &UID)
166 1: ImmBorrowField[1](UID.id: ID)
167 2: Ret
168}
169
170public uid_to_inner(Arg0: &UID): ID {
171B0:
172 0: MoveLoc[0](Arg0: &UID)
173 1: ImmBorrowField[1](UID.id: ID)
174 2: ReadRef
175 3: Ret
176}
177
178public uid_to_bytes(Arg0: &UID): vector<u8> {
179B0:
180 0: MoveLoc[0](Arg0: &UID)
181 1: ImmBorrowField[1](UID.id: ID)
182 2: ImmBorrowField[0](ID.bytes: address)
183 3: Call bcs::to_bytes<address>(&address): vector<u8>
184 4: Ret
185}
186
187public uid_to_address(Arg0: &UID): address {
188B0:
189 0: MoveLoc[0](Arg0: &UID)
190 1: ImmBorrowField[1](UID.id: ID)
191 2: ImmBorrowField[0](ID.bytes: address)
192 3: ReadRef
193 4: Ret
194}
195
196public new(Arg0: &mut TxContext): UID {
197B0:
198 0: MoveLoc[0](Arg0: &mut TxContext)
199 1: Call tx_context::fresh_object_address(&mut TxContext): address
200 2: Pack[0](ID)
201 3: Pack[1](UID)
202 4: Ret
203}
204
205public delete(Arg0: UID) {
206B0:
207 0: MoveLoc[0](Arg0: UID)
208 1: Unpack[1](UID)
209 2: Unpack[0](ID)
210 3: Call delete_impl(address)
211 4: Ret
212}
213
214public id<Ty0: key>(Arg0: &Ty0): ID {
215B0:
216 0: MoveLoc[0](Arg0: &Ty0)
217 1: Call borrow_uid<Ty0>(&Ty0): &UID
218 2: ImmBorrowField[1](UID.id: ID)
219 3: ReadRef
220 4: Ret
221}
222
223public borrow_id<Ty0: key>(Arg0: &Ty0): &ID {
224B0:
225 0: MoveLoc[0](Arg0: &Ty0)
226 1: Call borrow_uid<Ty0>(&Ty0): &UID
227 2: ImmBorrowField[1](UID.id: ID)
228 3: Ret
229}
230
231public id_bytes<Ty0: key>(Arg0: &Ty0): vector<u8> {
232B0:
233 0: MoveLoc[0](Arg0: &Ty0)
234 1: Call borrow_uid<Ty0>(&Ty0): &UID
235 2: ImmBorrowField[1](UID.id: ID)
236 3: Call bcs::to_bytes<ID>(&ID): vector<u8>
237 4: Ret
238}
239
240public id_address<Ty0: key>(Arg0: &Ty0): address {
241B0:
242 0: MoveLoc[0](Arg0: &Ty0)
243 1: Call borrow_uid<Ty0>(&Ty0): &UID
244 2: ImmBorrowField[1](UID.id: ID)
245 3: ImmBorrowField[0](ID.bytes: address)
246 4: ReadRef
247 5: Ret
248}
249
250native borrow_uid<Ty0: key>(Arg0: &Ty0): &UID;
251
252public(friend) new_uid_from_hash(Arg0: address, Arg1: address): UID {
253B0:
254 0: MoveLoc[0](Arg0: address)
255 1: CopyLoc[1](Arg1: address)
256 2: Call record_new_uid_from_hash(address, address)
257 3: MoveLoc[1](Arg1: address)
258 4: Pack[0](ID)
259 5: Pack[1](UID)
260 6: Ret
261}
262
263native delete_impl(Arg0: address);
264
265native record_new_uid_from_hash(Arg0: address, Arg1: address);
266
267Constants [
268 0 => address: 0x0000000000000000000000000000000000000000000000000000000000000005
269 1 => address: 0x0000000000000000000000000000000000000000000000000000000000000006
270 2 => address: 0x0000000000000000000000000000000000000000000000000000000000000007
271 3 => address: 0x0000000000000000000000000000000000000000000000000000000000000008
272 4 => address: 0x0000000000000000000000000000000000000000000000000000000000000403
273 5 => address: 0x0000000000000000000000000000000000000000000000000000000000000acc
274 6 => address: 0x0000000000000000000000000000000000000000000000000000000000000009
275 7 => address: 0x000000000000000000000000000000000000000000000000000000000000000c
276 8 => address: 0x000000000000000000000000000000000000000000000000000000000000000d
277 9 => address: 0x000000000000000000000000000000000000000000000000000000000000000a
278 10 => address: 0x00000000000000000000000000000000000000000000000000000000000000fa
279 11 => u64: 0
280 12 => address: 0x0000000000000000000000000000000000000000000000000000000000000000
281]
282}
283
0x0000000000000000000000000000000000000000000000000000000000000002/bytecode/tx_context.mvb110 lines
1// Move bytecode v7
2module 2.tx_context {
3use 0000000000000000000000000000000000000000000000000000000000000001::option;
4
5struct TxContext has drop {
6 sender: address,
7 tx_hash: vector<u8>,
8 epoch: u64,
9 epoch_timestamp_ms: u64,
10 ids_created: u64
11}
12
13public sender(Arg0: &TxContext): address {
14B0:
15 0: Call native_sender(): address
16 1: Ret
17}
18
19native native_sender(): address;
20
21public digest(Arg0: &TxContext): &vector<u8> {
22B0:
23 0: MoveLoc[0](Arg0: &TxContext)
24 1: ImmBorrowField[0](TxContext.tx_hash: vector<u8>)
25 2: Ret
26}
27
28public epoch(Arg0: &TxContext): u64 {
29B0:
30 0: Call native_epoch(): u64
31 1: Ret
32}
33
34native native_epoch(): u64;
35
36public epoch_timestamp_ms(Arg0: &TxContext): u64 {
37B0:
38 0: Call native_epoch_timestamp_ms(): u64
39 1: Ret
40}
41
42native native_epoch_timestamp_ms(): u64;
43
44public sponsor(Arg0: &TxContext): Option<address> {
45B0:
46 0: Call option_sponsor(): Option<address>
47 1: Ret
48}
49
50public fresh_object_address(Arg0: &mut TxContext): address {
51B0:
52 0: Call fresh_id(): address
53 1: Ret
54}
55
56native fresh_id(): address;
57
58public reference_gas_price(Arg0: &TxContext): u64 {
59B0:
60 0: Call native_rgp(): u64
61 1: Ret
62}
63
64native native_rgp(): u64;
65
66public gas_price(Arg0: &TxContext): u64 {
67B0:
68 0: Call native_gas_price(): u64
69 1: Ret
70}
71
72native native_gas_price(): u64;
73
74native native_ids_created(): u64;
75
76native native_gas_budget(): u64;
77
78option_sponsor(): Option<address> {
79L0: loc0: Option<address>
80L1: loc1: vector<address>
81B0:
82 0: Call native_sponsor(): vector<address>
83 1: StLoc[1](loc1: vector<address>)
84 2: ImmBorrowLoc[1](loc1: vector<address>)
85 3: VecLen(1)
86 4: LdU64(0)
87 5: Eq
88 6: BrFalse(10)
89B1:
90 7: Call option::none<address>(): Option<address>
91 8: StLoc[0](loc0: Option<address>)
92 9: Branch(16)
93B2:
94 10: ImmBorrowLoc[1](loc1: vector<address>)
95 11: LdU64(0)
96 12: VecImmBorrow(1)
97 13: ReadRef
98 14: Call option::some<address>(address): Option<address>
99 15: StLoc[0](loc0: Option<address>)
100B3:
101 16: MoveLoc[0](loc0: Option<address>)
102 17: Ret
103}
104
105native native_sponsor(): vector<address>;
106
107native derive_id(Arg0: vector<u8>, Arg1: u64): address;
108
109}
110
This is a circuit, not a contract. It declares no ABI and no storage layout, so there is no interface list and no slot mapping to show. The source above is the whole of what it publishes.

Deployments