tx · FvekcXU8XFMVJWMUGspVG9MLYbxvY4skyYMxZViAFu2P

3NCCxt72qfGYBPUNx6zM49UDV9r4LvrtzeY:  -0.01500000 Waves

2024.04.01 18:32 [3043894] smart account 3NCCxt72qfGYBPUNx6zM49UDV9r4LvrtzeY > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FvekcXU8XFMVJWMUGspVG9MLYbxvY4skyYMxZViAFu2P",
    "fee": 1500000,
    "feeAssetId": null,
    "timestamp": 1711985605078,
    "version": 2,
    "chainId": 84,
    "sender": "3NCCxt72qfGYBPUNx6zM49UDV9r4LvrtzeY",
    "senderPublicKey": "D14bs2ieC42BPAapbooQT637A3iD7mXwJ9bgfDGXBHcX",
    "proofs": [
        "32sopN1xfdxaHXx5tnQshK9UuhWmpeazTuukzd8PctftUxPmPTRYnkoidnkfQKLXowc8dEcjZFGRpA2zCXYLtnYf"
    ],
    "script": "base64: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",
    "height": 3043894,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: GTLSsgejKNDrJR5wNYLL1vepT2AE9aNCegUhzpF2CpwT

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 = "externalTransfer"
23+
24+let k = "SPOT"
25+
26+let l = 1
27+
28+let m = 2
29+
30+let n = 1
31+
32+let o = 1
33+
34+let p = 2
35+
36+let q = toBigInt(0)
37+
38+let r = toBigInt(100000000)
39+
40+let s = toBigInt(100000)
41+
42+func t (u,v) = {
43+    let w = addressFromString(u)
44+    if ($isInstanceOf(w, "Address"))
45+        then {
46+            let x = w
47+            true
48+            }
49+        else throw(v)
50+    }
51+
52+
53+func y (z,A,v) = if ((A > z))
54+    then throw(v)
55+    else true
56+
57+
58+func B (C,D,v) = if ((C != D))
59+    then throw(v)
60+    else true
61+
62+
63+func E (C,D,v) = if ((C == D))
64+    then throw(v)
65+    else true
66+
67+
68+func F (z,v) = if (if ((0 >= size(z)))
69+    then true
70+    else contains(z, a))
71+    then throw(v)
72+    else true
73+
74+
75+func G (C,D,v) = if ((C != D))
76+    then throw(v)
77+    else true
78+
79+
80+func H () = {
81+    let w = getBoolean(d)
82+    if ($isInstanceOf(w, "Boolean"))
83+        then {
84+            let x = w
85+            x
86+            }
87+        else false
88+    }
89+
90+
91+func I (J) = [BooleanEntry(d, J)]
92+
93+
94+func K () = {
95+    let w = getString(b)
96+    if ($isInstanceOf(w, "String"))
97+        then {
98+            let x = w
99+            addressFromStringValue(x)
100+            }
101+        else Address(base58'')
102+    }
103+
104+
105+func L (M) = [StringEntry(b, toString(M))]
106+
107+
108+func N () = {
109+    let w = getString(e)
110+    if ($isInstanceOf(w, "String"))
111+        then {
112+            let x = w
113+            addressFromStringValue(x)
114+            }
115+        else Address(base58'')
116+    }
117+
118+
119+func O (P) = [StringEntry(e, toString(P))]
120+
121+
122+func Q () = {
123+    let w = getString(f)
124+    if ($isInstanceOf(w, "String"))
125+        then {
126+            let x = w
127+            addressFromStringValue(x)
128+            }
129+        else Address(base58'')
130+    }
131+
132+
133+func R (S) = [StringEntry(f, toString(S))]
134+
135+
136+func T () = {
137+    let w = getString(g)
138+    if ($isInstanceOf(w, "String"))
139+        then {
140+            let x = w
141+            x
142+            }
143+        else ""
144+    }
145+
146+
147+func U (V) = [StringEntry(g, V)]
148+
149+
150+func W (X) = {
151+    let w = getBoolean(makeString([h, X], a))
152+    if ($isInstanceOf(w, "Boolean"))
153+        then {
154+            let x = w
155+            x
156+            }
157+        else false
158+    }
159+
160+
161+func Y (X,z) = [BooleanEntry(makeString([h, X], a), z)]
162+
163+
164+func Z (aa) = {
165+    let w = getString(makeString([i, toBase58String(aa)], a))
166+    if ($isInstanceOf(w, "String"))
167+        then {
168+            let x = w
169+            parseBigIntValue(x)
170+            }
171+        else q
172+    }
173+
174+
175+func ab (aa,ac) = [StringEntry(makeString([i, toBase58String(aa)], a), toString(ac))]
176+
177+
178+func ad (ae) = if ((ae != this))
179+    then throw("_onlyThisContract: revert")
180+    else true
181+
182+
183+func af () = if ((K() == Address(base58'')))
184+    then throw("_whenMultisigSet: revert")
185+    else true
186+
187+
188+func ag () = if (H())
189+    then throw("_whenNotInitialized: revert")
190+    else true
191+
192+
193+func ah () = if (!(H()))
194+    then throw("_whenInitialized: revert")
195+    else true
196+
197+
198+func ai (aj,v) = if ((N() != aj))
199+    then throw(v)
200+    else true
201+
202+
203+func ak (al,am,v) = if (if ((al != l))
204+    then (al != m)
205+    else false)
206+    then throw(v)
207+    else if ((am != n))
208+        then throw(v)
209+        else true
210+
211+
212+func an (X,v) = if (!(W(X)))
213+    then throw(v)
214+    else true
215+
216+
217+func ao (ap,v) = if (if ((ap != o))
218+    then (ap != p)
219+    else false)
220+    then throw(v)
221+    else true
222+
223+
224+func aq (ar,v) = if ((size(ar) != 32))
225+    then throw(v)
226+    else true
227+
228+
229+func as (at,v) = if ((size(at) != 32))
230+    then throw(v)
231+    else true
232+
233+
234+func au (aa,av,aw,v) = if (!(sigVerify(aa, av, aw)))
235+    then throw(v)
236+    else true
237+
238+
239+func ax (ac,ay,v) = if ((ay > fraction(ac, s, r, DOWN)))
240+    then throw(v)
241+    else true
242+
243+
244+func az (aA,v) = {
245+    let aB = split(aA, a)
246+    let aC = valueOrErrorMessage(parseInt(aB[0]), (v + ": inv type"))
247+    let aD = valueOrErrorMessage(parseInt(aB[1]), (v + ": inv version"))
248+    let aE = aB[2]
249+    let aF = valueOrErrorMessage(parseInt(aB[3]), (v + ": inv side"))
250+    let aG = valueOrErrorMessage(parseInt(aB[4]), (v + ": inv ts"))
251+    let aH = fromBase58String(aB[5])
252+    let aI = valueOrErrorMessage(parseInt(aB[6]), (v + ": inv alg"))
253+    let aJ = fromBase58String(aB[7])
254+    let aK = if (if ((aC == l))
255+        then (aD == n)
256+        else false)
257+        then {
258+            let aL = valueOrErrorMessage(parseBigInt(aB[8]), (v + ": inv price"))
259+            let aM = valueOrErrorMessage(parseBigInt(aB[9]), (v + ": inv amount"))
260+            let aN = (toBytes(aL) + toBytes(aM))
261+            $Tuple4(aL, aM, q, aN)
262+            }
263+        else if (if ((aC == m))
264+            then (aD == n)
265+            else false)
266+            then {
267+                let aM = valueOrErrorMessage(parseBigInt(aB[8]), (v + ": inv amount"))
268+                let aO = if ((valueOrErrorMessage(parseInt(aB[9]), (v + ": inv isBaseAmount")) == 0))
269+                    then false
270+                    else true
271+                if (aO)
272+                    then $Tuple4(q, aM, q, (toBytes(aM) + toBytes(1)))
273+                    else $Tuple4(q, q, aM, (toBytes(aM) + toBytes(0)))
274+                }
275+            else throw((v + ": inv type & version"))
276+    let aL = aK._1
277+    let aP = aK._2
278+    let aQ = aK._3
279+    let aN = aK._4
280+    let aR = ((((((((toBytes(aC) + toBytes(aD)) + toBytes(size(aE))) + toBytes(aE)) + toBytes(aF)) + toBytes(aG)) + aH) + toBytes(aI)) + aN)
281+    let aS = keccak256_32Kb(aR)
282+    let aT = if (if (if (if (if (if (if (ak(aC, aD, (v + "inv order type")))
283+        then an(aE, (v + "inv order symbol"))
284+        else false)
285+        then ao(aF, (v + "inv order side"))
286+        else false)
287+        then aq(aH, (v + "inv order public key"))
288+        else false)
289+        then as(aJ, (v + "inv sig format"))
290+        else false)
291+        then y(aL, q, (v + "neg price"))
292+        else false)
293+        then y(aP, q, (v + "neg base amount"))
294+        else false)
295+        then y(aQ, q, (v + "neg quote amount"))
296+        else false
297+    if ((aT == aT))
298+        then $Tuple10(aC, aE, aF, aL, aP, aQ, aS, aH, aI, aJ)
299+        else throw("Strict value is not equal to itself.")
300+    }
301+
302+
303+@Callable(aU)
304+func init (P,S,V) = {
305+    let aT = if (if (if (if (if (ad(aU.caller))
306+        then ag()
307+        else false)
308+        then af()
309+        else false)
310+        then t(P, "init: invalid sequencer")
311+        else false)
312+        then t(S, "init: invalid accountStorage")
313+        else false)
314+        then F(V, "init: invalid feeRecipient")
315+        else false
316+    if ((aT == aT))
317+        then $Tuple2((((I(true) ++ O(addressFromStringValue(P))) ++ R(addressFromStringValue(S))) ++ U(V)), unit)
318+        else throw("Strict value is not equal to itself.")
319+    }
320+
321+
322+
323+@Callable(aU)
324+func trade (aV,aW,aX,aY) = {
325+    let aZ = az(aV, "trade: invalid maker order")
326+    let ba = aZ._1
327+    let bb = aZ._2
328+    let bc = aZ._3
329+    let bd = aZ._4
330+    let be = aZ._5
331+    let bf = aZ._6
332+    let bg = aZ._7
333+    let bh = aZ._8
334+    let bi = aZ._9
335+    let bj = aZ._10
336+    let bk = az(aW, "trade: invalid taker order")
337+    let bl = bk._1
338+    let bm = bk._2
339+    let bn = bk._3
340+    let bo = bk._4
341+    let bp = bk._5
342+    let bq = bk._6
343+    let br = bk._7
344+    let bs = bk._8
345+    let bt = bk._9
346+    let bu = bk._10
347+    let bv = valueOrErrorMessage(parseBigInt(aX), "trade: baseFee not int")
348+    let bw = valueOrErrorMessage(parseBigInt(aY), "trade: quoteFee not int")
349+    let bx = bd
350+    let by = Z(bg)
351+    let bz = (be - by)
352+    let bA = Z(br)
353+    let bB = if ((bp == q))
354+        then fraction((bq - bA), r, bx, DOWN)
355+        else (bp - bA)
356+    let bC = min([bz, bB])
357+    let bD = fraction(bC, bx, r, DOWN)
358+    let aT = if (if (if (if (if (if (ai(aU.caller, "trade: invalid sequencer"))
359+        then y(bC, q, "trade: neg trade amount")
360+        else false)
361+        then B(ba, l, "trade: maker is not limit")
362+        else false)
363+        then G(bb, bm, "trade: symbol mismatch")
364+        else false)
365+        then E(bc, bn, "trade: side mismatch")
366+        else false)
367+        then au(bg, bj, bh, "trade: invalid maker sig")
368+        else false)
369+        then au(br, bu, bs, "trade: invalid taker sig")
370+        else false
371+    if ((aT == aT))
372+        then {
373+            let bE = if ((bc == o))
374+                then $Tuple2(bh, bs)
375+                else $Tuple2(bs, bh)
376+            let bF = bE._1
377+            let bG = bE._2
378+            let bH = if (ax(bC, bv, "trade: base fee too much"))
379+                then ax(bD, bw, "trade: quote fee too much")
380+                else false
381+            if ((bH == bH))
382+                then {
383+                    let bI = split(bb, "-")
384+                    let bJ = bI[0]
385+                    let bK = bI[1]
386+                    let bL = T()
387+                    let bM = invoke(Q(), j, [k, bJ, bG, bF, bC, bv, bL], nil)
388+                    if ((bM == bM))
389+                        then {
390+                            let bN = invoke(Q(), j, [k, bK, bF, bG, bD, bw, bL], nil)
391+                            if ((bN == bN))
392+                                then {
393+                                    let bO = (by + bC)
394+                                    let bP = if ((bp == q))
395+                                        then (bA + bD)
396+                                        else (bA + bC)
397+                                    $Tuple2((ab(bg, bO) ++ ab(br, bP)), unit)
398+                                    }
399+                                else throw("Strict value is not equal to itself.")
400+                            }
401+                        else throw("Strict value is not equal to itself.")
402+                    }
403+                else throw("Strict value is not equal to itself.")
404+            }
405+        else throw("Strict value is not equal to itself.")
406+    }
407+
408+
409+
410+@Callable(aU)
411+func updateSymbol (X,bQ) = {
412+    let aT = if (ad(aU.caller))
413+        then F(X, "updateSymbol: invalid symbol")
414+        else false
415+    if ((aT == aT))
416+        then $Tuple2(Y(X, bQ), unit)
417+        else throw("Strict value is not equal to itself.")
418+    }
419+
420+
421+
422+@Callable(aU)
423+func setMultisig (M) = {
424+    let aT = if (ad(aU.caller))
425+        then t(M, "setMultisig: invalid multisig")
426+        else false
427+    if ((aT == aT))
428+        then $Tuple2(L(addressFromStringValue(M)), unit)
429+        else throw("Strict value is not equal to itself.")
430+    }
431+
432+
433+@Verifier(bR)
434+func bS () = {
435+    let w = getString(b)
436+    if ($isInstanceOf(w, "String"))
437+        then {
438+            let bT = w
439+            valueOrElse(getBoolean(addressFromStringValue(bT), makeString([c, toString(this), toBase58String(bR.id)], a)), false)
440+            }
441+        else sigVerify(bR.bodyBytes, bR.proofs[0], bR.senderPublicKey)
442+    }
443+
github/deemru/w8io/169f3d6 
28.61 ms ◑