Sui mainnet
Verified source
0xf6a6…4b1b
0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b
The pipeline is behind the chain tip0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b
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
- 0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b
- Status
- full match
- Provider
- disassembly of package 0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b as `sui replay` fetched it at the version that executed
- Compiler
- Language
- move-disassembly
- Bundle
- sha1:8eb714b3a9023babfc48dc6255b53ad2d4af4875
Sources
0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/constants.mvb0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/internal_pair.mvb0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/internal_price.mvb0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/math.mvb0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/price_oracle.mvb
0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/constants.mvb14 lines
1// Move bytecode v7
2module c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5.constants {
3
4public(friend) get_version(): u64 {
5B0:
6 0: LdConst[0](u64: 13)
7 1: Ret
8}
9
10Constants [
11 0 => u64: 13
12]
13}
14
0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/internal_pair.mvb40 lines
1// Move bytecode v7
2module c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5.internal_pair {
3use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
4
5struct RawPair has copy, drop, store {
6 base: TypeName,
7 quote: TypeName
8}
9
10struct Pair<phantom Ty0, phantom Ty1> has drop {
11 raw: RawPair
12}
13
14public new_raw(Arg0: TypeName, Arg1: TypeName): RawPair {
15B0:
16 0: MoveLoc[0](Arg0: TypeName)
17 1: MoveLoc[1](Arg1: TypeName)
18 2: Pack[0](RawPair)
19 3: Ret
20}
21
22public new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1> {
23B0:
24 0: Call type_name::with_defining_ids<Ty0>(): TypeName
25 1: Call type_name::with_defining_ids<Ty1>(): TypeName
26 2: Call new_raw(TypeName, TypeName): RawPair
27 3: PackGeneric[0](Pair<Ty0, Ty1>)
28 4: Ret
29}
30
31public get_raw<Ty0, Ty1>(Arg0: &Pair<Ty0, Ty1>): RawPair {
32B0:
33 0: MoveLoc[0](Arg0: &Pair<Ty0, Ty1>)
34 1: ImmBorrowFieldGeneric[0](Pair.raw: RawPair)
35 2: ReadRef
36 3: Ret
37}
38
39}
40
0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/internal_price.mvb146 lines
1// Move bytecode v7
2module c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5.internal_price {
3use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
4use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
5use 0000000000000000000000000000000000000000000000000000000000000002::clock;
6
7struct RawPrice has copy, drop, store {
8 price: u128,
9 expiry: u64
10}
11
12struct Price<phantom Ty0, phantom Ty1> has copy, drop {
13 price: u128,
14 expiry: u64,
15 is_inversed: bool
16}
17
18public into_price<Ty0, Ty1>(Arg0: &RawPrice): Price<Ty0, Ty1> {
19B0:
20 0: CopyLoc[0](Arg0: &RawPrice)
21 1: ImmBorrowField[0](RawPrice.price: u128)
22 2: ReadRef
23 3: MoveLoc[0](Arg0: &RawPrice)
24 4: ImmBorrowField[1](RawPrice.expiry: u64)
25 5: ReadRef
26 6: LdFalse
27 7: PackGeneric[0](Price<Ty0, Ty1>)
28 8: Ret
29}
30
31public new_price<Ty0, Ty1>(Arg0: u128, Arg1: u64): Price<Ty0, Ty1> {
32B0:
33 0: MoveLoc[0](Arg0: u128)
34 1: MoveLoc[1](Arg1: u64)
35 2: LdFalse
36 3: PackGeneric[0](Price<Ty0, Ty1>)
37 4: Ret
38}
39
40public get_price<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>): u128 {
41B0:
42 0: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
43 1: ImmBorrowFieldGeneric[0](Price.price: u128)
44 2: ReadRef
45 3: Ret
46}
47
48public get_expiry<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>): u64 {
49B0:
50 0: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
51 1: ImmBorrowFieldGeneric[1](Price.expiry: u64)
52 2: ReadRef
53 3: Ret
54}
55
56public is_inversed<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>): bool {
57B0:
58 0: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
59 1: ImmBorrowFieldGeneric[2](Price.is_inversed: bool)
60 2: ReadRef
61 3: Ret
62}
63
64public get_base_name<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>): String {
65B0:
66 0: Call type_name::with_defining_ids<Ty0>(): TypeName
67 1: Call type_name::into_string(TypeName): String
68 2: Ret
69}
70
71public get_quote_name<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>): String {
72B0:
73 0: Call type_name::with_defining_ids<Ty1>(): TypeName
74 1: Call type_name::into_string(TypeName): String
75 2: Ret
76}
77
78public get_valid_price<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>, Arg1: &Clock): u128 {
79B0:
80 0: CopyLoc[0](Arg0: &Price<Ty0, Ty1>)
81 1: ImmBorrowFieldGeneric[1](Price.expiry: u64)
82 2: ReadRef
83 3: MoveLoc[1](Arg1: &Clock)
84 4: Call clock::timestamp_ms(&Clock): u64
85 5: Lt
86 6: BrFalse(8)
87B1:
88 7: Branch(12)
89B2:
90 8: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
91 9: Pop
92 10: LdConst[0](u64: 0)
93 11: Abort
94B3:
95 12: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
96 13: ImmBorrowFieldGeneric[0](Price.price: u128)
97 14: ReadRef
98 15: Ret
99}
100
101public is_expired<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>, Arg1: &Clock): bool {
102B0:
103 0: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
104 1: ImmBorrowFieldGeneric[1](Price.expiry: u64)
105 2: ReadRef
106 3: MoveLoc[1](Arg1: &Clock)
107 4: Call clock::timestamp_ms(&Clock): u64
108 5: Lt
109 6: Ret
110}
111
112public get_inverse_price<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>): Price<Ty1, Ty0> {
113B0:
114 0: LdConst[1](u128: 1000..)
115 1: LdConst[1](u128: 1000..)
116 2: Mul
117 3: CopyLoc[0](Arg0: &Price<Ty0, Ty1>)
118 4: ImmBorrowFieldGeneric[0](Price.price: u128)
119 5: ReadRef
120 6: Div
121 7: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
122 8: ImmBorrowFieldGeneric[1](Price.expiry: u64)
123 9: ReadRef
124 10: LdTrue
125 11: PackGeneric[1](Price<Ty1, Ty0>)
126 12: Ret
127}
128
129public get_raw<Ty0, Ty1>(Arg0: &Price<Ty0, Ty1>): RawPrice {
130B0:
131 0: CopyLoc[0](Arg0: &Price<Ty0, Ty1>)
132 1: ImmBorrowFieldGeneric[0](Price.price: u128)
133 2: ReadRef
134 3: MoveLoc[0](Arg0: &Price<Ty0, Ty1>)
135 4: ImmBorrowFieldGeneric[1](Price.expiry: u64)
136 5: ReadRef
137 6: Pack[0](RawPrice)
138 7: Ret
139}
140
141Constants [
142 0 => u64: 0
143 1 => u128: 1000000000000000000
144]
145}
146
0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/math.mvb52 lines
1// Move bytecode v7
2module c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5.math {
3use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
4
5init(Arg0: &mut TxContext) {
6B0:
7 0: Ret
8}
9
10public mul_div_u128(Arg0: u128, Arg1: u128, Arg2: u128): u128 {
11L3: loc0: u256
12B0:
13 0: CopyLoc[2](Arg2: u128)
14 1: LdU128(0)
15 2: Neq
16 3: BrFalse(5)
17B1:
18 4: Branch(7)
19B2:
20 5: LdConst[0](u64: 2000)
21 6: Abort
22B3:
23 7: MoveLoc[0](Arg0: u128)
24 8: CastU256
25 9: MoveLoc[1](Arg1: u128)
26 10: CastU256
27 11: Mul
28 12: MoveLoc[2](Arg2: u128)
29 13: CastU256
30 14: Div
31 15: StLoc[3](loc0: u256)
32 16: CopyLoc[3](loc0: u256)
33 17: LdU256(340282366920938463463374607431768211455)
34 18: Le
35 19: BrFalse(21)
36B4:
37 20: Branch(23)
38B5:
39 21: LdConst[1](u64: 2001)
40 22: Abort
41B6:
42 23: MoveLoc[3](loc0: u256)
43 24: CastU128
44 25: Ret
45}
46
47Constants [
48 0 => u64: 2000
49 1 => u64: 2001
50]
51}
52
0xf6a6d2492e7b575f3551602652bcd4ff72cc522a42ad5bbfd8c248ed545c4b1b/bytecode/price_oracle.mvb1854 lines
1// Move bytecode v7
2module c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5.price_oracle {
3use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::admin;
4use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::constants;
5use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::internal_pair;
6use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::internal_price;
7use c8724de692400a2a08585f6f7c8617acfb783abe2c66ae6a4680a21b36a504c5::math;
8use 0000000000000000000000000000000000000000000000000000000000000001::ascii;
9use 0000000000000000000000000000000000000000000000000000000000000001::option;
10use 0000000000000000000000000000000000000000000000000000000000000001::type_name;
11use 0000000000000000000000000000000000000000000000000000000000000001::u64;
12use 0000000000000000000000000000000000000000000000000000000000000001::vector;
13use 0000000000000000000000000000000000000000000000000000000000000002::clock;
14use 0000000000000000000000000000000000000000000000000000000000000002::dynamic_field;
15use 0000000000000000000000000000000000000000000000000000000000000002::event;
16use 0000000000000000000000000000000000000000000000000000000000000002::linked_table;
17use 0000000000000000000000000000000000000000000000000000000000000002::object;
18use 0000000000000000000000000000000000000000000000000000000000000002::table;
19use 0000000000000000000000000000000000000000000000000000000000000002::transfer;
20use 0000000000000000000000000000000000000000000000000000000000000002::tx_context;
21
22struct OracleAdminCap has store, key {
23 id: UID,
24 oracle_id: ID
25}
26
27struct PriceFeederCap has store, key {
28 id: UID,
29 for_oracle: ID
30}
31
32struct Oracle has key {
33 id: UID,
34 price_threshold_ratio: u64,
35 default_price_expiry_seconds: u64,
36 supported_pairs: LinkedTable<RawPair, AssetPair>,
37 prices: Table<RawPair, PriceData>,
38 version: u64
39}
40
41struct FeederGuardKey has copy, drop, store {
42 dummy_field: bool
43}
44
45struct FeederGuard has store {
46 active: Table<ID, bool>
47}
48
49struct AssetPair has copy, drop, store {
50 base_name: String,
51 quote_name: String,
52 base_precision: u8,
53 quote_precision: u8
54}
55
56struct AssetPairResponse has copy, drop, store {
57 pair: RawPair,
58 info: AssetPair
59}
60
61struct PriceData has copy, drop, store {
62 price: RawPrice,
63 last_updated_ms: u64,
64 updater: address
65}
66
67struct PriceResponse has copy, drop, store {
68 pair_data: Option<PriceData>,
69 is_inverted: bool
70}
71
72struct OracleCreated has copy, drop {
73 oracle_id: ID,
74 admin_id: ID
75}
76
77struct OracleConfigUpdated has copy, drop {
78 oracle_id: ID,
79 price_threshold_ratio: u64,
80 default_price_expiry_seconds: u64
81}
82
83struct PriceFeederCapMinted has copy, drop {
84 oracle_id: ID,
85 price_feeder_id: ID
86}
87
88struct PriceFeederCapDeleted has copy, drop {
89 oracle_id: ID,
90 price_feeder_id: ID
91}
92
93struct PriceFeederWhitelisted has copy, drop {
94 oracle_id: ID,
95 price_feeder_id: ID
96}
97
98struct PriceFeederRemovedFromWhitelist has copy, drop {
99 oracle_id: ID,
100 price_feeder_id: ID
101}
102
103struct PriceUpdated<phantom Ty0, phantom Ty1> has copy, drop {
104 oracle_id: ID,
105 price: Price<Ty0, Ty1>
106}
107
108struct PriceReseted<phantom Ty0, phantom Ty1> has copy, drop {
109 oracle_id: ID,
110 price: Price<Ty0, Ty1>
111}
112
113struct PriceHalted<phantom Ty0, phantom Ty1> has copy, drop {
114 oracle_id: ID,
115 price: Price<Ty0, Ty1>
116}
117
118struct AssetPairAdded<phantom Ty0, phantom Ty1> has copy, drop {
119 oracle_id: ID,
120 base_name: String,
121 quote_name: String,
122 base_precision: u8,
123 quote_precision: u8
124}
125
126struct AssetPairRemoved<phantom Ty0, phantom Ty1> has copy, drop {
127 oracle_id: ID,
128 base_name: String,
129 quote_name: String
130}
131
132struct AuthorityAdded has copy, drop {
133 dummy_field: bool
134}
135
136struct AuthorityRemoved has copy, drop {
137 dummy_field: bool
138}
139
140struct ConfigResponse has copy, drop, store {
141 price_threshold_ratio: u64,
142 default_price_expiry_seconds: u64
143}
144
145public get_inner_price<Ty0, Ty1>(Arg0: &PriceData): u128 {
146L1: loc0: Price<Ty0, Ty1>
147B0:
148 0: MoveLoc[0](Arg0: &PriceData)
149 1: ImmBorrowField[0](PriceData.price: RawPrice)
150 2: Call internal_price::into_price<Ty0, Ty1>(&RawPrice): Price<Ty0, Ty1>
151 3: StLoc[1](loc0: Price<Ty0, Ty1>)
152 4: ImmBorrowLoc[1](loc0: Price<Ty0, Ty1>)
153 5: Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
154 6: Ret
155}
156
157entry migrate_module_version(Arg0: &ProtocolAdminCap, Arg1: &mut Oracle, Arg2: vector<ID>, Arg3: &mut TxContext) {
158B0:
159 0: CopyLoc[1](Arg1: &mut Oracle)
160 1: ImmBorrowField[1](Oracle.id: UID)
161 2: LdFalse
162 3: Pack[3](FeederGuardKey)
163 4: Call dynamic_field::exists_<FeederGuardKey>(&UID, FeederGuardKey): bool
164 5: Not
165 6: BrFalse(18)
166B1:
167 7: ImmBorrowLoc[2](Arg2: vector<ID>)
168 8: Call vector::is_empty<ID>(&vector<ID>): bool
169 9: Not
170 10: BrFalse(12)
171B2:
172 11: Branch(18)
173B3:
174 12: MoveLoc[1](Arg1: &mut Oracle)
175 13: Pop
176 14: MoveLoc[3](Arg3: &mut TxContext)
177 15: Pop
178 16: LdConst[5](u64: 3004)
179 17: Abort
180B4:
181 18: CopyLoc[1](Arg1: &mut Oracle)
182 19: ImmBorrowField[2](Oracle.version: u64)
183 20: ReadRef
184 21: Call constants::get_version(): u64
185 22: Lt
186 23: BrFalse(25)
187B5:
188 24: Branch(31)
189B6:
190 25: MoveLoc[1](Arg1: &mut Oracle)
191 26: Pop
192 27: MoveLoc[3](Arg3: &mut TxContext)
193 28: Pop
194 29: LdConst[6](u64: 3005)
195 30: Abort
196B7:
197 31: Call constants::get_version(): u64
198 32: CopyLoc[1](Arg1: &mut Oracle)
199 33: MutBorrowField[2](Oracle.version: u64)
200 34: WriteRef
201 35: MoveLoc[1](Arg1: &mut Oracle)
202 36: MoveLoc[2](Arg2: vector<ID>)
203 37: MoveLoc[3](Arg3: &mut TxContext)
204 38: Call enable_and_seed_feeder_whitelist(&mut Oracle, vector<ID>, &mut TxContext)
205 39: Ret
206}
207
208enable_and_seed_feeder_whitelist(Arg0: &mut Oracle, Arg1: vector<ID>, Arg2: &mut TxContext) {
209L3: loc0: ID
210L4: loc1: &mut FeederGuard
211L5: loc2: u64
212L6: loc3: u64
213L7: loc4: ID
214B0:
215 0: CopyLoc[0](Arg0: &mut Oracle)
216 1: ImmBorrowField[1](Oracle.id: UID)
217 2: LdFalse
218 3: Pack[3](FeederGuardKey)
219 4: Call dynamic_field::exists_<FeederGuardKey>(&UID, FeederGuardKey): bool
220 5: BrFalse(11)
221B1:
222 6: MoveLoc[0](Arg0: &mut Oracle)
223 7: Pop
224 8: MoveLoc[2](Arg2: &mut TxContext)
225 9: Pop
226 10: Ret
227B2:
228 11: CopyLoc[0](Arg0: &mut Oracle)
229 12: ImmBorrowField[1](Oracle.id: UID)
230 13: Call object::uid_to_inner(&UID): ID
231 14: StLoc[7](loc4: ID)
232 15: CopyLoc[0](Arg0: &mut Oracle)
233 16: MutBorrowField[1](Oracle.id: UID)
234 17: LdFalse
235 18: Pack[3](FeederGuardKey)
236 19: MoveLoc[2](Arg2: &mut TxContext)
237 20: Call table::new<ID, bool>(&mut TxContext): Table<ID, bool>
238 21: Pack[4](FeederGuard)
239 22: Call dynamic_field::add<FeederGuardKey, FeederGuard>(&mut UID, FeederGuardKey, FeederGuard)
240 23: MoveLoc[0](Arg0: &mut Oracle)
241 24: MutBorrowField[1](Oracle.id: UID)
242 25: LdFalse
243 26: Pack[3](FeederGuardKey)
244 27: Call dynamic_field::borrow_mut<FeederGuardKey, FeederGuard>(&mut UID, FeederGuardKey): &mut FeederGuard
245 28: StLoc[4](loc1: &mut FeederGuard)
246 29: ImmBorrowLoc[1](Arg1: vector<ID>)
247 30: VecLen(9)
248 31: StLoc[6](loc3: u64)
249 32: LdU64(0)
250 33: StLoc[5](loc2: u64)
251B3:
252 34: CopyLoc[5](loc2: u64)
253 35: CopyLoc[6](loc3: u64)
254 36: Lt
255 37: BrFalse(64)
256B4:
257 38: ImmBorrowLoc[1](Arg1: vector<ID>)
258 39: CopyLoc[5](loc2: u64)
259 40: VecImmBorrow(9)
260 41: ReadRef
261 42: StLoc[3](loc0: ID)
262 43: CopyLoc[4](loc1: &mut FeederGuard)
263 44: ImmBorrowField[3](FeederGuard.active: Table<ID, bool>)
264 45: CopyLoc[3](loc0: ID)
265 46: Call table::contains<ID, bool>(&Table<ID, bool>, ID): bool
266 47: Not
267 48: BrFalse(59)
268B5:
269 49: Branch(50)
270B6:
271 50: CopyLoc[4](loc1: &mut FeederGuard)
272 51: MutBorrowField[3](FeederGuard.active: Table<ID, bool>)
273 52: CopyLoc[3](loc0: ID)
274 53: LdTrue
275 54: Call table::add<ID, bool>(&mut Table<ID, bool>, ID, bool)
276 55: CopyLoc[7](loc4: ID)
277 56: MoveLoc[3](loc0: ID)
278 57: Pack[13](PriceFeederWhitelisted)
279 58: Call event::emit<PriceFeederWhitelisted>(PriceFeederWhitelisted)
280B7:
281 59: MoveLoc[5](loc2: u64)
282 60: LdU64(1)
283 61: Add
284 62: StLoc[5](loc2: u64)
285 63: Branch(34)
286B8:
287 64: MoveLoc[4](loc1: &mut FeederGuard)
288 65: Pop
289 66: Ret
290}
291
292public validate_oracle_version(Arg0: &Oracle) {
293B0:
294 0: MoveLoc[0](Arg0: &Oracle)
295 1: ImmBorrowField[2](Oracle.version: u64)
296 2: ReadRef
297 3: Call constants::get_version(): u64
298 4: Eq
299 5: BrFalse(7)
300B1:
301 6: Branch(9)
302B2:
303 7: LdConst[6](u64: 3005)
304 8: Abort
305B3:
306 9: Ret
307}
308
309public initialize(Arg0: &ProtocolAdminCap, Arg1: u64, Arg2: Option<u64>, Arg3: address, Arg4: &mut TxContext) {
310L5: loc0: bool
311L6: loc1: address
312L7: loc2: OracleAdminCap
313L8: loc3: ID
314L9: loc4: Oracle
315L10: loc5: UID
316L11: loc6: ID
317L12: loc7: u64
318B0:
319 0: CopyLoc[4](Arg4: &mut TxContext)
320 1: FreezeRef
321 2: Call tx_context::sender(&TxContext): address
322 3: StLoc[6](loc1: address)
323 4: CopyLoc[4](Arg4: &mut TxContext)
324 5: Call object::new(&mut TxContext): UID
325 6: StLoc[10](loc5: UID)
326 7: ImmBorrowLoc[10](loc5: UID)
327 8: Call object::uid_to_inner(&UID): ID
328 9: StLoc[11](loc6: ID)
329 10: CopyLoc[1](Arg1: u64)
330 11: CastU128
331 12: LdConst[0](u128: 10000)
332 13: Le
333 14: BrFalse(16)
334B1:
335 15: Branch(20)
336B2:
337 16: MoveLoc[4](Arg4: &mut TxContext)
338 17: Pop
339 18: LdConst[5](u64: 3004)
340 19: Abort
341B3:
342 20: ImmBorrowLoc[2](Arg2: Option<u64>)
343 21: LdConst[14](u64: 300)
344 22: Call option::get_with_default<u64>(&Option<u64>, u64): u64
345 23: StLoc[12](loc7: u64)
346 24: CopyLoc[12](loc7: u64)
347 25: LdU64(0)
348 26: Gt
349 27: BrFalse(33)
350B4:
351 28: CopyLoc[12](loc7: u64)
352 29: LdConst[15](u64: 86400)
353 30: Le
354 31: StLoc[5](loc0: bool)
355 32: Branch(35)
356B5:
357 33: LdFalse
358 34: StLoc[5](loc0: bool)
359B6:
360 35: MoveLoc[5](loc0: bool)
361 36: BrFalse(38)
362B7:
363 37: Branch(42)
364B8:
365 38: MoveLoc[4](Arg4: &mut TxContext)
366 39: Pop
367 40: LdConst[5](u64: 3004)
368 41: Abort
369B9:
370 42: MoveLoc[10](loc5: UID)
371 43: MoveLoc[1](Arg1: u64)
372 44: MoveLoc[12](loc7: u64)
373 45: CopyLoc[4](Arg4: &mut TxContext)
374 46: Call linked_table::new<RawPair, AssetPair>(&mut TxContext): LinkedTable<RawPair, AssetPair>
375 47: CopyLoc[4](Arg4: &mut TxContext)
376 48: Call table::new<RawPair, PriceData>(&mut TxContext): Table<RawPair, PriceData>
377 49: Call constants::get_version(): u64
378 50: Pack[2](Oracle)
379 51: StLoc[9](loc4: Oracle)
380 52: CopyLoc[4](Arg4: &mut TxContext)
381 53: Call object::new(&mut TxContext): UID
382 54: CopyLoc[11](loc6: ID)
383 55: Pack[0](OracleAdminCap)
384 56: StLoc[7](loc2: OracleAdminCap)
385 57: CopyLoc[11](loc6: ID)
386 58: ImmBorrowLoc[7](loc2: OracleAdminCap)
387 59: ImmBorrowField[4](OracleAdminCap.id: UID)
388 60: Call object::uid_to_inner(&UID): ID
389 61: Pack[9](OracleCreated)
390 62: Call event::emit<OracleCreated>(OracleCreated)
391 63: MoveLoc[11](loc6: ID)
392 64: MoveLoc[3](Arg3: address)
393 65: CopyLoc[4](Arg4: &mut TxContext)
394 66: Call mint_price_feeder_cap_internal(ID, address, &mut TxContext): ID
395 67: StLoc[8](loc3: ID)
396 68: MutBorrowLoc[9](loc4: Oracle)
397 69: MoveLoc[8](loc3: ID)
398 70: VecPack(9, 1)
399 71: MoveLoc[4](Arg4: &mut TxContext)
400 72: Call enable_and_seed_feeder_whitelist(&mut Oracle, vector<ID>, &mut TxContext)
401 73: MoveLoc[9](loc4: Oracle)
402 74: Call transfer::share_object<Oracle>(Oracle)
403 75: MoveLoc[7](loc2: OracleAdminCap)
404 76: MoveLoc[6](loc1: address)
405 77: Call transfer::transfer<OracleAdminCap>(OracleAdminCap, address)
406 78: Ret
407}
408
409public mint_price_feeder_cap(Arg0: &Oracle, Arg1: &OracleAdminCap, Arg2: address, Arg3: &mut TxContext) {
410B0:
411 0: CopyLoc[0](Arg0: &Oracle)
412 1: Call validate_oracle_version(&Oracle)
413 2: MoveLoc[1](Arg1: &OracleAdminCap)
414 3: ImmBorrowField[5](OracleAdminCap.oracle_id: ID)
415 4: ReadRef
416 5: CopyLoc[0](Arg0: &Oracle)
417 6: ImmBorrowField[1](Oracle.id: UID)
418 7: Call object::uid_to_inner(&UID): ID
419 8: Eq
420 9: BrFalse(11)
421B1:
422 10: Branch(17)
423B2:
424 11: MoveLoc[0](Arg0: &Oracle)
425 12: Pop
426 13: MoveLoc[3](Arg3: &mut TxContext)
427 14: Pop
428 15: LdConst[1](u64: 3000)
429 16: Abort
430B3:
431 17: MoveLoc[0](Arg0: &Oracle)
432 18: ImmBorrowField[1](Oracle.id: UID)
433 19: Call object::uid_to_inner(&UID): ID
434 20: MoveLoc[2](Arg2: address)
435 21: MoveLoc[3](Arg3: &mut TxContext)
436 22: Call mint_price_feeder_cap_internal(ID, address, &mut TxContext): ID
437 23: Pop
438 24: Ret
439}
440
441mint_price_feeder_cap_internal(Arg0: ID, Arg1: address, Arg2: &mut TxContext): ID {
442L3: loc0: PriceFeederCap
443L4: loc1: ID
444B0:
445 0: MoveLoc[2](Arg2: &mut TxContext)
446 1: Call object::new(&mut TxContext): UID
447 2: CopyLoc[0](Arg0: ID)
448 3: Pack[1](PriceFeederCap)
449 4: StLoc[3](loc0: PriceFeederCap)
450 5: ImmBorrowLoc[3](loc0: PriceFeederCap)
451 6: ImmBorrowField[6](PriceFeederCap.id: UID)
452 7: Call object::uid_to_inner(&UID): ID
453 8: StLoc[4](loc1: ID)
454 9: MoveLoc[0](Arg0: ID)
455 10: CopyLoc[4](loc1: ID)
456 11: Pack[11](PriceFeederCapMinted)
457 12: Call event::emit<PriceFeederCapMinted>(PriceFeederCapMinted)
458 13: MoveLoc[3](loc0: PriceFeederCap)
459 14: MoveLoc[1](Arg1: address)
460 15: Call transfer::transfer<PriceFeederCap>(PriceFeederCap, address)
461 16: MoveLoc[4](loc1: ID)
462 17: Ret
463}
464
465entry public(friend) whitelist_price_feeders(Arg0: &mut Oracle, Arg1: &OracleAdminCap, Arg2: vector<ID>, Arg3: &mut TxContext) {
466L4: loc0: &mut FeederGuard
467L5: loc1: u64
468L6: loc2: u64
469L7: loc3: ID
470L8: loc4: ID
471B0:
472 0: CopyLoc[0](Arg0: &mut Oracle)
473 1: FreezeRef
474 2: Call validate_oracle_version(&Oracle)
475 3: MoveLoc[1](Arg1: &OracleAdminCap)
476 4: ImmBorrowField[5](OracleAdminCap.oracle_id: ID)
477 5: ReadRef
478 6: CopyLoc[0](Arg0: &mut Oracle)
479 7: ImmBorrowField[1](Oracle.id: UID)
480 8: Call object::uid_to_inner(&UID): ID
481 9: Eq
482 10: BrFalse(12)
483B1:
484 11: Branch(16)
485B2:
486 12: MoveLoc[0](Arg0: &mut Oracle)
487 13: Pop
488 14: LdConst[1](u64: 3000)
489 15: Abort
490B3:
491 16: ImmBorrowLoc[2](Arg2: vector<ID>)
492 17: Call vector::is_empty<ID>(&vector<ID>): bool
493 18: Not
494 19: BrFalse(21)
495B4:
496 20: Branch(25)
497B5:
498 21: MoveLoc[0](Arg0: &mut Oracle)
499 22: Pop
500 23: LdConst[5](u64: 3004)
501 24: Abort
502B6:
503 25: CopyLoc[0](Arg0: &mut Oracle)
504 26: ImmBorrowField[1](Oracle.id: UID)
505 27: Call object::uid_to_inner(&UID): ID
506 28: StLoc[7](loc3: ID)
507 29: MoveLoc[0](Arg0: &mut Oracle)
508 30: MutBorrowField[1](Oracle.id: UID)
509 31: LdFalse
510 32: Pack[3](FeederGuardKey)
511 33: Call dynamic_field::borrow_mut<FeederGuardKey, FeederGuard>(&mut UID, FeederGuardKey): &mut FeederGuard
512 34: StLoc[4](loc0: &mut FeederGuard)
513 35: ImmBorrowLoc[2](Arg2: vector<ID>)
514 36: VecLen(9)
515 37: StLoc[6](loc2: u64)
516 38: LdU64(0)
517 39: StLoc[5](loc1: u64)
518B7:
519 40: CopyLoc[5](loc1: u64)
520 41: CopyLoc[6](loc2: u64)
521 42: Lt
522 43: BrFalse(70)
523B8:
524 44: ImmBorrowLoc[2](Arg2: vector<ID>)
525 45: CopyLoc[5](loc1: u64)
526 46: VecImmBorrow(9)
527 47: ReadRef
528 48: StLoc[8](loc4: ID)
529 49: CopyLoc[4](loc0: &mut FeederGuard)
530 50: ImmBorrowField[3](FeederGuard.active: Table<ID, bool>)
531 51: CopyLoc[8](loc4: ID)
532 52: Call table::contains<ID, bool>(&Table<ID, bool>, ID): bool
533 53: Not
534 54: BrFalse(65)
535B9:
536 55: CopyLoc[4](loc0: &mut FeederGuard)
537 56: MutBorrowField[3](FeederGuard.active: Table<ID, bool>)
538 57: CopyLoc[8](loc4: ID)
539 58: LdTrue
540 59: Call table::add<ID, bool>(&mut Table<ID, bool>, ID, bool)
541 60: CopyLoc[7](loc3: ID)
542 61: MoveLoc[8](loc4: ID)
543 62: Pack[13](PriceFeederWhitelisted)
544 63: Call event::emit<PriceFeederWhitelisted>(PriceFeederWhitelisted)
545 64: Branch(65)
546B10:
547 65: MoveLoc[5](loc1: u64)
548 66: LdU64(1)
549 67: Add
550 68: StLoc[5](loc1: u64)
551 69: Branch(40)
552B11:
553 70: MoveLoc[4](loc0: &mut FeederGuard)
554 71: Pop
555 72: Ret
556}
557
558entry public(friend) remove_price_feeders_from_whitelist(Arg0: &mut Oracle, Arg1: &OracleAdminCap, Arg2: vector<ID>, Arg3: &mut TxContext) {
559L4: loc0: &mut FeederGuard
560L5: loc1: u64
561L6: loc2: u64
562L7: loc3: ID
563L8: loc4: ID
564B0:
565 0: CopyLoc[0](Arg0: &mut Oracle)
566 1: FreezeRef
567 2: Call validate_oracle_version(&Oracle)
568 3: MoveLoc[1](Arg1: &OracleAdminCap)
569 4: ImmBorrowField[5](OracleAdminCap.oracle_id: ID)
570 5: ReadRef
571 6: CopyLoc[0](Arg0: &mut Oracle)
572 7: ImmBorrowField[1](Oracle.id: UID)
573 8: Call object::uid_to_inner(&UID): ID
574 9: Eq
575 10: BrFalse(12)
576B1:
577 11: Branch(16)
578B2:
579 12: MoveLoc[0](Arg0: &mut Oracle)
580 13: Pop
581 14: LdConst[1](u64: 3000)
582 15: Abort
583B3:
584 16: ImmBorrowLoc[2](Arg2: vector<ID>)
585 17: Call vector::is_empty<ID>(&vector<ID>): bool
586 18: Not
587 19: BrFalse(21)
588B4:
589 20: Branch(25)
590B5:
591 21: MoveLoc[0](Arg0: &mut Oracle)
592 22: Pop
593 23: LdConst[5](u64: 3004)
594 24: Abort
595B6:
596 25: CopyLoc[0](Arg0: &mut Oracle)
597 26: ImmBorrowField[1](Oracle.id: UID)
598 27: Call object::uid_to_inner(&UID): ID
599 28: StLoc[7](loc3: ID)
600 29: MoveLoc[0](Arg0: &mut Oracle)
601 30: MutBorrowField[1](Oracle.id: UID)
602 31: LdFalse
603 32: Pack[3](FeederGuardKey)
604 33: Call dynamic_field::borrow_mut<FeederGuardKey, FeederGuard>(&mut UID, FeederGuardKey): &mut FeederGuard
605 34: StLoc[4](loc0: &mut FeederGuard)
606 35: ImmBorrowLoc[2](Arg2: vector<ID>)
607 36: VecLen(9)
608 37: StLoc[6](loc2: u64)
609 38: LdU64(0)
610 39: StLoc[5](loc1: u64)
611B7:
612 40: CopyLoc[5](loc1: u64)
613 41: CopyLoc[6](loc2: u64)
614 42: Lt
615 43: BrFalse(69)
616B8:
617 44: ImmBorrowLoc[2](Arg2: vector<ID>)
618 45: CopyLoc[5](loc1: u64)
619 46: VecImmBorrow(9)
620 47: ReadRef
621 48: StLoc[8](loc4: ID)
622 49: CopyLoc[4](loc0: &mut FeederGuard)
623 50: ImmBorrowField[3](FeederGuard.active: Table<ID, bool>)
624 51: CopyLoc[8](loc4: ID)
625 52: Call table::contains<ID, bool>(&Table<ID, bool>, ID): bool
626 53: BrFalse(64)
627B9:
628 54: CopyLoc[4](loc0: &mut FeederGuard)
629 55: MutBorrowField[3](FeederGuard.active: Table<ID, bool>)
630 56: CopyLoc[8](loc4: ID)
631 57: Call table::remove<ID, bool>(&mut Table<ID, bool>, ID): bool
632 58: Pop
633 59: CopyLoc[7](loc3: ID)
634 60: MoveLoc[8](loc4: ID)
635 61: Pack[14](PriceFeederRemovedFromWhitelist)
636 62: Call event::emit<PriceFeederRemovedFromWhitelist>(PriceFeederRemovedFromWhitelist)
637 63: Branch(64)
638B10:
639 64: MoveLoc[5](loc1: u64)
640 65: LdU64(1)
641 66: Add
642 67: StLoc[5](loc1: u64)
643 68: Branch(40)
644B11:
645 69: MoveLoc[4](loc0: &mut FeederGuard)
646 70: Pop
647 71: Ret
648}
649
650public update_config(Arg0: &mut Oracle, Arg1: &OracleAdminCap, Arg2: Option<u64>, Arg3: Option<u64>, Arg4: &mut TxContext) {
651L5: loc0: bool
652L6: loc1: u64
653B0:
654 0: CopyLoc[0](Arg0: &mut Oracle)
655 1: FreezeRef
656 2: Call validate_oracle_version(&Oracle)
657 3: MoveLoc[1](Arg1: &OracleAdminCap)
658 4: ImmBorrowField[5](OracleAdminCap.oracle_id: ID)
659 5: ReadRef
660 6: CopyLoc[0](Arg0: &mut Oracle)
661 7: ImmBorrowField[1](Oracle.id: UID)
662 8: Call object::uid_to_inner(&UID): ID
663 9: Eq
664 10: BrFalse(12)
665B1:
666 11: Branch(16)
667B2:
668 12: MoveLoc[0](Arg0: &mut Oracle)
669 13: Pop
670 14: LdConst[1](u64: 3000)
671 15: Abort
672B3:
673 16: ImmBorrowLoc[2](Arg2: Option<u64>)
674 17: Call option::is_some<u64>(&Option<u64>): bool
675 18: BrFalse(37)
676B4:
677 19: ImmBorrowLoc[2](Arg2: Option<u64>)
678 20: Call option::borrow<u64>(&Option<u64>): &u64
679 21: ReadRef
680 22: CastU128
681 23: LdConst[0](u128: 10000)
682 24: Le
683 25: BrFalse(27)
684B5:
685 26: Branch(31)
686B6:
687 27: MoveLoc[0](Arg0: &mut Oracle)
688 28: Pop
689 29: LdConst[5](u64: 3004)
690 30: Abort
691B7:
692 31: ImmBorrowLoc[2](Arg2: Option<u64>)
693 32: Call option::borrow<u64>(&Option<u64>): &u64
694 33: ReadRef
695 34: CopyLoc[0](Arg0: &mut Oracle)
696 35: MutBorrowField[7](Oracle.price_threshold_ratio: u64)
697 36: WriteRef
698B8:
699 37: ImmBorrowLoc[3](Arg3: Option<u64>)
700 38: Call option::is_some<u64>(&Option<u64>): bool
701 39: BrFalse(68)
702B9:
703 40: ImmBorrowLoc[3](Arg3: Option<u64>)
704 41: Call option::borrow<u64>(&Option<u64>): &u64
705 42: ReadRef
706 43: StLoc[6](loc1: u64)
707 44: CopyLoc[6](loc1: u64)
708 45: LdU64(0)
709 46: Gt
710 47: BrFalse(53)
711B10:
712 48: MoveLoc[6](loc1: u64)
713 49: LdConst[15](u64: 86400)
714 50: Le
715 51: StLoc[5](loc0: bool)
716 52: Branch(55)
717B11:
718 53: LdFalse
719 54: StLoc[5](loc0: bool)
720B12:
721 55: MoveLoc[5](loc0: bool)
722 56: BrFalse(58)
723B13:
724 57: Branch(62)
725B14:
726 58: MoveLoc[0](Arg0: &mut Oracle)
727 59: Pop
728 60: LdConst[5](u64: 3004)
729 61: Abort
730B15:
731 62: ImmBorrowLoc[3](Arg3: Option<u64>)
732 63: Call option::borrow<u64>(&Option<u64>): &u64
733 64: ReadRef
734 65: CopyLoc[0](Arg0: &mut Oracle)
735 66: MutBorrowField[8](Oracle.default_price_expiry_seconds: u64)
736 67: WriteRef
737B16:
738 68: CopyLoc[0](Arg0: &mut Oracle)
739 69: ImmBorrowField[1](Oracle.id: UID)
740 70: Call object::uid_to_inner(&UID): ID
741 71: CopyLoc[0](Arg0: &mut Oracle)
742 72: ImmBorrowField[7](Oracle.price_threshold_ratio: u64)
743 73: ReadRef
744 74: MoveLoc[0](Arg0: &mut Oracle)
745 75: ImmBorrowField[8](Oracle.default_price_expiry_seconds: u64)
746 76: ReadRef
747 77: Pack[10](OracleConfigUpdated)
748 78: Call event::emit<OracleConfigUpdated>(OracleConfigUpdated)
749 79: Ret
750}
751
752assert_feeder_allowed(Arg0: &Oracle, Arg1: &PriceFeederCap) {
753B0:
754 0: MoveLoc[0](Arg0: &Oracle)
755 1: MoveLoc[1](Arg1: &PriceFeederCap)
756 2: Call object::id<PriceFeederCap>(&PriceFeederCap): ID
757 3: Call is_price_feeder_whitelisted(&Oracle, ID): bool
758 4: BrFalse(6)
759B1:
760 5: Branch(8)
761B2:
762 6: LdConst[13](u64: 3013)
763 7: Abort
764B3:
765 8: Ret
766}
767
768public update_price<Ty0, Ty1>(Arg0: &mut Oracle, Arg1: &PriceFeederCap, Arg2: u128, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {
769L6: loc0: Price<Ty0, Ty1>
770L7: loc1: u64
771L8: loc2: Pair<Ty0, Ty1>
772L9: loc3: u128
773L10: loc4: &mut PriceData
774L11: loc5: Price<Ty0, Ty1>
775L12: loc6: PriceData
776L13: loc7: address
777L14: loc8: u64
778B0:
779 0: CopyLoc[0](Arg0: &mut Oracle)
780 1: FreezeRef
781 2: Call validate_oracle_version(&Oracle)
782 3: MoveLoc[5](Arg5: &mut TxContext)
783 4: FreezeRef
784 5: Call tx_context::sender(&TxContext): address
785 6: StLoc[13](loc7: address)
786 7: CopyLoc[1](Arg1: &PriceFeederCap)
787 8: ImmBorrowField[9](PriceFeederCap.for_oracle: ID)
788 9: ReadRef
789 10: CopyLoc[0](Arg0: &mut Oracle)
790 11: ImmBorrowField[1](Oracle.id: UID)
791 12: Call object::uid_to_inner(&UID): ID
792 13: Eq
793 14: BrFalse(16)
794B1:
795 15: Branch(24)
796B2:
797 16: MoveLoc[0](Arg0: &mut Oracle)
798 17: Pop
799 18: MoveLoc[1](Arg1: &PriceFeederCap)
800 19: Pop
801 20: MoveLoc[4](Arg4: &Clock)
802 21: Pop
803 22: LdConst[1](u64: 3000)
804 23: Abort
805B3:
806 24: CopyLoc[0](Arg0: &mut Oracle)
807 25: FreezeRef
808 26: MoveLoc[1](Arg1: &PriceFeederCap)
809 27: Call assert_feeder_allowed(&Oracle, &PriceFeederCap)
810 28: CopyLoc[2](Arg2: u128)
811 29: LdU128(0)
812 30: Gt
813 31: BrFalse(33)
814B4:
815 32: Branch(39)
816B5:
817 33: MoveLoc[0](Arg0: &mut Oracle)
818 34: Pop
819 35: MoveLoc[4](Arg4: &Clock)
820 36: Pop
821 37: LdConst[4](u64: 3003)
822 38: Abort
823B6:
824 39: MoveLoc[3](Arg3: u64)
825 40: LdConst[15](u64: 86400)
826 41: LdU64(1000)
827 42: Mul
828 43: Call u64::min(u64, u64): u64
829 44: StLoc[14](loc8: u64)
830 45: CopyLoc[4](Arg4: &Clock)
831 46: Call clock::timestamp_ms(&Clock): u64
832 47: MoveLoc[14](loc8: u64)
833 48: Add
834 49: StLoc[7](loc1: u64)
835 50: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
836 51: StLoc[8](loc2: Pair<Ty0, Ty1>)
837 52: MoveLoc[2](Arg2: u128)
838 53: MoveLoc[7](loc1: u64)
839 54: Call internal_price::new_price<Ty0, Ty1>(u128, u64): Price<Ty0, Ty1>
840 55: StLoc[11](loc5: Price<Ty0, Ty1>)
841 56: CopyLoc[0](Arg0: &mut Oracle)
842 57: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
843 58: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
844 59: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
845 60: Call linked_table::contains<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): bool
846 61: BrFalse(63)
847B7:
848 62: Branch(69)
849B8:
850 63: MoveLoc[0](Arg0: &mut Oracle)
851 64: Pop
852 65: MoveLoc[4](Arg4: &Clock)
853 66: Pop
854 67: LdConst[2](u64: 3001)
855 68: Abort
856B9:
857 69: ImmBorrowLoc[11](loc5: Price<Ty0, Ty1>)
858 70: Call internal_price::get_raw<Ty0, Ty1>(&Price<Ty0, Ty1>): RawPrice
859 71: CopyLoc[4](Arg4: &Clock)
860 72: Call clock::timestamp_ms(&Clock): u64
861 73: MoveLoc[13](loc7: address)
862 74: Pack[7](PriceData)
863 75: StLoc[12](loc6: PriceData)
864 76: ImmBorrowLoc[11](loc5: Price<Ty0, Ty1>)
865 77: MoveLoc[4](Arg4: &Clock)
866 78: Call internal_price::is_expired<Ty0, Ty1>(&Price<Ty0, Ty1>, &Clock): bool
867 79: Not
868 80: BrFalse(82)
869B10:
870 81: Branch(86)
871B11:
872 82: MoveLoc[0](Arg0: &mut Oracle)
873 83: Pop
874 84: LdConst[3](u64: 3002)
875 85: Abort
876B12:
877 86: CopyLoc[0](Arg0: &mut Oracle)
878 87: ImmBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
879 88: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
880 89: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
881 90: Call table::contains<RawPair, PriceData>(&Table<RawPair, PriceData>, RawPair): bool
882 91: BrFalse(116)
883B13:
884 92: CopyLoc[0](Arg0: &mut Oracle)
885 93: MutBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
886 94: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
887 95: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
888 96: Call table::borrow_mut<RawPair, PriceData>(&mut Table<RawPair, PriceData>, RawPair): &mut PriceData
889 97: StLoc[10](loc4: &mut PriceData)
890 98: CopyLoc[10](loc4: &mut PriceData)
891 99: ImmBorrowField[0](PriceData.price: RawPrice)
892 100: Call internal_price::into_price<Ty0, Ty1>(&RawPrice): Price<Ty0, Ty1>
893 101: StLoc[6](loc0: Price<Ty0, Ty1>)
894 102: ImmBorrowLoc[6](loc0: Price<Ty0, Ty1>)
895 103: Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
896 104: StLoc[9](loc3: u128)
897 105: CopyLoc[0](Arg0: &mut Oracle)
898 106: ImmBorrowField[7](Oracle.price_threshold_ratio: u64)
899 107: ReadRef
900 108: MoveLoc[9](loc3: u128)
901 109: ImmBorrowLoc[11](loc5: Price<Ty0, Ty1>)
902 110: Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
903 111: Call assert_price_within_threshold(u64, u128, u128)
904 112: MoveLoc[12](loc6: PriceData)
905 113: MoveLoc[10](loc4: &mut PriceData)
906 114: WriteRef
907 115: Branch(122)
908B14:
909 116: CopyLoc[0](Arg0: &mut Oracle)
910 117: MutBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
911 118: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
912 119: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
913 120: MoveLoc[12](loc6: PriceData)
914 121: Call table::add<RawPair, PriceData>(&mut Table<RawPair, PriceData>, RawPair, PriceData)
915B15:
916 122: MoveLoc[0](Arg0: &mut Oracle)
917 123: ImmBorrowField[1](Oracle.id: UID)
918 124: Call object::uid_to_inner(&UID): ID
919 125: MoveLoc[11](loc5: Price<Ty0, Ty1>)
920 126: PackGeneric[0](PriceUpdated<Ty0, Ty1>)
921 127: Call event::emit<PriceUpdated<Ty0, Ty1>>(PriceUpdated<Ty0, Ty1>)
922 128: Ret
923}
924
925public update_price_with_expiry<Ty0, Ty1>(Arg0: &mut Oracle, Arg1: &PriceFeederCap, Arg2: u128, Arg3: u64, Arg4: &Clock, Arg5: &mut TxContext) {
926L6: loc0: bool
927L7: loc1: u64
928L8: loc2: Pair<Ty0, Ty1>
929L9: loc3: Price<Ty0, Ty1>
930L10: loc4: u64
931L11: loc5: u128
932L12: loc6: &mut PriceData
933L13: loc7: Price<Ty0, Ty1>
934L14: loc8: PriceData
935L15: loc9: address
936B0:
937 0: CopyLoc[0](Arg0: &mut Oracle)
938 1: FreezeRef
939 2: Call validate_oracle_version(&Oracle)
940 3: MoveLoc[5](Arg5: &mut TxContext)
941 4: FreezeRef
942 5: Call tx_context::sender(&TxContext): address
943 6: StLoc[15](loc9: address)
944 7: CopyLoc[1](Arg1: &PriceFeederCap)
945 8: ImmBorrowField[9](PriceFeederCap.for_oracle: ID)
946 9: ReadRef
947 10: CopyLoc[0](Arg0: &mut Oracle)
948 11: ImmBorrowField[1](Oracle.id: UID)
949 12: Call object::uid_to_inner(&UID): ID
950 13: Eq
951 14: BrFalse(16)
952B1:
953 15: Branch(24)
954B2:
955 16: MoveLoc[0](Arg0: &mut Oracle)
956 17: Pop
957 18: MoveLoc[1](Arg1: &PriceFeederCap)
958 19: Pop
959 20: MoveLoc[4](Arg4: &Clock)
960 21: Pop
961 22: LdConst[1](u64: 3000)
962 23: Abort
963B3:
964 24: CopyLoc[0](Arg0: &mut Oracle)
965 25: FreezeRef
966 26: MoveLoc[1](Arg1: &PriceFeederCap)
967 27: Call assert_feeder_allowed(&Oracle, &PriceFeederCap)
968 28: CopyLoc[4](Arg4: &Clock)
969 29: Call clock::timestamp_ms(&Clock): u64
970 30: StLoc[7](loc1: u64)
971 31: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
972 32: StLoc[8](loc2: Pair<Ty0, Ty1>)
973 33: MoveLoc[2](Arg2: u128)
974 34: CopyLoc[3](Arg3: u64)
975 35: Call internal_price::new_price<Ty0, Ty1>(u128, u64): Price<Ty0, Ty1>
976 36: StLoc[13](loc7: Price<Ty0, Ty1>)
977 37: CopyLoc[0](Arg0: &mut Oracle)
978 38: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
979 39: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
980 40: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
981 41: Call linked_table::contains<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): bool
982 42: BrFalse(44)
983B4:
984 43: Branch(50)
985B5:
986 44: MoveLoc[0](Arg0: &mut Oracle)
987 45: Pop
988 46: MoveLoc[4](Arg4: &Clock)
989 47: Pop
990 48: LdConst[2](u64: 3001)
991 49: Abort
992B6:
993 50: CopyLoc[3](Arg3: u64)
994 51: CopyLoc[7](loc1: u64)
995 52: LdConst[15](u64: 86400)
996 53: LdU64(1000)
997 54: Mul
998 55: Add
999 56: Le
1000 57: BrFalse(59)
1001B7:
1002 58: Branch(65)
1003B8:
1004 59: MoveLoc[0](Arg0: &mut Oracle)
1005 60: Pop
1006 61: MoveLoc[4](Arg4: &Clock)
1007 62: Pop
1008 63: LdConst[10](u64: 3010)
1009 64: Abort
1010B9:
1011 65: ImmBorrowLoc[13](loc7: Price<Ty0, Ty1>)
1012 66: MoveLoc[4](Arg4: &Clock)
1013 67: Call internal_price::is_expired<Ty0, Ty1>(&Price<Ty0, Ty1>, &Clock): bool
1014 68: Not
1015 69: BrFalse(71)
1016B10:
1017 70: Branch(75)
1018B11:
1019 71: MoveLoc[0](Arg0: &mut Oracle)
1020 72: Pop
1021 73: LdConst[3](u64: 3002)
1022 74: Abort
1023B12:
1024 75: ImmBorrowLoc[13](loc7: Price<Ty0, Ty1>)
1025 76: Call internal_price::get_raw<Ty0, Ty1>(&Price<Ty0, Ty1>): RawPrice
1026 77: CopyLoc[7](loc1: u64)
1027 78: MoveLoc[15](loc9: address)
1028 79: Pack[7](PriceData)
1029 80: StLoc[14](loc8: PriceData)
1030 81: CopyLoc[0](Arg0: &mut Oracle)
1031 82: ImmBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1032 83: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
1033 84: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1034 85: Call table::contains<RawPair, PriceData>(&Table<RawPair, PriceData>, RawPair): bool
1035 86: BrFalse(135)
1036B13:
1037 87: CopyLoc[0](Arg0: &mut Oracle)
1038 88: MutBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1039 89: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
1040 90: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1041 91: Call table::borrow_mut<RawPair, PriceData>(&mut Table<RawPair, PriceData>, RawPair): &mut PriceData
1042 92: StLoc[12](loc6: &mut PriceData)
1043 93: CopyLoc[12](loc6: &mut PriceData)
1044 94: ImmBorrowField[0](PriceData.price: RawPrice)
1045 95: Call internal_price::into_price<Ty0, Ty1>(&RawPrice): Price<Ty0, Ty1>
1046 96: StLoc[9](loc3: Price<Ty0, Ty1>)
1047 97: ImmBorrowLoc[9](loc3: Price<Ty0, Ty1>)
1048 98: Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
1049 99: StLoc[11](loc5: u128)
1050 100: ImmBorrowLoc[9](loc3: Price<Ty0, Ty1>)
1051 101: Call internal_price::get_expiry<Ty0, Ty1>(&Price<Ty0, Ty1>): u64
1052 102: StLoc[10](loc4: u64)
1053 103: CopyLoc[0](Arg0: &mut Oracle)
1054 104: ImmBorrowField[7](Oracle.price_threshold_ratio: u64)
1055 105: ReadRef
1056 106: MoveLoc[11](loc5: u128)
1057 107: ImmBorrowLoc[13](loc7: Price<Ty0, Ty1>)
1058 108: Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
1059 109: Call assert_price_within_threshold(u64, u128, u128)
1060 110: CopyLoc[10](loc4: u64)
1061 111: MoveLoc[7](loc1: u64)
1062 112: Gt
1063 113: BrFalse(119)
1064B14:
1065 114: MoveLoc[3](Arg3: u64)
1066 115: MoveLoc[10](loc4: u64)
1067 116: Lt
1068 117: StLoc[6](loc0: bool)
1069 118: Branch(121)
1070B15:
1071 119: LdFalse
1072 120: StLoc[6](loc0: bool)
1073B16:
1074 121: MoveLoc[6](loc0: bool)
1075 122: Not
1076 123: BrFalse(125)
1077B17:
1078 124: Branch(131)
1079B18:
1080 125: MoveLoc[12](loc6: &mut PriceData)
1081 126: Pop
1082 127: MoveLoc[0](Arg0: &mut Oracle)
1083 128: Pop
1084 129: LdConst[11](u64: 3011)
1085 130: Abort
1086B19:
1087 131: MoveLoc[14](loc8: PriceData)
1088 132: MoveLoc[12](loc6: &mut PriceData)
1089 133: WriteRef
1090 134: Branch(141)
1091B20:
1092 135: CopyLoc[0](Arg0: &mut Oracle)
1093 136: MutBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1094 137: ImmBorrowLoc[8](loc2: Pair<Ty0, Ty1>)
1095 138: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1096 139: MoveLoc[14](loc8: PriceData)
1097 140: Call table::add<RawPair, PriceData>(&mut Table<RawPair, PriceData>, RawPair, PriceData)
1098B21:
1099 141: MoveLoc[0](Arg0: &mut Oracle)
1100 142: ImmBorrowField[1](Oracle.id: UID)
1101 143: Call object::uid_to_inner(&UID): ID
1102 144: MoveLoc[13](loc7: Price<Ty0, Ty1>)
1103 145: PackGeneric[0](PriceUpdated<Ty0, Ty1>)
1104 146: Call event::emit<PriceUpdated<Ty0, Ty1>>(PriceUpdated<Ty0, Ty1>)
1105 147: Ret
1106}
1107
1108public halt_price<Ty0, Ty1>(Arg0: &mut Oracle, Arg1: &PriceFeederCap, Arg2: u128, Arg3: &Clock, Arg4: &mut TxContext) {
1109L5: loc0: Price<Ty0, Ty1>
1110L6: loc1: &mut PriceData
1111L7: loc2: u128
1112L8: loc3: u64
1113L9: loc4: Pair<Ty0, Ty1>
1114L10: loc5: Price<Ty0, Ty1>
1115L11: loc6: PriceData
1116L12: loc7: address
1117B0:
1118 0: CopyLoc[0](Arg0: &mut Oracle)
1119 1: FreezeRef
1120 2: Call validate_oracle_version(&Oracle)
1121 3: MoveLoc[4](Arg4: &mut TxContext)
1122 4: FreezeRef
1123 5: Call tx_context::sender(&TxContext): address
1124 6: StLoc[12](loc7: address)
1125 7: CopyLoc[1](Arg1: &PriceFeederCap)
1126 8: ImmBorrowField[9](PriceFeederCap.for_oracle: ID)
1127 9: ReadRef
1128 10: CopyLoc[0](Arg0: &mut Oracle)
1129 11: ImmBorrowField[1](Oracle.id: UID)
1130 12: Call object::uid_to_inner(&UID): ID
1131 13: Eq
1132 14: BrFalse(16)
1133B1:
1134 15: Branch(24)
1135B2:
1136 16: MoveLoc[0](Arg0: &mut Oracle)
1137 17: Pop
1138 18: MoveLoc[1](Arg1: &PriceFeederCap)
1139 19: Pop
1140 20: MoveLoc[3](Arg3: &Clock)
1141 21: Pop
1142 22: LdConst[1](u64: 3000)
1143 23: Abort
1144B3:
1145 24: CopyLoc[0](Arg0: &mut Oracle)
1146 25: FreezeRef
1147 26: MoveLoc[1](Arg1: &PriceFeederCap)
1148 27: Call assert_feeder_allowed(&Oracle, &PriceFeederCap)
1149 28: CopyLoc[3](Arg3: &Clock)
1150 29: Call clock::timestamp_ms(&Clock): u64
1151 30: LdU64(1)
1152 31: Sub
1153 32: StLoc[8](loc3: u64)
1154 33: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
1155 34: StLoc[9](loc4: Pair<Ty0, Ty1>)
1156 35: CopyLoc[0](Arg0: &mut Oracle)
1157 36: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1158 37: ImmBorrowLoc[9](loc4: Pair<Ty0, Ty1>)
1159 38: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1160 39: Call linked_table::contains<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): bool
1161 40: BrFalse(42)
1162B4:
1163 41: Branch(48)
1164B5:
1165 42: MoveLoc[0](Arg0: &mut Oracle)
1166 43: Pop
1167 44: MoveLoc[3](Arg3: &Clock)
1168 45: Pop
1169 46: LdConst[2](u64: 3001)
1170 47: Abort
1171B6:
1172 48: MoveLoc[2](Arg2: u128)
1173 49: MoveLoc[8](loc3: u64)
1174 50: Call internal_price::new_price<Ty0, Ty1>(u128, u64): Price<Ty0, Ty1>
1175 51: StLoc[10](loc5: Price<Ty0, Ty1>)
1176 52: CopyLoc[0](Arg0: &mut Oracle)
1177 53: ImmBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1178 54: ImmBorrowLoc[9](loc4: Pair<Ty0, Ty1>)
1179 55: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1180 56: Call table::contains<RawPair, PriceData>(&Table<RawPair, PriceData>, RawPair): bool
1181 57: Not
1182 58: BrFalse(64)
1183B7:
1184 59: MoveLoc[0](Arg0: &mut Oracle)
1185 60: Pop
1186 61: MoveLoc[3](Arg3: &Clock)
1187 62: Pop
1188 63: Ret
1189B8:
1190 64: ImmBorrowLoc[10](loc5: Price<Ty0, Ty1>)
1191 65: Call internal_price::get_raw<Ty0, Ty1>(&Price<Ty0, Ty1>): RawPrice
1192 66: MoveLoc[3](Arg3: &Clock)
1193 67: Call clock::timestamp_ms(&Clock): u64
1194 68: MoveLoc[12](loc7: address)
1195 69: Pack[7](PriceData)
1196 70: StLoc[11](loc6: PriceData)
1197 71: CopyLoc[0](Arg0: &mut Oracle)
1198 72: MutBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1199 73: ImmBorrowLoc[9](loc4: Pair<Ty0, Ty1>)
1200 74: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1201 75: Call table::borrow_mut<RawPair, PriceData>(&mut Table<RawPair, PriceData>, RawPair): &mut PriceData
1202 76: StLoc[6](loc1: &mut PriceData)
1203 77: CopyLoc[6](loc1: &mut PriceData)
1204 78: ImmBorrowField[0](PriceData.price: RawPrice)
1205 79: Call internal_price::into_price<Ty0, Ty1>(&RawPrice): Price<Ty0, Ty1>
1206 80: StLoc[5](loc0: Price<Ty0, Ty1>)
1207 81: ImmBorrowLoc[5](loc0: Price<Ty0, Ty1>)
1208 82: Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
1209 83: StLoc[7](loc2: u128)
1210 84: CopyLoc[0](Arg0: &mut Oracle)
1211 85: ImmBorrowField[7](Oracle.price_threshold_ratio: u64)
1212 86: ReadRef
1213 87: MoveLoc[7](loc2: u128)
1214 88: ImmBorrowLoc[10](loc5: Price<Ty0, Ty1>)
1215 89: Call internal_price::get_price<Ty0, Ty1>(&Price<Ty0, Ty1>): u128
1216 90: Call assert_price_within_threshold(u64, u128, u128)
1217 91: MoveLoc[11](loc6: PriceData)
1218 92: MoveLoc[6](loc1: &mut PriceData)
1219 93: WriteRef
1220 94: MoveLoc[0](Arg0: &mut Oracle)
1221 95: ImmBorrowField[1](Oracle.id: UID)
1222 96: Call object::uid_to_inner(&UID): ID
1223 97: MoveLoc[10](loc5: Price<Ty0, Ty1>)
1224 98: PackGeneric[1](PriceHalted<Ty0, Ty1>)
1225 99: Call event::emit<PriceHalted<Ty0, Ty1>>(PriceHalted<Ty0, Ty1>)
1226 100: Ret
1227}
1228
1229public reset_price<Ty0, Ty1>(Arg0: &mut Oracle, Arg1: &OracleAdminCap, Arg2: u128, Arg3: &Clock, Arg4: &mut TxContext) {
1230L5: loc0: u64
1231L6: loc1: Pair<Ty0, Ty1>
1232L7: loc2: &mut PriceData
1233L8: loc3: Price<Ty0, Ty1>
1234L9: loc4: PriceData
1235L10: loc5: address
1236B0:
1237 0: CopyLoc[0](Arg0: &mut Oracle)
1238 1: FreezeRef
1239 2: Call validate_oracle_version(&Oracle)
1240 3: MoveLoc[1](Arg1: &OracleAdminCap)
1241 4: ImmBorrowField[5](OracleAdminCap.oracle_id: ID)
1242 5: ReadRef
1243 6: CopyLoc[0](Arg0: &mut Oracle)
1244 7: ImmBorrowField[1](Oracle.id: UID)
1245 8: Call object::uid_to_inner(&UID): ID
1246 9: Eq
1247 10: BrFalse(12)
1248B1:
1249 11: Branch(20)
1250B2:
1251 12: MoveLoc[0](Arg0: &mut Oracle)
1252 13: Pop
1253 14: MoveLoc[4](Arg4: &mut TxContext)
1254 15: Pop
1255 16: MoveLoc[3](Arg3: &Clock)
1256 17: Pop
1257 18: LdConst[1](u64: 3000)
1258 19: Abort
1259B3:
1260 20: MoveLoc[4](Arg4: &mut TxContext)
1261 21: FreezeRef
1262 22: Call tx_context::sender(&TxContext): address
1263 23: StLoc[10](loc5: address)
1264 24: CopyLoc[3](Arg3: &Clock)
1265 25: Call clock::timestamp_ms(&Clock): u64
1266 26: LdU64(1)
1267 27: Sub
1268 28: StLoc[5](loc0: u64)
1269 29: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
1270 30: StLoc[6](loc1: Pair<Ty0, Ty1>)
1271 31: MoveLoc[2](Arg2: u128)
1272 32: MoveLoc[5](loc0: u64)
1273 33: Call internal_price::new_price<Ty0, Ty1>(u128, u64): Price<Ty0, Ty1>
1274 34: StLoc[8](loc3: Price<Ty0, Ty1>)
1275 35: CopyLoc[0](Arg0: &mut Oracle)
1276 36: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1277 37: ImmBorrowLoc[6](loc1: Pair<Ty0, Ty1>)
1278 38: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1279 39: Call linked_table::contains<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): bool
1280 40: BrFalse(42)
1281B4:
1282 41: Branch(48)
1283B5:
1284 42: MoveLoc[0](Arg0: &mut Oracle)
1285 43: Pop
1286 44: MoveLoc[3](Arg3: &Clock)
1287 45: Pop
1288 46: LdConst[2](u64: 3001)
1289 47: Abort
1290B6:
1291 48: ImmBorrowLoc[8](loc3: Price<Ty0, Ty1>)
1292 49: Call internal_price::get_raw<Ty0, Ty1>(&Price<Ty0, Ty1>): RawPrice
1293 50: MoveLoc[3](Arg3: &Clock)
1294 51: Call clock::timestamp_ms(&Clock): u64
1295 52: MoveLoc[10](loc5: address)
1296 53: Pack[7](PriceData)
1297 54: StLoc[9](loc4: PriceData)
1298 55: CopyLoc[0](Arg0: &mut Oracle)
1299 56: ImmBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1300 57: ImmBorrowLoc[6](loc1: Pair<Ty0, Ty1>)
1301 58: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1302 59: Call table::contains<RawPair, PriceData>(&Table<RawPair, PriceData>, RawPair): bool
1303 60: BrFalse(62)
1304B7:
1305 61: Branch(66)
1306B8:
1307 62: MoveLoc[0](Arg0: &mut Oracle)
1308 63: Pop
1309 64: LdConst[8](u64: 3008)
1310 65: Abort
1311B9:
1312 66: CopyLoc[0](Arg0: &mut Oracle)
1313 67: MutBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1314 68: ImmBorrowLoc[6](loc1: Pair<Ty0, Ty1>)
1315 69: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1316 70: Call table::borrow_mut<RawPair, PriceData>(&mut Table<RawPair, PriceData>, RawPair): &mut PriceData
1317 71: StLoc[7](loc2: &mut PriceData)
1318 72: MoveLoc[9](loc4: PriceData)
1319 73: MoveLoc[7](loc2: &mut PriceData)
1320 74: WriteRef
1321 75: MoveLoc[0](Arg0: &mut Oracle)
1322 76: ImmBorrowField[1](Oracle.id: UID)
1323 77: Call object::uid_to_inner(&UID): ID
1324 78: MoveLoc[8](loc3: Price<Ty0, Ty1>)
1325 79: PackGeneric[2](PriceReseted<Ty0, Ty1>)
1326 80: Call event::emit<PriceReseted<Ty0, Ty1>>(PriceReseted<Ty0, Ty1>)
1327 81: Ret
1328}
1329
1330public delete_price_feeder_cap(Arg0: PriceFeederCap, Arg1: &mut TxContext) {
1331L2: loc0: ID
1332L3: loc1: UID
1333B0:
1334 0: MoveLoc[0](Arg0: PriceFeederCap)
1335 1: Unpack[1](PriceFeederCap)
1336 2: StLoc[2](loc0: ID)
1337 3: StLoc[3](loc1: UID)
1338 4: MoveLoc[2](loc0: ID)
1339 5: ImmBorrowLoc[3](loc1: UID)
1340 6: Call object::uid_to_inner(&UID): ID
1341 7: Pack[12](PriceFeederCapDeleted)
1342 8: Call event::emit<PriceFeederCapDeleted>(PriceFeederCapDeleted)
1343 9: MoveLoc[3](loc1: UID)
1344 10: Call object::delete(UID)
1345 11: Ret
1346}
1347
1348public add_asset_pair<Ty0, Ty1>(Arg0: &mut Oracle, Arg1: &OracleAdminCap, Arg2: u8, Arg3: u8, Arg4: &mut TxContext) {
1349L5: loc0: String
1350L6: loc1: Pair<Ty0, Ty1>
1351L7: loc2: String
1352B0:
1353 0: CopyLoc[0](Arg0: &mut Oracle)
1354 1: FreezeRef
1355 2: Call validate_oracle_version(&Oracle)
1356 3: MoveLoc[1](Arg1: &OracleAdminCap)
1357 4: ImmBorrowField[5](OracleAdminCap.oracle_id: ID)
1358 5: ReadRef
1359 6: CopyLoc[0](Arg0: &mut Oracle)
1360 7: ImmBorrowField[1](Oracle.id: UID)
1361 8: Call object::uid_to_inner(&UID): ID
1362 9: Eq
1363 10: BrFalse(12)
1364B1:
1365 11: Branch(16)
1366B2:
1367 12: MoveLoc[0](Arg0: &mut Oracle)
1368 13: Pop
1369 14: LdConst[1](u64: 3000)
1370 15: Abort
1371B3:
1372 16: Call type_name::with_defining_ids<Ty0>(): TypeName
1373 17: Call type_name::with_defining_ids<Ty1>(): TypeName
1374 18: Neq
1375 19: BrFalse(21)
1376B4:
1377 20: Branch(25)
1378B5:
1379 21: MoveLoc[0](Arg0: &mut Oracle)
1380 22: Pop
1381 23: LdConst[12](u64: 3012)
1382 24: Abort
1383B6:
1384 25: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
1385 26: StLoc[6](loc1: Pair<Ty0, Ty1>)
1386 27: CopyLoc[0](Arg0: &mut Oracle)
1387 28: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1388 29: ImmBorrowLoc[6](loc1: Pair<Ty0, Ty1>)
1389 30: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1390 31: Call linked_table::contains<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): bool
1391 32: Not
1392 33: BrFalse(35)
1393B7:
1394 34: Branch(39)
1395B8:
1396 35: MoveLoc[0](Arg0: &mut Oracle)
1397 36: Pop
1398 37: LdConst[7](u64: 3006)
1399 38: Abort
1400B9:
1401 39: Call type_name::with_defining_ids<Ty0>(): TypeName
1402 40: Call type_name::into_string(TypeName): String
1403 41: StLoc[5](loc0: String)
1404 42: Call type_name::with_defining_ids<Ty1>(): TypeName
1405 43: Call type_name::into_string(TypeName): String
1406 44: StLoc[7](loc2: String)
1407 45: CopyLoc[0](Arg0: &mut Oracle)
1408 46: MutBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1409 47: ImmBorrowLoc[6](loc1: Pair<Ty0, Ty1>)
1410 48: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1411 49: CopyLoc[5](loc0: String)
1412 50: CopyLoc[7](loc2: String)
1413 51: CopyLoc[2](Arg2: u8)
1414 52: CopyLoc[3](Arg3: u8)
1415 53: Pack[5](AssetPair)
1416 54: Call linked_table::push_back<RawPair, AssetPair>(&mut LinkedTable<RawPair, AssetPair>, RawPair, AssetPair)
1417 55: MoveLoc[0](Arg0: &mut Oracle)
1418 56: ImmBorrowField[1](Oracle.id: UID)
1419 57: Call object::uid_to_inner(&UID): ID
1420 58: MoveLoc[5](loc0: String)
1421 59: MoveLoc[7](loc2: String)
1422 60: MoveLoc[2](Arg2: u8)
1423 61: MoveLoc[3](Arg3: u8)
1424 62: PackGeneric[3](AssetPairAdded<Ty0, Ty1>)
1425 63: Call event::emit<AssetPairAdded<Ty0, Ty1>>(AssetPairAdded<Ty0, Ty1>)
1426 64: Ret
1427}
1428
1429public remove_asset_pair<Ty0, Ty1>(Arg0: &mut Oracle, Arg1: &OracleAdminCap, Arg2: &mut TxContext) {
1430L3: loc0: String
1431L4: loc1: Pair<Ty0, Ty1>
1432L5: loc2: String
1433B0:
1434 0: CopyLoc[0](Arg0: &mut Oracle)
1435 1: FreezeRef
1436 2: Call validate_oracle_version(&Oracle)
1437 3: MoveLoc[1](Arg1: &OracleAdminCap)
1438 4: ImmBorrowField[5](OracleAdminCap.oracle_id: ID)
1439 5: ReadRef
1440 6: CopyLoc[0](Arg0: &mut Oracle)
1441 7: ImmBorrowField[1](Oracle.id: UID)
1442 8: Call object::uid_to_inner(&UID): ID
1443 9: Eq
1444 10: BrFalse(12)
1445B1:
1446 11: Branch(16)
1447B2:
1448 12: MoveLoc[0](Arg0: &mut Oracle)
1449 13: Pop
1450 14: LdConst[1](u64: 3000)
1451 15: Abort
1452B3:
1453 16: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
1454 17: StLoc[4](loc1: Pair<Ty0, Ty1>)
1455 18: CopyLoc[0](Arg0: &mut Oracle)
1456 19: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1457 20: ImmBorrowLoc[4](loc1: Pair<Ty0, Ty1>)
1458 21: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1459 22: Call linked_table::contains<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): bool
1460 23: BrFalse(25)
1461B4:
1462 24: Branch(29)
1463B5:
1464 25: MoveLoc[0](Arg0: &mut Oracle)
1465 26: Pop
1466 27: LdConst[2](u64: 3001)
1467 28: Abort
1468B6:
1469 29: CopyLoc[0](Arg0: &mut Oracle)
1470 30: ImmBorrowLoc[4](loc1: Pair<Ty0, Ty1>)
1471 31: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1472 32: Call internal_remove_price(&mut Oracle, RawPair)
1473 33: CopyLoc[0](Arg0: &mut Oracle)
1474 34: MoveLoc[4](loc1: Pair<Ty0, Ty1>)
1475 35: Call internal_remove_asset_pair<Ty0, Ty1>(&mut Oracle, Pair<Ty0, Ty1>): String * String
1476 36: StLoc[5](loc2: String)
1477 37: StLoc[3](loc0: String)
1478 38: MoveLoc[0](Arg0: &mut Oracle)
1479 39: ImmBorrowField[1](Oracle.id: UID)
1480 40: Call object::uid_to_inner(&UID): ID
1481 41: MoveLoc[3](loc0: String)
1482 42: MoveLoc[5](loc2: String)
1483 43: PackGeneric[4](AssetPairRemoved<Ty0, Ty1>)
1484 44: Call event::emit<AssetPairRemoved<Ty0, Ty1>>(AssetPairRemoved<Ty0, Ty1>)
1485 45: Ret
1486}
1487
1488assert_price_within_threshold(Arg0: u64, Arg1: u128, Arg2: u128) {
1489L3: loc0: bool
1490L4: loc1: u128
1491L5: loc2: u128
1492L6: loc3: u128
1493L7: loc4: u128
1494L8: loc5: u128
1495B0:
1496 0: MoveLoc[0](Arg0: u64)
1497 1: CastU128
1498 2: StLoc[6](loc3: u128)
1499 3: LdConst[0](u128: 10000)
1500 4: CopyLoc[6](loc3: u128)
1501 5: Sub
1502 6: StLoc[5](loc2: u128)
1503 7: CopyLoc[1](Arg1: u128)
1504 8: MoveLoc[5](loc2: u128)
1505 9: LdConst[0](u128: 10000)
1506 10: Call math::mul_div_u128(u128, u128, u128): u128
1507 11: StLoc[4](loc1: u128)
1508 12: LdConst[0](u128: 10000)
1509 13: MoveLoc[6](loc3: u128)
1510 14: Add
1511 15: StLoc[8](loc5: u128)
1512 16: MoveLoc[1](Arg1: u128)
1513 17: MoveLoc[8](loc5: u128)
1514 18: LdConst[0](u128: 10000)
1515 19: Call math::mul_div_u128(u128, u128, u128): u128
1516 20: StLoc[7](loc4: u128)
1517 21: CopyLoc[2](Arg2: u128)
1518 22: MoveLoc[4](loc1: u128)
1519 23: Ge
1520 24: BrFalse(30)
1521B1:
1522 25: MoveLoc[2](Arg2: u128)
1523 26: MoveLoc[7](loc4: u128)
1524 27: Le
1525 28: StLoc[3](loc0: bool)
1526 29: Branch(32)
1527B2:
1528 30: LdFalse
1529 31: StLoc[3](loc0: bool)
1530B3:
1531 32: MoveLoc[3](loc0: bool)
1532 33: BrFalse(35)
1533B4:
1534 34: Branch(37)
1535B5:
1536 35: LdConst[4](u64: 3003)
1537 36: Abort
1538B6:
1539 37: Ret
1540}
1541
1542internal_remove_asset_pair<Ty0, Ty1>(Arg0: &mut Oracle, Arg1: Pair<Ty0, Ty1>): String * String {
1543L2: loc0: &AssetPair
1544L3: loc1: String
1545L4: loc2: String
1546B0:
1547 0: CopyLoc[0](Arg0: &mut Oracle)
1548 1: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1549 2: ImmBorrowLoc[1](Arg1: Pair<Ty0, Ty1>)
1550 3: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1551 4: Call linked_table::borrow<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): &AssetPair
1552 5: StLoc[2](loc0: &AssetPair)
1553 6: CopyLoc[2](loc0: &AssetPair)
1554 7: ImmBorrowField[12](AssetPair.base_name: String)
1555 8: ReadRef
1556 9: StLoc[3](loc1: String)
1557 10: MoveLoc[2](loc0: &AssetPair)
1558 11: ImmBorrowField[13](AssetPair.quote_name: String)
1559 12: ReadRef
1560 13: StLoc[4](loc2: String)
1561 14: MoveLoc[0](Arg0: &mut Oracle)
1562 15: MutBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1563 16: ImmBorrowLoc[1](Arg1: Pair<Ty0, Ty1>)
1564 17: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1565 18: Call linked_table::remove<RawPair, AssetPair>(&mut LinkedTable<RawPair, AssetPair>, RawPair): AssetPair
1566 19: Pop
1567 20: MoveLoc[3](loc1: String)
1568 21: MoveLoc[4](loc2: String)
1569 22: Ret
1570}
1571
1572internal_remove_price(Arg0: &mut Oracle, Arg1: RawPair) {
1573B0:
1574 0: CopyLoc[0](Arg0: &mut Oracle)
1575 1: ImmBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1576 2: CopyLoc[1](Arg1: RawPair)
1577 3: Call table::contains<RawPair, PriceData>(&Table<RawPair, PriceData>, RawPair): bool
1578 4: BrFalse(11)
1579B1:
1580 5: MoveLoc[0](Arg0: &mut Oracle)
1581 6: MutBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1582 7: MoveLoc[1](Arg1: RawPair)
1583 8: Call table::remove<RawPair, PriceData>(&mut Table<RawPair, PriceData>, RawPair): PriceData
1584 9: Pop
1585 10: Branch(13)
1586B2:
1587 11: MoveLoc[0](Arg0: &mut Oracle)
1588 12: Pop
1589B3:
1590 13: Ret
1591}
1592
1593public config_into(Arg0: &ConfigResponse): u64 * u64 {
1594B0:
1595 0: CopyLoc[0](Arg0: &ConfigResponse)
1596 1: ImmBorrowField[14](ConfigResponse.price_threshold_ratio: u64)
1597 2: ReadRef
1598 3: MoveLoc[0](Arg0: &ConfigResponse)
1599 4: ImmBorrowField[15](ConfigResponse.default_price_expiry_seconds: u64)
1600 5: ReadRef
1601 6: Ret
1602}
1603
1604public config(Arg0: &Oracle): ConfigResponse {
1605B0:
1606 0: CopyLoc[0](Arg0: &Oracle)
1607 1: ImmBorrowField[7](Oracle.price_threshold_ratio: u64)
1608 2: ReadRef
1609 3: MoveLoc[0](Arg0: &Oracle)
1610 4: ImmBorrowField[8](Oracle.default_price_expiry_seconds: u64)
1611 5: ReadRef
1612 6: Pack[22](ConfigResponse)
1613 7: Ret
1614}
1615
1616public check_asset_pair_exists<Ty0, Ty1>(Arg0: &mut Oracle): bool {
1617L1: loc0: Pair<Ty0, Ty1>
1618B0:
1619 0: CopyLoc[0](Arg0: &mut Oracle)
1620 1: FreezeRef
1621 2: Call validate_oracle_version(&Oracle)
1622 3: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
1623 4: StLoc[1](loc0: Pair<Ty0, Ty1>)
1624 5: MoveLoc[0](Arg0: &mut Oracle)
1625 6: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1626 7: ImmBorrowLoc[1](loc0: Pair<Ty0, Ty1>)
1627 8: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1628 9: Call linked_table::contains<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): bool
1629 10: Ret
1630}
1631
1632public(friend) is_price_feeder_whitelisted(Arg0: &Oracle, Arg1: ID): bool {
1633B0:
1634 0: MoveLoc[0](Arg0: &Oracle)
1635 1: ImmBorrowField[1](Oracle.id: UID)
1636 2: LdFalse
1637 3: Pack[3](FeederGuardKey)
1638 4: Call dynamic_field::borrow<FeederGuardKey, FeederGuard>(&UID, FeederGuardKey): &FeederGuard
1639 5: ImmBorrowField[3](FeederGuard.active: Table<ID, bool>)
1640 6: MoveLoc[1](Arg1: ID)
1641 7: Call table::contains<ID, bool>(&Table<ID, bool>, ID): bool
1642 8: Ret
1643}
1644
1645public get_price<Ty0, Ty1>(Arg0: &Oracle): PriceResponse {
1646L1: loc0: Pair<Ty0, Ty1>
1647L2: loc1: Price<Ty0, Ty1>
1648L3: loc2: Price<Ty0, Ty1>
1649L4: loc3: &PriceData
1650L5: loc4: &PriceData
1651B0:
1652 0: Call internal_pair::new_pair<Ty0, Ty1>(): Pair<Ty0, Ty1>
1653 1: StLoc[1](loc0: Pair<Ty0, Ty1>)
1654 2: CopyLoc[0](Arg0: &Oracle)
1655 3: ImmBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1656 4: ImmBorrowLoc[1](loc0: Pair<Ty0, Ty1>)
1657 5: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1658 6: Call table::contains<RawPair, PriceData>(&Table<RawPair, PriceData>, RawPair): bool
1659 7: BrFalse(9)
1660B1:
1661 8: Branch(15)
1662B2:
1663 9: MoveLoc[0](Arg0: &Oracle)
1664 10: Pop
1665 11: Call option::none<PriceData>(): Option<PriceData>
1666 12: LdFalse
1667 13: Pack[8](PriceResponse)
1668 14: Ret
1669B3:
1670 15: MoveLoc[0](Arg0: &Oracle)
1671 16: ImmBorrowField[11](Oracle.prices: Table<RawPair, PriceData>)
1672 17: ImmBorrowLoc[1](loc0: Pair<Ty0, Ty1>)
1673 18: Call internal_pair::get_raw<Ty0, Ty1>(&Pair<Ty0, Ty1>): RawPair
1674 19: Call table::borrow<RawPair, PriceData>(&Table<RawPair, PriceData>, RawPair): &PriceData
1675 20: StLoc[4](loc3: &PriceData)
1676 21: CopyLoc[4](loc3: &PriceData)
1677 22: ImmBorrowField[0](PriceData.price: RawPrice)
1678 23: Call internal_price::into_price<Ty0, Ty1>(&RawPrice): Price<Ty0, Ty1>
1679 24: StLoc[2](loc1: Price<Ty0, Ty1>)
1680 25: MoveLoc[4](loc3: &PriceData)
1681 26: MoveLoc[2](loc1: Price<Ty0, Ty1>)
1682 27: StLoc[3](loc2: Price<Ty0, Ty1>)
1683 28: StLoc[5](loc4: &PriceData)
1684 29: ImmBorrowLoc[3](loc2: Price<Ty0, Ty1>)
1685 30: Call internal_price::get_raw<Ty0, Ty1>(&Price<Ty0, Ty1>): RawPrice
1686 31: CopyLoc[5](loc4: &PriceData)
1687 32: ImmBorrowField[16](PriceData.last_updated_ms: u64)
1688 33: ReadRef
1689 34: MoveLoc[5](loc4: &PriceData)
1690 35: ImmBorrowField[17](PriceData.updater: address)
1691 36: ReadRef
1692 37: Pack[7](PriceData)
1693 38: Call option::some<PriceData>(PriceData): Option<PriceData>
1694 39: LdFalse
1695 40: Pack[8](PriceResponse)
1696 41: Ret
1697}
1698
1699public get_valid_price<Ty0, Ty1>(Arg0: &Oracle, Arg1: &Clock): PriceData * bool {
1700L2: loc0: Price<Ty0, Ty1>
1701L3: loc1: PriceData
1702L4: loc2: PriceResponse
1703B0:
1704 0: CopyLoc[0](Arg0: &Oracle)
1705 1: Call validate_oracle_version(&Oracle)
1706 2: MoveLoc[0](Arg0: &Oracle)
1707 3: Call get_price<Ty0, Ty1>(&Oracle): PriceResponse
1708 4: StLoc[4](loc2: PriceResponse)
1709 5: ImmBorrowLoc[4](loc2: PriceResponse)
1710 6: ImmBorrowField[18](PriceResponse.pair_data: Option<PriceData>)
1711 7: Call option::is_some<PriceData>(&Option<PriceData>): bool
1712 8: BrFalse(10)
1713B1:
1714 9: Branch(14)
1715B2:
1716 10: MoveLoc[1](Arg1: &Clock)
1717 11: Pop
1718 12: LdConst[8](u64: 3008)
1719 13: Abort
1720B3:
1721 14: ImmBorrowLoc[4](loc2: PriceResponse)
1722 15: ImmBorrowField[18](PriceResponse.pair_data: Option<PriceData>)
1723 16: Call option::borrow<PriceData>(&Option<PriceData>): &PriceData
1724 17: ReadRef
1725 18: StLoc[3](loc1: PriceData)
1726 19: ImmBorrowLoc[3](loc1: PriceData)
1727 20: ImmBorrowField[0](PriceData.price: RawPrice)
1728 21: Call internal_price::into_price<Ty0, Ty1>(&RawPrice): Price<Ty0, Ty1>
1729 22: StLoc[2](loc0: Price<Ty0, Ty1>)
1730 23: ImmBorrowLoc[2](loc0: Price<Ty0, Ty1>)
1731 24: MoveLoc[1](Arg1: &Clock)
1732 25: Call internal_price::is_expired<Ty0, Ty1>(&Price<Ty0, Ty1>, &Clock): bool
1733 26: Not
1734 27: BrFalse(29)
1735B4:
1736 28: Branch(31)
1737B5:
1738 29: LdConst[3](u64: 3002)
1739 30: Abort
1740B6:
1741 31: MoveLoc[3](loc1: PriceData)
1742 32: ImmBorrowLoc[4](loc2: PriceResponse)
1743 33: ImmBorrowField[19](PriceResponse.is_inverted: bool)
1744 34: ReadRef
1745 35: Ret
1746}
1747
1748public price_data_price<Ty0, Ty1>(Arg0: &PriceData): Price<Ty0, Ty1> {
1749B0:
1750 0: MoveLoc[0](Arg0: &PriceData)
1751 1: ImmBorrowField[0](PriceData.price: RawPrice)
1752 2: Call internal_price::into_price<Ty0, Ty1>(&RawPrice): Price<Ty0, Ty1>
1753 3: Ret
1754}
1755
1756public price_data_last_updated(Arg0: &PriceData): u64 {
1757B0:
1758 0: MoveLoc[0](Arg0: &PriceData)
1759 1: ImmBorrowField[16](PriceData.last_updated_ms: u64)
1760 2: ReadRef
1761 3: Ret
1762}
1763
1764public price_response_pair_data(Arg0: &PriceResponse): Option<PriceData> {
1765B0:
1766 0: MoveLoc[0](Arg0: &PriceResponse)
1767 1: ImmBorrowField[18](PriceResponse.pair_data: Option<PriceData>)
1768 2: ReadRef
1769 3: Ret
1770}
1771
1772public asset_pair_response_pair(Arg0: &AssetPairResponse): RawPair {
1773B0:
1774 0: MoveLoc[0](Arg0: &AssetPairResponse)
1775 1: ImmBorrowField[20](AssetPairResponse.pair: RawPair)
1776 2: ReadRef
1777 3: Ret
1778}
1779
1780public asset_pairs(Arg0: &Oracle): vector<AssetPairResponse> {
1781L1: loc0: &AssetPair
1782L2: loc1: vector<AssetPairResponse>
1783L3: loc2: &Option<RawPair>
1784L4: loc3: RawPair
1785B0:
1786 0: VecPack(113, 0)
1787 1: StLoc[2](loc1: vector<AssetPairResponse>)
1788 2: CopyLoc[0](Arg0: &Oracle)
1789 3: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1790 4: Call linked_table::front<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>): &Option<RawPair>
1791 5: StLoc[3](loc2: &Option<RawPair>)
1792B1:
1793 6: CopyLoc[3](loc2: &Option<RawPair>)
1794 7: Call option::is_some<RawPair>(&Option<RawPair>): bool
1795 8: BrFalse(31)
1796B2:
1797 9: Branch(10)
1798B3:
1799 10: MoveLoc[3](loc2: &Option<RawPair>)
1800 11: Call option::borrow<RawPair>(&Option<RawPair>): &RawPair
1801 12: ReadRef
1802 13: StLoc[4](loc3: RawPair)
1803 14: CopyLoc[0](Arg0: &Oracle)
1804 15: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1805 16: CopyLoc[4](loc3: RawPair)
1806 17: Call linked_table::borrow<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): &AssetPair
1807 18: StLoc[1](loc0: &AssetPair)
1808 19: MutBorrowLoc[2](loc1: vector<AssetPairResponse>)
1809 20: CopyLoc[4](loc3: RawPair)
1810 21: MoveLoc[1](loc0: &AssetPair)
1811 22: ReadRef
1812 23: Pack[6](AssetPairResponse)
1813 24: VecPushBack(113)
1814 25: CopyLoc[0](Arg0: &Oracle)
1815 26: ImmBorrowField[10](Oracle.supported_pairs: LinkedTable<RawPair, AssetPair>)
1816 27: MoveLoc[4](loc3: RawPair)
1817 28: Call linked_table::next<RawPair, AssetPair>(&LinkedTable<RawPair, AssetPair>, RawPair): &Option<RawPair>
1818 29: StLoc[3](loc2: &Option<RawPair>)
1819 30: Branch(6)
1820B4:
1821 31: MoveLoc[0](Arg0: &Oracle)
1822 32: Pop
1823 33: MoveLoc[3](loc2: &Option<RawPair>)
1824 34: Pop
1825 35: MoveLoc[2](loc1: vector<AssetPairResponse>)
1826 36: Ret
1827}
1828
1829public update_module_version(Arg0: &mut Oracle) {
1830B0:
1831 0: LdConst[9](u64: 3009)
1832 1: Abort
1833}
1834
1835Constants [
1836 0 => u128: 10000
1837 1 => u64: 3000
1838 2 => u64: 3001
1839 3 => u64: 3002
1840 4 => u64: 3003
1841 5 => u64: 3004
1842 6 => u64: 3005
1843 7 => u64: 3006
1844 8 => u64: 3008
1845 9 => u64: 3009
1846 10 => u64: 3010
1847 11 => u64: 3011
1848 12 => u64: 3012
1849 13 => u64: 3013
1850 14 => u64: 300
1851 15 => u64: 86400
1852]
1853}
1854
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
This code is deployed at one address. Any other address running the same bytecode would appear here too, already verified.