tx · FxmQ977Wxv6n79SbP2PiqTaP2wmWf62ayufW62WVNJQp

3MxdaTYVJHgaTxdqfzMGzF5D4gqDXH8dUje:  -0.03200000 Waves

2022.12.20 10:52 [2368336] smart account 3MxdaTYVJHgaTxdqfzMGzF5D4gqDXH8dUje > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FxmQ977Wxv6n79SbP2PiqTaP2wmWf62ayufW62WVNJQp",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1671522777698,
    "version": 2,
    "chainId": 84,
    "sender": "3MxdaTYVJHgaTxdqfzMGzF5D4gqDXH8dUje",
    "senderPublicKey": "71dLMGej17QGvPwSWGwXgcU2oD9aGy6ubg9E8oDfV1yT",
    "proofs": [
        "FHNf4FguFej5vqdQ3YUqTvP9jRRQPeMPiuVcnZ7MwFLLgyo5LC5HFXeViVUWtBy8NVN3th3Cg9iJ7Wg2vGGiBxq"
    ],
    "script": "base64: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",
    "height": 2368336,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: G4E1EtA2zTujWdoTHVerbnxHH1L1CKPJcK1fPJgRHZsE

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = addressFromStringValue("3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g")
5+
6+let b = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
7+
8+let c = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
9+
10+let d = base58'7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1'
11+
12+let e = addressFromStringValue("3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU")
13+
14+let f = addressFromStringValue("3PDrYPF6izza2sXWffzTPF7e2Fcir2CMpki")
15+
16+let g = base58'At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL'
17+
18+let h = "At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL"
19+
20+let i = addressFromStringValue("3P7r93vXHuusageNJVGwzqaz3WMotAu49Yz")
21+
22+let j = addressFromStringValue("3PLp9KrdrbWAvSFHGJVEaszUubquz3M6mfe")
23+
24+let k = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
25+
26+let l = "Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on"
27+
28+let m = addressFromStringValue("3PKi4G3VX2k42ZSmNNrmvgdDH7JzRaUhY7R")
29+
30+let n = addressFromStringValue("3PCENpEKe8atwELZ7oCSmcdEfcRuKTrUx99")
31+
32+let o = base58'F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9'
33+
34+let p = addressFromStringValue("3PC3HtupBxBmy4WtZf1Tym1vrxg9MwbZRK1")
35+
36+let q = "6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ"
37+
38+let r = base58'6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ'
39+
40+let s = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
41+
42+let t = addressFromStringValue("3P93Kqz8PUbCudvMyjbci54WxQrtBtw4dbZ")
43+
44+let u = addressFromStringValue("3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz")
45+
46+let v = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
47+
48+let w = base58'34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ'
49+
50+let x = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
51+
52+let y = addressFromStringValue("3P93Kqz8PUbCudvMyjbci54WxQrtBtw4dbZ")
53+
54+let z = addressFromStringValue("3PH832eKnw67PFvJfUg9Knz6BHM87QvjMeL")
55+
56+let A = "8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91"
57+
58+let B = base58'8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91'
59+
60+let C = base58'EbwpqrZjrvi7XLowkM5Z2rg7xVdzfg6S5ec9asarpAU9'
61+
62+let D = addressFromStringValue("3PN1eJpdhJyRptcN9iLTarsJBtR2Kb3NXSU")
63+
64+let E = addressFromStringValue("3PCBWDTA6jrFswd7gQgaE3Xk7gLM5RKofvp")
65+
66+let F = addressFromStringValue("3PACj2DLTw3uUhsUmT98zHU5M4hPufbHKav")
67+
68+let G = "8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS"
69+
70+let H = base58'8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS'
71+
72+let I = base58'8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy'
73+
74+let J = base58'58RNQJqLQ3tYYpkjuJujWzLzMX3nzpGn6bTC8LfLtgAM'
75+
76+let K = addressFromStringValue("3PEMqetsaJDbYMw1XGovmE37FB8VUhGnX9A")
77+
78+let L = "474jTeYx2r2Va35794tCScAXWJG9hU2HcgxzMowaZUnu"
79+
80+let M = base58'474jTeYx2r2Va35794tCScAXWJG9hU2HcgxzMowaZUnu'
81+
82+let N = base58'6gtgBD12xZkUTnzGofoFJpMg5gYG1FP6PaGyLviVQjbh'
83+
84+let O = addressFromStringValue("3PNEC4YKqZiMMytFrYRVtpW2ujvi3aGXRPm")
85+
86+let P = base58'H8wRVSgq82j6YU1K7jXVpDXHpd5m91t3bmCzRR7uFGc7'
87+
88+let Q = addressFromStringValue("3P94wvu5gA7VhjPgAB3twaeqdwHCwNK2vsn")
89+
90+let R = "HZk1mbfuJpmxU1Fs4AX5MWLVYtctsNcg6e2C6VKqK8zk"
91+
92+let S = base58'HZk1mbfuJpmxU1Fs4AX5MWLVYtctsNcg6e2C6VKqK8zk'
93+
94+let T = base58'CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv'
95+
96+let U = addressFromStringValue("3P32Rjpo9YHoHaorLSxvnV6CkKFXyfDCkJh")
97+
98+let V = base58'2npCQ21bzjEgBYWMepyd95aA3vwXaQpPBXnHtmmXadXF'
99+
100+let W = addressFromStringValue("3PFxchXqKNjgP1CcbgFZjHyrEj9xMbSeLU3")
101+
102+let X = "4LHHvYGNKJUg5hj65aGD5vgScvCBmLpdRFtjokvCjSL8"
103+
104+let Y = base58'4LHHvYGNKJUg5hj65aGD5vgScvCBmLpdRFtjokvCjSL8'
105+
106+let Z = base58'CaryXC3PhVr1rTxUGk8Bx7CcoxPX9ea3F5RGFiCe98Jr'
107+
108+let aa = addressFromStringValue("3P6DLdJTP2EySq9MFdJu6beUevrQd2sVVBh")
109+
110+let ab = base58'8g1Ki9cvjjhLUTyNwd4MaZ4fNfNTVc92Cb6f8My4qb1A'
111+
112+let ac = addressFromStringValue("3P3Y38zymCHoTM6qcE9JcEA8rhaGTQbVMgu")
113+
114+let ad = "C1iWsKGqLwjHUndiQ7iXpdmPum9PeCDFfyXBdJJosDRS"
115+
116+let ae = base58'C1iWsKGqLwjHUndiQ7iXpdmPum9PeCDFfyXBdJJosDRS'
117+
118+let af = base58'EsGs3xQLW8QSRiABfztfVLe8u5a2pvNfkdti4VYes1ms'
119+
120+let ag = addressFromStringValue("3PEeJQRJT4v4XvSUBPmxhdWKz439nae7KtQ")
121+
122+let ah = base58'2wk64hhVqjC3DgJa9HE9bcV7dCazuRtCSs6giqBAbBak'
123+
124+let ai = addressFromStringValue("3PDSXwwA2xAtmxeo2bebDP3AA5ynZ2Krgnw")
125+
126+let aj = base58'CBFNT7ti8bGzESndbsNB376Ug4fQ2ZyhXzdY892edTqq'
127+
128+let ak = "Ajso6nTTjptu2UHLx6hfSXVtHFtRBJCkKYd5SAyj7zf5"
129+
130+let al = base58'Ajso6nTTjptu2UHLx6hfSXVtHFtRBJCkKYd5SAyj7zf5'
131+
132+let am = addressFromStringValue("3P93Kqz8PUbCudvMyjbci54WxQrtBtw4dbZ")
133+
134+func an (ao) = valueOrElse(getInteger(this, ao), 35)
135+
136+
137+let ap = an("montant")
138+
139+@Callable(aq)
140+func set (ap) = if ((aq.caller != this))
141+    then throw("you are not allowed to set!")
142+    else [IntegerEntry("montant", ap)]
143+
144+
145+
146+@Callable(aq)
147+func a1 () = if ((aq.caller != this))
148+    then throw("you are not allowed to arb!")
149+    else {
150+        let ar = assetBalance(this, b)
151+        if ((ar == ar))
152+            then {
153+                let as = wavesBalance(this).available
154+                if ((as == as))
155+                    then {
156+                        let at = invoke(f, "swap", ["WAVES", 1], [AttachedPayment(b, (ap * 1000000))])
157+                        if ((at == at))
158+                            then {
159+                                let au = (wavesBalance(this).available - as)
160+                                if ((0 >= au))
161+                                    then throw("nothing to arb")
162+                                    else {
163+                                        let av = invoke(a, "putOneTkn", [1, false], [AttachedPayment(unit, au)])
164+                                        if ((av == av))
165+                                            then {
166+                                                let aw = assetBalance(this, d)
167+                                                if ((aw == aw))
168+                                                    then {
169+                                                        let ax = invoke(a, "getOneTkn", [c, 1], [AttachedPayment(d, aw)])
170+                                                        if ((ax == ax))
171+                                                            then {
172+                                                                let ay = assetBalance(this, b)
173+                                                                if ((ay == ay))
174+                                                                    then if ((0 >= (ay - ar)))
175+                                                                        then throw("WU PUZZLE -> WX  [($_$)]")
176+                                                                        else nil
177+                                                                    else throw("Strict value is not equal to itself.")
178+                                                                }
179+                                                            else throw("Strict value is not equal to itself.")
180+                                                        }
181+                                                    else throw("Strict value is not equal to itself.")
182+                                                }
183+                                            else throw("Strict value is not equal to itself.")
184+                                        }
185+                                }
186+                            else throw("Strict value is not equal to itself.")
187+                        }
188+                    else throw("Strict value is not equal to itself.")
189+                }
190+            else throw("Strict value is not equal to itself.")
191+        }
192+
193+
194+
195+@Callable(aq)
196+func a2 () = if ((aq.caller != this))
197+    then throw("you are not allowed to arb!")
198+    else {
199+        let ar = assetBalance(this, b)
200+        if ((ar == ar))
201+            then {
202+                let as = wavesBalance(this).available
203+                if ((as == as))
204+                    then {
205+                        let av = invoke(a, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
206+                        if ((av == av))
207+                            then {
208+                                let aw = assetBalance(this, d)
209+                                if ((aw == aw))
210+                                    then {
211+                                        let ax = invoke(a, "getOneTkn", ["WAVES", 1], [AttachedPayment(d, aw)])
212+                                        if ((ax == ax))
213+                                            then {
214+                                                let au = (wavesBalance(this).available - as)
215+                                                if ((0 >= au))
216+                                                    then throw("nothing to arb")
217+                                                    else {
218+                                                        let at = invoke(f, "swap", [c, 1], [AttachedPayment(unit, au)])
219+                                                        if ((at == at))
220+                                                            then {
221+                                                                let ay = assetBalance(this, b)
222+                                                                if ((ay == ay))
223+                                                                    then if ((0 >= (ay - ar)))
224+                                                                        then throw("WU WX -> PUZZLE [($_$)]")
225+                                                                        else nil
226+                                                                    else throw("Strict value is not equal to itself.")
227+                                                                }
228+                                                            else throw("Strict value is not equal to itself.")
229+                                                        }
230+                                                }
231+                                            else throw("Strict value is not equal to itself.")
232+                                        }
233+                                    else throw("Strict value is not equal to itself.")
234+                                }
235+                            else throw("Strict value is not equal to itself.")
236+                        }
237+                    else throw("Strict value is not equal to itself.")
238+                }
239+            else throw("Strict value is not equal to itself.")
240+        }
241+
242+
243+
244+@Callable(aq)
245+func a3 () = if ((aq.caller != this))
246+    then throw("you are not allowed to arb!")
247+    else {
248+        let ar = assetBalance(this, b)
249+        if ((ar == ar))
250+            then {
251+                let az = invoke(i, "swap", [h, 1], [AttachedPayment(b, (ap * 1000000))])
252+                if ((az == az))
253+                    then {
254+                        let aA = assetBalance(this, g)
255+                        let aB = invoke(j, "exchange", [1], [AttachedPayment(g, aA)])
256+                        if ((aB == aB))
257+                            then {
258+                                let ay = assetBalance(this, b)
259+                                if ((ay == ay))
260+                                    then if ((0 >= (ay - ar)))
261+                                        then throw("SURF PUZZLE -> SWOP [($_$)]")
262+                                        else nil
263+                                    else throw("Strict value is not equal to itself.")
264+                                }
265+                            else throw("Strict value is not equal to itself.")
266+                        }
267+                    else throw("Strict value is not equal to itself.")
268+                }
269+            else throw("Strict value is not equal to itself.")
270+        }
271+
272+
273+
274+@Callable(aq)
275+func a4 () = if ((aq.caller != this))
276+    then throw("you are not allowed to arb!")
277+    else {
278+        let ar = assetBalance(this, b)
279+        if ((ar == ar))
280+            then {
281+                let aC = invoke(j, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
282+                if ((aC == aC))
283+                    then {
284+                        let aA = assetBalance(this, g)
285+                        let aD = invoke(i, "swap", [c, 1], [AttachedPayment(g, aA)])
286+                        if ((aD == aD))
287+                            then {
288+                                let ay = assetBalance(this, b)
289+                                if ((ay == ay))
290+                                    then if ((0 >= (ay - ar)))
291+                                        then throw("SURF SWOP -> PUZZLE [($_$)]")
292+                                        else nil
293+                                    else throw("Strict value is not equal to itself.")
294+                                }
295+                            else throw("Strict value is not equal to itself.")
296+                        }
297+                    else throw("Strict value is not equal to itself.")
298+                }
299+            else throw("Strict value is not equal to itself.")
300+        }
301+
302+
303+
304+@Callable(aq)
305+func a5 () = if ((aq.caller != this))
306+    then throw("you are not allowed to arb!")
307+    else {
308+        let ar = assetBalance(this, b)
309+        if ((ar == ar))
310+            then {
311+                let av = invoke(n, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
312+                if ((av == av))
313+                    then {
314+                        let aw = assetBalance(this, o)
315+                        if ((aw == aw))
316+                            then {
317+                                let ax = invoke(n, "getOneTkn", [l, 1], [AttachedPayment(o, aw)])
318+                                if ((ax == ax))
319+                                    then {
320+                                        let aE = assetBalance(this, k)
321+                                        let aF = invoke(m, "exchange", [1], [AttachedPayment(k, aE)])
322+                                        if ((aF == aF))
323+                                            then {
324+                                                let ay = assetBalance(this, b)
325+                                                if ((ay == ay))
326+                                                    then if ((0 >= (ay - ar)))
327+                                                        then throw("WX WX -> SWOP [($_$)]")
328+                                                        else nil
329+                                                    else throw("Strict value is not equal to itself.")
330+                                                }
331+                                            else throw("Strict value is not equal to itself.")
332+                                        }
333+                                    else throw("Strict value is not equal to itself.")
334+                                }
335+                            else throw("Strict value is not equal to itself.")
336+                        }
337+                    else throw("Strict value is not equal to itself.")
338+                }
339+            else throw("Strict value is not equal to itself.")
340+        }
341+
342+
343+
344+@Callable(aq)
345+func a6 () = if ((aq.caller != this))
346+    then throw("you are not allowed to arb!")
347+    else {
348+        let ar = assetBalance(this, b)
349+        if ((ar == ar))
350+            then {
351+                let aG = invoke(m, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
352+                if ((aG == aG))
353+                    then {
354+                        let aE = assetBalance(this, k)
355+                        let av = invoke(n, "putOneTkn", [1, false], [AttachedPayment(k, aE)])
356+                        if ((av == av))
357+                            then {
358+                                let aw = assetBalance(this, o)
359+                                if ((aw == aw))
360+                                    then {
361+                                        let ax = invoke(n, "getOneTkn", [c, 1], [AttachedPayment(o, aw)])
362+                                        if ((ax == ax))
363+                                            then {
364+                                                let ay = assetBalance(this, b)
365+                                                if ((ay == ay))
366+                                                    then if ((0 >= (ay - ar)))
367+                                                        then throw("WX SWOP -> WX [($_$)]")
368+                                                        else nil
369+                                                    else throw("Strict value is not equal to itself.")
370+                                                }
371+                                            else throw("Strict value is not equal to itself.")
372+                                        }
373+                                    else throw("Strict value is not equal to itself.")
374+                                }
375+                            else throw("Strict value is not equal to itself.")
376+                        }
377+                    else throw("Strict value is not equal to itself.")
378+                }
379+            else throw("Strict value is not equal to itself.")
380+        }
381+
382+
383+
384+@Callable(aq)
385+func a7 () = if ((aq.caller != this))
386+    then throw("you are not allowed to arb!")
387+    else {
388+        let ar = assetBalance(this, b)
389+        if ((ar == ar))
390+            then {
391+                let aH = invoke(t, "swap", [q, 1], [AttachedPayment(b, (ap * 1000000))])
392+                if ((aH == aH))
393+                    then {
394+                        let aI = assetBalance(this, r)
395+                        if ((aI == aI))
396+                            then {
397+                                let av = invoke(p, "putOneTknV2", [1, false], [AttachedPayment(r, aI)])
398+                                if ((av == av))
399+                                    then {
400+                                        let aw = assetBalance(this, s)
401+                                        if ((aw == aw))
402+                                            then {
403+                                                let ax = invoke(p, "getOneTknV2", [c, 1], [AttachedPayment(s, aw)])
404+                                                if ((ax == ax))
405+                                                    then {
406+                                                        let ay = assetBalance(this, b)
407+                                                        if ((ay == ay))
408+                                                            then if ((0 >= (ay - ar)))
409+                                                                then throw("USDC PUZZLE -> WX [($_$)]")
410+                                                                else nil
411+                                                            else throw("Strict value is not equal to itself.")
412+                                                        }
413+                                                    else throw("Strict value is not equal to itself.")
414+                                                }
415+                                            else throw("Strict value is not equal to itself.")
416+                                        }
417+                                    else throw("Strict value is not equal to itself.")
418+                                }
419+                            else throw("Strict value is not equal to itself.")
420+                        }
421+                    else throw("Strict value is not equal to itself.")
422+                }
423+            else throw("Strict value is not equal to itself.")
424+        }
425+
426+
427+
428+@Callable(aq)
429+func a8 () = if ((aq.caller != this))
430+    then throw("you are not allowed to arb!")
431+    else {
432+        let ar = assetBalance(this, b)
433+        if ((ar == ar))
434+            then {
435+                let av = invoke(p, "putOneTknV2", [1, false], [AttachedPayment(b, (ap * 1000000))])
436+                if ((av == av))
437+                    then {
438+                        let aw = assetBalance(this, s)
439+                        if ((aw == aw))
440+                            then {
441+                                let ax = invoke(p, "getOneTknV2", [q, 1], [AttachedPayment(s, aw)])
442+                                if ((ax == ax))
443+                                    then {
444+                                        let aI = assetBalance(this, r)
445+                                        if ((aI == aI))
446+                                            then {
447+                                                let aJ = invoke(t, "swap", [c, 1], [AttachedPayment(r, aI)])
448+                                                if ((aJ == aJ))
449+                                                    then {
450+                                                        let ay = assetBalance(this, b)
451+                                                        if ((ay == ay))
452+                                                            then if ((0 >= (ay - ar)))
453+                                                                then throw("USDC WX -> PUZZLE [($_$)]")
454+                                                                else nil
455+                                                            else throw("Strict value is not equal to itself.")
456+                                                        }
457+                                                    else throw("Strict value is not equal to itself.")
458+                                                }
459+                                            else throw("Strict value is not equal to itself.")
460+                                        }
461+                                    else throw("Strict value is not equal to itself.")
462+                                }
463+                            else throw("Strict value is not equal to itself.")
464+                        }
465+                    else throw("Strict value is not equal to itself.")
466+                }
467+            else throw("Strict value is not equal to itself.")
468+        }
469+
470+
471+
472+@Callable(aq)
473+func a9 () = if ((aq.caller != this))
474+    then throw("you are not allowed to arb!")
475+    else {
476+        let ar = assetBalance(this, b)
477+        if ((ar == ar))
478+            then {
479+                let aK = invoke(y, "swap", [v, 1], [AttachedPayment(b, (ap * 1000000))])
480+                if ((aK == aK))
481+                    then {
482+                        let aL = assetBalance(this, w)
483+                        if ((aL == aL))
484+                            then {
485+                                let av = invoke(u, "putOneTknV2", [1, false], [AttachedPayment(w, aL)])
486+                                if ((av == av))
487+                                    then {
488+                                        let aw = assetBalance(this, x)
489+                                        if ((aw == aw))
490+                                            then {
491+                                                let ax = invoke(u, "getOneTknV2", [c, 1], [AttachedPayment(x, aw)])
492+                                                if ((ax == ax))
493+                                                    then {
494+                                                        let ay = assetBalance(this, b)
495+                                                        if ((ay == ay))
496+                                                            then if ((0 >= (ay - ar)))
497+                                                                then throw("USDT PUZZLE -> WX [($_$)]")
498+                                                                else nil
499+                                                            else throw("Strict value is not equal to itself.")
500+                                                        }
501+                                                    else throw("Strict value is not equal to itself.")
502+                                                }
503+                                            else throw("Strict value is not equal to itself.")
504+                                        }
505+                                    else throw("Strict value is not equal to itself.")
506+                                }
507+                            else throw("Strict value is not equal to itself.")
508+                        }
509+                    else throw("Strict value is not equal to itself.")
510+                }
511+            else throw("Strict value is not equal to itself.")
512+        }
513+
514+
515+
516+@Callable(aq)
517+func a10 () = if ((aq.caller != this))
518+    then throw("you are not allowed to arb!")
519+    else {
520+        let ar = assetBalance(this, b)
521+        if ((ar == ar))
522+            then {
523+                let av = invoke(u, "putOneTknV2", [1, false], [AttachedPayment(b, (ap * 1000000))])
524+                if ((av == av))
525+                    then {
526+                        let aw = assetBalance(this, x)
527+                        if ((aw == aw))
528+                            then {
529+                                let ax = invoke(u, "getOneTknV2", [v, 1], [AttachedPayment(x, aw)])
530+                                if ((ax == ax))
531+                                    then {
532+                                        let aL = assetBalance(this, w)
533+                                        if ((aL == aL))
534+                                            then {
535+                                                let aM = invoke(y, "swap", [c, 1], [AttachedPayment(w, aL)])
536+                                                if ((aM == aM))
537+                                                    then {
538+                                                        let ay = assetBalance(this, b)
539+                                                        if ((ay == ay))
540+                                                            then if ((0 >= (ay - ar)))
541+                                                                then throw("USDT WX -> PUZZLE [($_$)]")
542+                                                                else nil
543+                                                            else throw("Strict value is not equal to itself.")
544+                                                        }
545+                                                    else throw("Strict value is not equal to itself.")
546+                                                }
547+                                            else throw("Strict value is not equal to itself.")
548+                                        }
549+                                    else throw("Strict value is not equal to itself.")
550+                                }
551+                            else throw("Strict value is not equal to itself.")
552+                        }
553+                    else throw("Strict value is not equal to itself.")
554+                }
555+            else throw("Strict value is not equal to itself.")
556+        }
557+
558+
559+
560+@Callable(aq)
561+func a11 () = if ((aq.caller != this))
562+    then throw("you are not allowed to arb!")
563+    else {
564+        let ar = assetBalance(this, b)
565+        if ((ar == ar))
566+            then {
567+                let aN = invoke(D, "swap", [A, 1], [AttachedPayment(b, (ap * 1000000))])
568+                if ((aN == aN))
569+                    then {
570+                        let aO = assetBalance(this, B)
571+                        if ((aO == aO))
572+                            then {
573+                                let av = invoke(z, "putOneTkn", [1, false], [AttachedPayment(B, aO)])
574+                                if ((av == av))
575+                                    then {
576+                                        let aw = assetBalance(this, C)
577+                                        if ((aw == aw))
578+                                            then {
579+                                                let ax = invoke(z, "getOneTkn", [c, 1], [AttachedPayment(C, aw)])
580+                                                if ((ax == ax))
581+                                                    then {
582+                                                        let ay = assetBalance(this, b)
583+                                                        if ((ay == ay))
584+                                                            then if ((0 >= (ay - ar)))
585+                                                                then throw("TSN PUZZLE -> WX [($_$)]")
586+                                                                else nil
587+                                                            else throw("Strict value is not equal to itself.")
588+                                                        }
589+                                                    else throw("Strict value is not equal to itself.")
590+                                                }
591+                                            else throw("Strict value is not equal to itself.")
592+                                        }
593+                                    else throw("Strict value is not equal to itself.")
594+                                }
595+                            else throw("Strict value is not equal to itself.")
596+                        }
597+                    else throw("Strict value is not equal to itself.")
598+                }
599+            else throw("Strict value is not equal to itself.")
600+        }
601+
602+
603+
604+@Callable(aq)
605+func a12 () = if ((aq.caller != this))
606+    then throw("you are not allowed to arb!")
607+    else {
608+        let ar = assetBalance(this, b)
609+        if ((ar == ar))
610+            then {
611+                let av = invoke(z, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
612+                if ((av == av))
613+                    then {
614+                        let aw = assetBalance(this, C)
615+                        if ((aw == aw))
616+                            then {
617+                                let ax = invoke(z, "getOneTkn", [A, 1], [AttachedPayment(C, aw)])
618+                                if ((ax == ax))
619+                                    then {
620+                                        let aO = assetBalance(this, B)
621+                                        if ((aO == aO))
622+                                            then {
623+                                                let aP = invoke(D, "swap", [c, 1], [AttachedPayment(B, aO)])
624+                                                if ((aP == aP))
625+                                                    then {
626+                                                        let ay = assetBalance(this, b)
627+                                                        if ((ay == ay))
628+                                                            then if ((0 >= (ay - ar)))
629+                                                                then throw("TSN WX -> PUZZLE [($_$)]")
630+                                                                else nil
631+                                                            else throw("Strict value is not equal to itself.")
632+                                                        }
633+                                                    else throw("Strict value is not equal to itself.")
634+                                                }
635+                                            else throw("Strict value is not equal to itself.")
636+                                        }
637+                                    else throw("Strict value is not equal to itself.")
638+                                }
639+                            else throw("Strict value is not equal to itself.")
640+                        }
641+                    else throw("Strict value is not equal to itself.")
642+                }
643+            else throw("Strict value is not equal to itself.")
644+        }
645+
646+
647+
648+@Callable(aq)
649+func a13 () = if ((aq.caller != this))
650+    then throw("you are not allowed to arb!")
651+    else {
652+        let ar = assetBalance(this, b)
653+        if ((ar == ar))
654+            then {
655+                let av = invoke(E, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
656+                if ((av == av))
657+                    then {
658+                        let aw = assetBalance(this, I)
659+                        if ((aw == aw))
660+                            then {
661+                                let ax = invoke(E, "getOneTkn", [G, 1], [AttachedPayment(I, aw)])
662+                                if ((ax == ax))
663+                                    then {
664+                                        let aQ = assetBalance(this, H)
665+                                        let aR = invoke(F, "exchange", [1], [AttachedPayment(H, aQ)])
666+                                        if ((aR == aR))
667+                                            then {
668+                                                let ay = assetBalance(this, b)
669+                                                if ((ay == ay))
670+                                                    then if ((0 >= (ay - ar)))
671+                                                        then throw("BTC WX -> SWOP [($_$)]")
672+                                                        else nil
673+                                                    else throw("Strict value is not equal to itself.")
674+                                                }
675+                                            else throw("Strict value is not equal to itself.")
676+                                        }
677+                                    else throw("Strict value is not equal to itself.")
678+                                }
679+                            else throw("Strict value is not equal to itself.")
680+                        }
681+                    else throw("Strict value is not equal to itself.")
682+                }
683+            else throw("Strict value is not equal to itself.")
684+        }
685+
686+
687+
688+@Callable(aq)
689+func a14 () = if ((aq.caller != this))
690+    then throw("you are not allowed to arb!")
691+    else {
692+        let ar = assetBalance(this, b)
693+        if ((ar == ar))
694+            then {
695+                let aS = invoke(F, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
696+                if ((aS == aS))
697+                    then {
698+                        let aQ = assetBalance(this, H)
699+                        let av = invoke(E, "putOneTkn", [1, false], [AttachedPayment(H, aQ)])
700+                        if ((av == av))
701+                            then {
702+                                let aw = assetBalance(this, I)
703+                                if ((aw == aw))
704+                                    then {
705+                                        let ax = invoke(E, "getOneTkn", [c, 1], [AttachedPayment(I, aw)])
706+                                        if ((ax == ax))
707+                                            then {
708+                                                let ay = assetBalance(this, b)
709+                                                if ((ay == ay))
710+                                                    then if ((0 >= (ay - ar)))
711+                                                        then throw("BTC SWOP -> WX [($_$)]")
712+                                                        else nil
713+                                                    else throw("Strict value is not equal to itself.")
714+                                                }
715+                                            else throw("Strict value is not equal to itself.")
716+                                        }
717+                                    else throw("Strict value is not equal to itself.")
718+                                }
719+                            else throw("Strict value is not equal to itself.")
720+                        }
721+                    else throw("Strict value is not equal to itself.")
722+                }
723+            else throw("Strict value is not equal to itself.")
724+        }
725+
726+
727+
728+@Callable(aq)
729+func a15 () = if ((aq.caller != this))
730+    then throw("you are not allowed to arb!")
731+    else {
732+        let ar = assetBalance(this, b)
733+        if ((ar == ar))
734+            then {
735+                let av = invoke(K, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
736+                if ((av == av))
737+                    then {
738+                        let aw = assetBalance(this, N)
739+                        if ((aw == aw))
740+                            then {
741+                                let ax = invoke(K, "getOneTkn", [L, 1], [AttachedPayment(N, aw)])
742+                                if ((ax == ax))
743+                                    then {
744+                                        let aT = assetBalance(this, M)
745+                                        let aU = invoke(O, "exchange", [1], [AttachedPayment(M, aT)])
746+                                        if ((aU == aU))
747+                                            then {
748+                                                let ay = assetBalance(this, b)
749+                                                if ((ay == ay))
750+                                                    then if ((0 >= (ay - ar)))
751+                                                        then throw("ETH WX -> SWOP [($_$)]")
752+                                                        else nil
753+                                                    else throw("Strict value is not equal to itself.")
754+                                                }
755+                                            else throw("Strict value is not equal to itself.")
756+                                        }
757+                                    else throw("Strict value is not equal to itself.")
758+                                }
759+                            else throw("Strict value is not equal to itself.")
760+                        }
761+                    else throw("Strict value is not equal to itself.")
762+                }
763+            else throw("Strict value is not equal to itself.")
764+        }
765+
766+
767+
768+@Callable(aq)
769+func a16 () = if ((aq.caller != this))
770+    then throw("you are not allowed to arb!")
771+    else {
772+        let ar = assetBalance(this, b)
773+        if ((ar == ar))
774+            then {
775+                let aV = invoke(O, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
776+                if ((aV == aV))
777+                    then {
778+                        let aT = assetBalance(this, M)
779+                        let av = invoke(K, "putOneTkn", [1, false], [AttachedPayment(M, aT)])
780+                        if ((av == av))
781+                            then {
782+                                let aw = assetBalance(this, N)
783+                                if ((aw == aw))
784+                                    then {
785+                                        let ax = invoke(K, "getOneTkn", [c, 1], [AttachedPayment(N, aw)])
786+                                        if ((ax == ax))
787+                                            then {
788+                                                let ay = assetBalance(this, b)
789+                                                if ((ay == ay))
790+                                                    then if ((0 >= (ay - ar)))
791+                                                        then throw("ETH SWOP -> WX [($_$)]")
792+                                                        else nil
793+                                                    else throw("Strict value is not equal to itself.")
794+                                                }
795+                                            else throw("Strict value is not equal to itself.")
796+                                        }
797+                                    else throw("Strict value is not equal to itself.")
798+                                }
799+                            else throw("Strict value is not equal to itself.")
800+                        }
801+                    else throw("Strict value is not equal to itself.")
802+                }
803+            else throw("Strict value is not equal to itself.")
804+        }
805+
806+
807+
808+@Callable(aq)
809+func a17 () = if ((aq.caller != this))
810+    then throw("you are not allowed to arb!")
811+    else {
812+        let ar = assetBalance(this, b)
813+        if ((ar == ar))
814+            then {
815+                let av = invoke(Q, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
816+                if ((av == av))
817+                    then {
818+                        let aw = assetBalance(this, T)
819+                        if ((aw == aw))
820+                            then {
821+                                let ax = invoke(Q, "getOneTkn", [R, 1], [AttachedPayment(T, aw)])
822+                                if ((ax == ax))
823+                                    then {
824+                                        let aW = assetBalance(this, S)
825+                                        let aX = invoke(U, "exchange", [1], [AttachedPayment(S, aW)])
826+                                        if ((aX == aX))
827+                                            then {
828+                                                let ay = assetBalance(this, b)
829+                                                if ((ay == ay))
830+                                                    then if ((0 >= (ay - ar)))
831+                                                        then throw("LTC WX -> SWOP [($_$)]")
832+                                                        else nil
833+                                                    else throw("Strict value is not equal to itself.")
834+                                                }
835+                                            else throw("Strict value is not equal to itself.")
836+                                        }
837+                                    else throw("Strict value is not equal to itself.")
838+                                }
839+                            else throw("Strict value is not equal to itself.")
840+                        }
841+                    else throw("Strict value is not equal to itself.")
842+                }
843+            else throw("Strict value is not equal to itself.")
844+        }
845+
846+
847+
848+@Callable(aq)
849+func a18 () = if ((aq.caller != this))
850+    then throw("you are not allowed to arb!")
851+    else {
852+        let ar = assetBalance(this, b)
853+        if ((ar == ar))
854+            then {
855+                let aY = invoke(U, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
856+                if ((aY == aY))
857+                    then {
858+                        let aW = assetBalance(this, S)
859+                        let av = invoke(Q, "putOneTkn", [1, false], [AttachedPayment(S, aW)])
860+                        if ((av == av))
861+                            then {
862+                                let aw = assetBalance(this, T)
863+                                if ((aw == aw))
864+                                    then {
865+                                        let ax = invoke(Q, "getOneTkn", [c, 1], [AttachedPayment(T, aw)])
866+                                        if ((ax == ax))
867+                                            then {
868+                                                let ay = assetBalance(this, b)
869+                                                if ((ay == ay))
870+                                                    then if ((0 >= (ay - ar)))
871+                                                        then throw("LTC SWOP -> WX [($_$)]")
872+                                                        else nil
873+                                                    else throw("Strict value is not equal to itself.")
874+                                                }
875+                                            else throw("Strict value is not equal to itself.")
876+                                        }
877+                                    else throw("Strict value is not equal to itself.")
878+                                }
879+                            else throw("Strict value is not equal to itself.")
880+                        }
881+                    else throw("Strict value is not equal to itself.")
882+                }
883+            else throw("Strict value is not equal to itself.")
884+        }
885+
886+
887+
888+@Callable(aq)
889+func a19 () = if ((aq.caller != this))
890+    then throw("you are not allowed to arb!")
891+    else {
892+        let ar = assetBalance(this, b)
893+        if ((ar == ar))
894+            then {
895+                let av = invoke(W, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
896+                if ((av == av))
897+                    then {
898+                        let aw = assetBalance(this, Z)
899+                        if ((aw == aw))
900+                            then {
901+                                let ax = invoke(W, "getOneTkn", [X, 1], [AttachedPayment(Z, aw)])
902+                                if ((ax == ax))
903+                                    then {
904+                                        let aZ = assetBalance(this, Y)
905+                                        let ba = invoke(aa, "exchange", [1], [AttachedPayment(Y, aZ)])
906+                                        if ((ba == ba))
907+                                            then {
908+                                                let ay = assetBalance(this, b)
909+                                                if ((ay == ay))
910+                                                    then if ((0 >= (ay - ar)))
911+                                                        then throw("WEST WX -> SWOP [($_$)]")
912+                                                        else nil
913+                                                    else throw("Strict value is not equal to itself.")
914+                                                }
915+                                            else throw("Strict value is not equal to itself.")
916+                                        }
917+                                    else throw("Strict value is not equal to itself.")
918+                                }
919+                            else throw("Strict value is not equal to itself.")
920+                        }
921+                    else throw("Strict value is not equal to itself.")
922+                }
923+            else throw("Strict value is not equal to itself.")
924+        }
925+
926+
927+
928+@Callable(aq)
929+func a20 () = if ((aq.caller != this))
930+    then throw("you are not allowed to arb!")
931+    else {
932+        let ar = assetBalance(this, b)
933+        if ((ar == ar))
934+            then {
935+                let bb = invoke(aa, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
936+                if ((bb == bb))
937+                    then {
938+                        let aZ = assetBalance(this, Y)
939+                        let av = invoke(W, "putOneTkn", [1, false], [AttachedPayment(Y, aZ)])
940+                        if ((av == av))
941+                            then {
942+                                let aw = assetBalance(this, Z)
943+                                if ((aw == aw))
944+                                    then {
945+                                        let ax = invoke(W, "getOneTkn", [c, 1], [AttachedPayment(Z, aw)])
946+                                        if ((ax == ax))
947+                                            then {
948+                                                let ay = assetBalance(this, b)
949+                                                if ((ay == ay))
950+                                                    then if ((0 >= (ay - ar)))
951+                                                        then throw("WEST SWOP -> WX [($_$)]")
952+                                                        else nil
953+                                                    else throw("Strict value is not equal to itself.")
954+                                                }
955+                                            else throw("Strict value is not equal to itself.")
956+                                        }
957+                                    else throw("Strict value is not equal to itself.")
958+                                }
959+                            else throw("Strict value is not equal to itself.")
960+                        }
961+                    else throw("Strict value is not equal to itself.")
962+                }
963+            else throw("Strict value is not equal to itself.")
964+        }
965+
966+
967+
968+@Callable(aq)
969+func a21 () = if ((aq.caller != this))
970+    then throw("you are not allowed to arb!")
971+    else {
972+        let ar = assetBalance(this, b)
973+        if ((ar == ar))
974+            then {
975+                let av = invoke(ac, "putOneTkn", [1, false], [AttachedPayment(b, (ap * 1000000))])
976+                if ((av == av))
977+                    then {
978+                        let aw = assetBalance(this, af)
979+                        if ((aw == aw))
980+                            then {
981+                                let ax = invoke(ac, "getOneTkn", [ad, 1], [AttachedPayment(af, aw)])
982+                                if ((ax == ax))
983+                                    then {
984+                                        let bc = assetBalance(this, ae)
985+                                        let bd = invoke(ag, "exchange", [1], [AttachedPayment(ae, bc)])
986+                                        if ((bd == bd))
987+                                            then {
988+                                                let ay = assetBalance(this, b)
989+                                                if ((ay == ay))
990+                                                    then if ((0 >= (ay - ar)))
991+                                                        then throw("EGG WX -> SWOP [($_$)]")
992+                                                        else nil
993+                                                    else throw("Strict value is not equal to itself.")
994+                                                }
995+                                            else throw("Strict value is not equal to itself.")
996+                                        }
997+                                    else throw("Strict value is not equal to itself.")
998+                                }
999+                            else throw("Strict value is not equal to itself.")
1000+                        }
1001+                    else throw("Strict value is not equal to itself.")
1002+                }
1003+            else throw("Strict value is not equal to itself.")
1004+        }
1005+
1006+
1007+
1008+@Callable(aq)
1009+func a22 () = if ((aq.caller != this))
1010+    then throw("you are not allowed to arb!")
1011+    else {
1012+        let ar = assetBalance(this, b)
1013+        if ((ar == ar))
1014+            then {
1015+                let be = invoke(ag, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
1016+                if ((be == be))
1017+                    then {
1018+                        let bc = assetBalance(this, ae)
1019+                        let av = invoke(ac, "putOneTkn", [1, false], [AttachedPayment(ae, bc)])
1020+                        if ((av == av))
1021+                            then {
1022+                                let aw = assetBalance(this, af)
1023+                                if ((aw == aw))
1024+                                    then {
1025+                                        let ax = invoke(ac, "getOneTkn", [c, 1], [AttachedPayment(af, aw)])
1026+                                        if ((ax == ax))
1027+                                            then {
1028+                                                let ay = assetBalance(this, b)
1029+                                                if ((ay == ay))
1030+                                                    then if ((0 >= (ay - ar)))
1031+                                                        then throw("EGG SWOP -> WX [($_$)]")
1032+                                                        else nil
1033+                                                    else throw("Strict value is not equal to itself.")
1034+                                                }
1035+                                            else throw("Strict value is not equal to itself.")
1036+                                        }
1037+                                    else throw("Strict value is not equal to itself.")
1038+                                }
1039+                            else throw("Strict value is not equal to itself.")
1040+                        }
1041+                    else throw("Strict value is not equal to itself.")
1042+                }
1043+            else throw("Strict value is not equal to itself.")
1044+        }
1045+
1046+
1047+
1048+@Callable(aq)
1049+func a23 () = if ((aq.caller != this))
1050+    then throw("you are not allowed to arb!")
1051+    else {
1052+        let ar = assetBalance(this, b)
1053+        if ((ar == ar))
1054+            then {
1055+                let bf = invoke(am, "swap", [ak, 1], [AttachedPayment(b, (ap * 1000000))])
1056+                if ((bf == bf))
1057+                    then {
1058+                        let bg = assetBalance(this, al)
1059+                        let bh = invoke(ai, "exchange", [1], [AttachedPayment(al, bg)])
1060+                        if ((bh == bh))
1061+                            then {
1062+                                let ay = assetBalance(this, b)
1063+                                if ((ay == ay))
1064+                                    then if ((0 >= (ay - ar)))
1065+                                        then throw("PLUTO PUZZLE -> SWOP [($_$)]")
1066+                                        else nil
1067+                                    else throw("Strict value is not equal to itself.")
1068+                                }
1069+                            else throw("Strict value is not equal to itself.")
1070+                        }
1071+                    else throw("Strict value is not equal to itself.")
1072+                }
1073+            else throw("Strict value is not equal to itself.")
1074+        }
1075+
1076+
1077+
1078+@Callable(aq)
1079+func a24 () = if ((aq.caller != this))
1080+    then throw("you are not allowed to arb!")
1081+    else {
1082+        let ar = assetBalance(this, b)
1083+        if ((ar == ar))
1084+            then {
1085+                let bi = invoke(ai, "exchange", [1], [AttachedPayment(b, (ap * 1000000))])
1086+                if ((bi == bi))
1087+                    then {
1088+                        let bg = assetBalance(this, al)
1089+                        let bj = invoke(am, "swap", [c, 1], [AttachedPayment(al, bg)])
1090+                        if ((bj == bj))
1091+                            then {
1092+                                let ay = assetBalance(this, b)
1093+                                if ((ay == ay))
1094+                                    then if ((0 >= (ay - ar)))
1095+                                        then throw("PLUTO SWOP -> PUZZLE [($_$)]")
1096+                                        else nil
1097+                                    else throw("Strict value is not equal to itself.")
1098+                                }
1099+                            else throw("Strict value is not equal to itself.")
1100+                        }
1101+                    else throw("Strict value is not equal to itself.")
1102+                }
1103+            else throw("Strict value is not equal to itself.")
1104+        }
1105+
1106+
1107+@Verifier(bk)
1108+func bl () = sigVerify_128Kb(bk.bodyBytes, bk.proofs[0], bk.senderPublicKey)
1109+
github/deemru/w8io/3ef1775 
107.81 ms ◑