tx · HhLmRNBtyHTQyzdkatBcYAFqEkawcmMFykXyeUQfVQpd

3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4:  -0.01800000 Waves

2024.07.04 11:03 [3179005] smart account 3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HhLmRNBtyHTQyzdkatBcYAFqEkawcmMFykXyeUQfVQpd",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1720080218023,
    "version": 2,
    "chainId": 84,
    "sender": "3MpiUwTkYopBwQEjyTf8sqy7iWLNwyq9Md4",
    "senderPublicKey": "9eCupW2UoCBhmiF1N9qWACCzkWT885DVzb65b8zxcSii",
    "proofs": [
        "zWy5Wo6c69wyzUCui2QzNiwDbxeDGi6DJgdF1Kwo3JzHB2JB3CfoEDiVUF7FXMUCey6fpcw1KzkzzjDzUhtBpZh"
    ],
    "script": "base64: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",
    "height": 3179005,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: FQi5iBpKorRvf6vjMgJwf5hwCYC9sPPCHSY6tXNi5q2T

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "__"
5+
6+let b = "MULTISIG"
7+
8+let c = "STATUS"
9+
10+let d = "INIT"
11+
12+let e = "SEQUENCER"
13+
14+let f = "ACCOUNT_STORAGE"
15+
16+let g = "FEE_RECIPIENT"
17+
18+let h = "SYMBOL"
19+
20+let i = "ORDER_FILLED_AMOUNT"
21+
22+let j = "REWARD_DISTRIBUTOR"
23+
24+let k = "externalTransfer"
25+
26+let l = "claimReward"
27+
28+let m = "SPOT"
29+
30+let n = 1
31+
32+let o = 2
33+
34+let p = 1
35+
36+let q = 1
37+
38+let r = 2
39+
40+let s = 1
41+
42+let t = 2
43+
44+let u = toBigInt(0)
45+
46+let v = toBigInt(1)
47+
48+let w = toBigInt(100000000)
49+
50+let x = toBigInt(100000)
51+
52+let y = base58'G5Nu92G2p7moXW9qjjN3na7gtq4dWCeVdaSjry'
53+
54+func z (A,B) = {
55+    let C = addressFromString(A)
56+    if ($isInstanceOf(C, "Address"))
57+        then {
58+            let D = C
59+            true
60+            }
61+        else throw(B)
62+    }
63+
64+
65+func E (F,G,B) = if ((G > F))
66+    then throw(B)
67+    else true
68+
69+
70+func H (I,J,B) = if ((I != J))
71+    then throw(B)
72+    else true
73+
74+
75+func K (I,J,B) = if ((I == J))
76+    then throw(B)
77+    else true
78+
79+
80+func L (F,B) = if (if ((0 >= size(F)))
81+    then true
82+    else contains(F, a))
83+    then throw(B)
84+    else true
85+
86+
87+func M (I,J,B) = if ((I != J))
88+    then throw(B)
89+    else true
90+
91+
92+func N () = {
93+    let C = getBoolean(d)
94+    if ($isInstanceOf(C, "Boolean"))
95+        then {
96+            let D = C
97+            D
98+            }
99+        else false
100+    }
101+
102+
103+func O (P) = [BooleanEntry(d, P)]
104+
105+
106+func Q () = {
107+    let C = getString(b)
108+    if ($isInstanceOf(C, "String"))
109+        then {
110+            let D = C
111+            addressFromStringValue(D)
112+            }
113+        else Address(base58'')
114+    }
115+
116+
117+func R (S) = [StringEntry(b, toString(S))]
118+
119+
120+func T () = {
121+    let C = getString(e)
122+    if ($isInstanceOf(C, "String"))
123+        then {
124+            let D = C
125+            addressFromStringValue(D)
126+            }
127+        else Address(base58'')
128+    }
129+
130+
131+func U (V) = [StringEntry(e, toString(V))]
132+
133+
134+func W () = {
135+    let C = getString(f)
136+    if ($isInstanceOf(C, "String"))
137+        then {
138+            let D = C
139+            addressFromStringValue(D)
140+            }
141+        else Address(base58'')
142+    }
143+
144+
145+func X (Y) = [StringEntry(f, toString(Y))]
146+
147+
148+func Z () = {
149+    let C = getString(g)
150+    if ($isInstanceOf(C, "String"))
151+        then {
152+            let D = C
153+            D
154+            }
155+        else ""
156+    }
157+
158+
159+func aa (ab) = [StringEntry(g, ab)]
160+
161+
162+func ac () = {
163+    let C = getString(j)
164+    if ($isInstanceOf(C, "String"))
165+        then {
166+            let D = C
167+            D
168+            }
169+        else ""
170+    }
171+
172+
173+func ad (ae) = [StringEntry(j, ae)]
174+
175+
176+func af (ag) = {
177+    let C = getBoolean(makeString([h, ag], a))
178+    if ($isInstanceOf(C, "Boolean"))
179+        then {
180+            let D = C
181+            D
182+            }
183+        else false
184+    }
185+
186+
187+func ah (ag,F) = [BooleanEntry(makeString([h, ag], a), F)]
188+
189+
190+func ai (aj) = {
191+    let C = getString(makeString([i, toBase58String(aj)], a))
192+    if ($isInstanceOf(C, "String"))
193+        then {
194+            let D = C
195+            parseBigIntValue(D)
196+            }
197+        else u
198+    }
199+
200+
201+func ak (aj,al) = [StringEntry(makeString([i, toBase58String(aj)], a), toString(al))]
202+
203+
204+func am (an) = if ((an != this))
205+    then throw("_onlyThisContract: revert")
206+    else true
207+
208+
209+func ao () = if ((Q() == Address(base58'')))
210+    then throw("_whenMultisigSet: revert")
211+    else true
212+
213+
214+func ap () = if (N())
215+    then throw("_whenNotInitialized: revert")
216+    else true
217+
218+
219+func aq () = if (!(N()))
220+    then throw("_whenInitialized: revert")
221+    else true
222+
223+
224+func ar (as,B) = if ((T() != as))
225+    then throw(B)
226+    else true
227+
228+
229+func at (au,av,B) = if (if ((au != n))
230+    then (au != o)
231+    else false)
232+    then throw(B)
233+    else if ((av != p))
234+        then throw(B)
235+        else true
236+
237+
238+func aw (ag,B) = if (!(af(ag)))
239+    then throw(B)
240+    else true
241+
242+
243+func ax (ay,B) = if (if ((ay != q))
244+    then (ay != r)
245+    else false)
246+    then throw(B)
247+    else true
248+
249+
250+func az (aA,aB,aC,aD,B) = {
251+    let aE = if ((aD == o))
252+        then true
253+        else if ((aC == q))
254+            then (aB >= aA)
255+            else if ((aC == r))
256+                then (aA >= aB)
257+                else false
258+    if (!(aE))
259+        then throw(B)
260+        else true
261+    }
262+
263+
264+func aF (aG,aH,B) = if ((aH == s))
265+    then if ((size(aG) != 64))
266+        then throw(B)
267+        else true
268+    else if ((aH == t))
269+        then if ((size(aG) != 65))
270+            then throw(B)
271+            else true
272+        else throw((B + ": inv alg"))
273+
274+
275+func aI (aJ,aH,B) = if ((aH == s))
276+    then if ((size(aJ) != 32))
277+        then throw(B)
278+        else true
279+    else if ((aH == t))
280+        then if ((size(aJ) != 20))
281+            then throw(B)
282+            else true
283+        else throw((B + ": inv alg"))
284+
285+
286+func aK (aJ,aH) = if ((aH == s))
287+    then toString(addressFromPublicKey(aJ))
288+    else if ((aH == t))
289+        then ("0x" + toBase16String(aJ))
290+        else throw("_convertPublicKeyToAddress: revert")
291+
292+
293+func aL (aj,aG,aJ,aH,B) = {
294+    let aE = if ((aH == s))
295+        then sigVerify(aj, aG, aJ)
296+        else if ((aH == t))
297+            then {
298+                let aM = keccak256_16Kb((y + aj))
299+                (takeRight(keccak256_16Kb(ecrecover(aM, aG)), 20) == aJ)
300+                }
301+            else throw((B + ": inv alg"))
302+    if (!(aE))
303+        then throw(B)
304+        else true
305+    }
306+
307+
308+func aN (al,aO,B) = if ((aO > fraction(al, x, w, DOWN)))
309+    then throw(B)
310+    else true
311+
312+
313+func aP (aQ,B) = {
314+    let aR = split(aQ, a)
315+    let aS = valueOrErrorMessage(parseInt(aR[0]), (B + ": inv type"))
316+    let aT = valueOrErrorMessage(parseInt(aR[1]), (B + ": inv version"))
317+    let aU = aR[2]
318+    let aV = valueOrErrorMessage(parseInt(aR[3]), (B + ": inv side"))
319+    let aW = valueOrErrorMessage(parseInt(aR[4]), (B + ": inv ts"))
320+    let aX = fromBase58String(aR[5])
321+    let aY = valueOrErrorMessage(parseInt(aR[6]), (B + ": inv alg"))
322+    let aZ = fromBase58String(aR[7])
323+    let ba = if (if ((aS == n))
324+        then (aT == p)
325+        else false)
326+        then {
327+            let bb = valueOrErrorMessage(parseBigInt(aR[8]), (B + ": inv price"))
328+            let bc = valueOrErrorMessage(parseBigInt(aR[9]), (B + ": inv amount"))
329+            let bd = (toBytes(bb) + toBytes(bc))
330+            $Tuple4(bb, bc, u, bd)
331+            }
332+        else if (if ((aS == o))
333+            then (aT == p)
334+            else false)
335+            then {
336+                let bc = valueOrErrorMessage(parseBigInt(aR[8]), (B + ": inv amount"))
337+                let be = if ((valueOrErrorMessage(parseBigInt(aR[9]), (B + ": inv isBaseAmount")) == u))
338+                    then false
339+                    else true
340+                if (be)
341+                    then $Tuple4(u, bc, u, (toBytes(bc) + toBytes(v)))
342+                    else $Tuple4(u, u, bc, (toBytes(bc) + toBytes(u)))
343+                }
344+            else throw((B + ": inv type & version"))
345+    let bb = ba._1
346+    let bf = ba._2
347+    let bg = ba._3
348+    let bd = ba._4
349+    let bh = ((((((((toBytes(aS) + toBytes(aT)) + toBytes(size(aU))) + toBytes(aU)) + toBytes(aV)) + toBytes(aW)) + aX) + toBytes(aY)) + bd)
350+    let bi = keccak256_32Kb(bh)
351+    let bj = if (if (if (if (if (if (if (at(aS, aT, (B + ": inv order type")))
352+        then aw(aU, (B + ": inv order symbol"))
353+        else false)
354+        then ax(aV, (B + ": inv order side"))
355+        else false)
356+        then aI(aX, aY, (B + ": inv order public key"))
357+        else false)
358+        then aF(aZ, aY, (B + ": inv sig format"))
359+        else false)
360+        then E(bb, u, (B + ": neg price"))
361+        else false)
362+        then E(bf, u, (B + ": neg base amount"))
363+        else false)
364+        then E(bg, u, (B + ": neg quote amount"))
365+        else false
366+    if ((bj == bj))
367+        then $Tuple10(aS, aU, aV, bb, bf, bg, bi, aX, aY, aZ)
368+        else throw("Strict value is not equal to itself.")
369+    }
370+
371+
372+@Callable(bk)
373+func init (V,Y,ab) = {
374+    let bj = if (if (if (if (if (am(bk.caller))
375+        then ap()
376+        else false)
377+        then ao()
378+        else false)
379+        then z(V, "init: invalid sequencer")
380+        else false)
381+        then z(Y, "init: invalid accountStorage")
382+        else false)
383+        then L(ab, "init: invalid feeRecipient")
384+        else false
385+    if ((bj == bj))
386+        then $Tuple2((((O(true) ++ U(addressFromStringValue(V))) ++ X(addressFromStringValue(Y))) ++ aa(ab)), unit)
387+        else throw("Strict value is not equal to itself.")
388+    }
389+
390+
391+
392+@Callable(bk)
393+func trade (bl,bm,bn,bo) = {
394+    let bp = aP(bl, "trade: invalid maker order")
395+    let bq = bp._1
396+    let br = bp._2
397+    let bs = bp._3
398+    let bt = bp._4
399+    let bu = bp._5
400+    let bv = bp._6
401+    let bw = bp._7
402+    let bx = bp._8
403+    let by = bp._9
404+    let bz = bp._10
405+    let bA = aP(bm, "trade: invalid taker order")
406+    let bB = bA._1
407+    let bC = bA._2
408+    let bD = bA._3
409+    let bE = bA._4
410+    let bF = bA._5
411+    let bG = bA._6
412+    let bH = bA._7
413+    let bI = bA._8
414+    let bJ = bA._9
415+    let bK = bA._10
416+    let bL = valueOrErrorMessage(parseBigInt(bn), "trade: baseFee not int")
417+    let bM = valueOrErrorMessage(parseBigInt(bo), "trade: quoteFee not int")
418+    let bN = bt
419+    let bO = ai(bw)
420+    let bP = (bu - bO)
421+    let bQ = ai(bH)
422+    let bR = if ((bF == u))
423+        then fraction((bG - bQ), w, bN, DOWN)
424+        else (bF - bQ)
425+    let bS = min([bP, bR])
426+    let bT = fraction(bS, bN, w, DOWN)
427+    let bj = if (if (if (if (if (if (if (if (if (ar(bk.caller, "trade: invalid sequencer"))
428+        then E(bS, u, "trade: neg trade amount")
429+        else false)
430+        then H(bq, n, "trade: maker is not limit")
431+        else false)
432+        then M(br, bC, "trade: symbol mismatch")
433+        else false)
434+        then K(bs, bD, "trade: side mismatch")
435+        else false)
436+        then aL(bw, bz, bx, by, "trade: invalid maker sig")
437+        else false)
438+        then aL(bH, bK, bI, bJ, "trade: invalid taker sig")
439+        else false)
440+        then aN(bS, bL, "trade: base fee too much")
441+        else false)
442+        then aN(bT, bM, "trade: quote fee too much")
443+        else false)
444+        then az(bt, bE, bD, bB, "trade: prices mismatch")
445+        else false
446+    if ((bj == bj))
447+        then {
448+            let bU = aK(bx, by)
449+            let bV = aK(bI, bJ)
450+            let bW = if ((bs == q))
451+                then $Tuple2(bU, bV)
452+                else $Tuple2(bV, bU)
453+            let bX = bW._1
454+            let bY = bW._2
455+            let bZ = split(br, "-")
456+            let ca = bZ[0]
457+            let cb = bZ[1]
458+            let cc = Z()
459+            let cd = invoke(W(), k, [m, ca, bY, bX, toString(bS), toString(bL), cc], nil)
460+            if ((cd == cd))
461+                then {
462+                    let ce = invoke(W(), k, [m, cb, bX, bY, toString(bT), toString(bM), cc], nil)
463+                    if ((ce == ce))
464+                        then {
465+                            let cf = (bO + bS)
466+                            let cg = if ((bF == u))
467+                                then (bQ + bT)
468+                                else (bQ + bS)
469+                            $Tuple2((ak(bw, cf) ++ ak(bH, cg)), unit)
470+                            }
471+                        else throw("Strict value is not equal to itself.")
472+                    }
473+                else throw("Strict value is not equal to itself.")
474+            }
475+        else throw("Strict value is not equal to itself.")
476+    }
477+
478+
479+
480+@Callable(bk)
481+func claimReward (ch,ci,al) = {
482+    let bc = valueOrErrorMessage(parseBigInt(al), "claimReward: amount not int")
483+    let bj = if (if (if (ar(bk.caller, "claimReward: invalid sequencer"))
484+        then L(ch, "claimReward: invalid user")
485+        else false)
486+        then L(ci, "claimReward: invalid currency")
487+        else false)
488+        then E(bc, u, "claimReward: neg amount")
489+        else false
490+    if ((bj == bj))
491+        then {
492+            let cd = invoke(W(), l, [ac(), ch, ci, al], nil)
493+            if ((cd == cd))
494+                then $Tuple2(nil, unit)
495+                else throw("Strict value is not equal to itself.")
496+            }
497+        else throw("Strict value is not equal to itself.")
498+    }
499+
500+
501+
502+@Callable(bk)
503+func updateSymbol (ag,cj) = {
504+    let bj = if (am(bk.caller))
505+        then L(ag, "updateSymbol: invalid symbol")
506+        else false
507+    if ((bj == bj))
508+        then $Tuple2(ah(ag, cj), unit)
509+        else throw("Strict value is not equal to itself.")
510+    }
511+
512+
513+
514+@Callable(bk)
515+func updateFeeRecipient (ab) = {
516+    let bj = if (if (am(bk.caller))
517+        then aq()
518+        else false)
519+        then L(ab, "updateFeeRecipient: invalid feeRecipient")
520+        else false
521+    if ((bj == bj))
522+        then $Tuple2(aa(ab), unit)
523+        else throw("Strict value is not equal to itself.")
524+    }
525+
526+
527+
528+@Callable(bk)
529+func updateRewardDistributor (ck) = {
530+    let bj = if (if (am(bk.caller))
531+        then aq()
532+        else false)
533+        then L(ck, "updateRewardDistributor: invalid rewardDistributor")
534+        else false
535+    if ((bj == bj))
536+        then $Tuple2(ad(ck), unit)
537+        else throw("Strict value is not equal to itself.")
538+    }
539+
540+
541+
542+@Callable(bk)
543+func setMultisig (S) = {
544+    let bj = if (am(bk.caller))
545+        then z(S, "setMultisig: invalid multisig")
546+        else false
547+    if ((bj == bj))
548+        then $Tuple2(R(addressFromStringValue(S)), unit)
549+        else throw("Strict value is not equal to itself.")
550+    }
551+
552+
553+@Verifier(cl)
554+func cm () = {
555+    let C = getString(b)
556+    if ($isInstanceOf(C, "String"))
557+        then {
558+            let cn = C
559+            valueOrElse(getBoolean(addressFromStringValue(cn), makeString([c, toString(this), toBase58String(cl.id)], a)), false)
560+            }
561+        else sigVerify(cl.bodyBytes, cl.proofs[0], cl.senderPublicKey)
562+    }
563+
github/deemru/w8io/169f3d6 
38.55 ms ◑