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 wxPool = addressFromStringValue("3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g")
5+
6+let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
7+
8+let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
9+
10+let usdnWavesLPTokenAssetId = base58'7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1'
11+
12+let routingPuzzlePool = addressFromStringValue("3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU")
13+
14+let nonRoutingPuzzlePool = addressFromStringValue("3PDrYPF6izza2sXWffzTPF7e2Fcir2CMpki")
15+
16+let surfAssetId = base58'At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL'
17+
18+let surfAssetIdString = "At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL"
19+
20+let nonRoutingPuzzleSurfPool = addressFromStringValue("3P7r93vXHuusageNJVGwzqaz3WMotAu49Yz")
21+
22+let swopSurfPool = addressFromStringValue("3PLp9KrdrbWAvSFHGJVEaszUubquz3M6mfe")
23+
24+let wxAssetId = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
25+
26+let wxAssetIdString = "Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on"
27+
28+let swopWxPool = addressFromStringValue("3PKi4G3VX2k42ZSmNNrmvgdDH7JzRaUhY7R")
29+
30+let wxWxPool = addressFromStringValue("3PCENpEKe8atwELZ7oCSmcdEfcRuKTrUx99")
31+
32+let usdnWxLPTokenAssetId = base58'F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9'
33+
34+let wxUsdcPool = addressFromStringValue("3PC3HtupBxBmy4WtZf1Tym1vrxg9MwbZRK1")
35+
36+let usdcAssetIdString = "6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ"
37+
38+let usdcAssetId = base58'6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ'
39+
40+let usdcWxLPTokenAssetId = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
41+
42+let puzzleUsdcPool = addressFromStringValue("3P93Kqz8PUbCudvMyjbci54WxQrtBtw4dbZ")
43+
44+let wxUsdtPool = addressFromStringValue("3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz")
45+
46+let usdtAssetIdString = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
47+
48+let usdtAssetId = base58'34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ'
49+
50+let usdtWxLPTokenAssetId = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
51+
52+let puzzleUsdtPool = addressFromStringValue("3P93Kqz8PUbCudvMyjbci54WxQrtBtw4dbZ")
53+
54+let wxTsnPool = addressFromStringValue("3PH832eKnw67PFvJfUg9Knz6BHM87QvjMeL")
55+
56+let tsnAssetIdString = "8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91"
57+
58+let tsnAssetId = base58'8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91'
59+
60+let tsnWxLPTokenAssetId = base58'EbwpqrZjrvi7XLowkM5Z2rg7xVdzfg6S5ec9asarpAU9'
61+
62+let puzzleTsnPool = addressFromStringValue("3PN1eJpdhJyRptcN9iLTarsJBtR2Kb3NXSU")
63+
64+let wxBtcPool = addressFromStringValue("3PCBWDTA6jrFswd7gQgaE3Xk7gLM5RKofvp")
65+
66+let swopBtcPool = addressFromStringValue("3PACj2DLTw3uUhsUmT98zHU5M4hPufbHKav")
67+
68+let btcAssetIdString = "8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS"
69+
70+let btcAssetId = base58'8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS'
71+
72+let btcWxLPTokenAssetId = base58'8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy'
73+
74+let btcSwopLpToken = base58'58RNQJqLQ3tYYpkjuJujWzLzMX3nzpGn6bTC8LfLtgAM'
75+
76+let wxEthPool = addressFromStringValue("3PEMqetsaJDbYMw1XGovmE37FB8VUhGnX9A")
77+
78+let ethAssetIdString = "474jTeYx2r2Va35794tCScAXWJG9hU2HcgxzMowaZUnu"
79+
80+let ethAssetId = base58'474jTeYx2r2Va35794tCScAXWJG9hU2HcgxzMowaZUnu'
81+
82+let ethWxLPTokenAssetId = base58'6gtgBD12xZkUTnzGofoFJpMg5gYG1FP6PaGyLviVQjbh'
83+
84+let swopEthPool = addressFromStringValue("3PNEC4YKqZiMMytFrYRVtpW2ujvi3aGXRPm")
85+
86+let ethSwopLpToken = base58'H8wRVSgq82j6YU1K7jXVpDXHpd5m91t3bmCzRR7uFGc7'
87+
88+let wxLtcPool = addressFromStringValue("3P94wvu5gA7VhjPgAB3twaeqdwHCwNK2vsn")
89+
90+let ltcAssetIdString = "HZk1mbfuJpmxU1Fs4AX5MWLVYtctsNcg6e2C6VKqK8zk"
91+
92+let ltcAssetId = base58'HZk1mbfuJpmxU1Fs4AX5MWLVYtctsNcg6e2C6VKqK8zk'
93+
94+let ltcWxLPTokenAssetId = base58'CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv'
95+
96+let swopLtcPool = addressFromStringValue("3P32Rjpo9YHoHaorLSxvnV6CkKFXyfDCkJh")
97+
98+let ltcSwopLpToken = base58'2npCQ21bzjEgBYWMepyd95aA3vwXaQpPBXnHtmmXadXF'
99+
100+let wxWestPool = addressFromStringValue("3PFxchXqKNjgP1CcbgFZjHyrEj9xMbSeLU3")
101+
102+let westAssetIdString = "4LHHvYGNKJUg5hj65aGD5vgScvCBmLpdRFtjokvCjSL8"
103+
104+let westAssetId = base58'4LHHvYGNKJUg5hj65aGD5vgScvCBmLpdRFtjokvCjSL8'
105+
106+let westWxLPTokenAssetId = base58'CaryXC3PhVr1rTxUGk8Bx7CcoxPX9ea3F5RGFiCe98Jr'
107+
108+let swopWestPool = addressFromStringValue("3P6DLdJTP2EySq9MFdJu6beUevrQd2sVVBh")
109+
110+let westSwopLpToken = base58'8g1Ki9cvjjhLUTyNwd4MaZ4fNfNTVc92Cb6f8My4qb1A'
111+
112+let wxEggPool = addressFromStringValue("3P3Y38zymCHoTM6qcE9JcEA8rhaGTQbVMgu")
113+
114+let eggAssetIdString = "C1iWsKGqLwjHUndiQ7iXpdmPum9PeCDFfyXBdJJosDRS"
115+
116+let eggAssetId = base58'C1iWsKGqLwjHUndiQ7iXpdmPum9PeCDFfyXBdJJosDRS'
117+
118+let eggWxLPTokenAssetId = base58'EsGs3xQLW8QSRiABfztfVLe8u5a2pvNfkdti4VYes1ms'
119+
120+let swopEggPool = addressFromStringValue("3PEeJQRJT4v4XvSUBPmxhdWKz439nae7KtQ")
121+
122+let eggSwopLpToken = base58'2wk64hhVqjC3DgJa9HE9bcV7dCazuRtCSs6giqBAbBak'
123+
124+let swopPlutoPool = addressFromStringValue("3PDSXwwA2xAtmxeo2bebDP3AA5ynZ2Krgnw")
125+
126+let plutoSwopLpToken = base58'CBFNT7ti8bGzESndbsNB376Ug4fQ2ZyhXzdY892edTqq'
127+
128+let plutoAssetIdString = "Ajso6nTTjptu2UHLx6hfSXVtHFtRBJCkKYd5SAyj7zf5"
129+
130+let plutoAssetId = base58'Ajso6nTTjptu2UHLx6hfSXVtHFtRBJCkKYd5SAyj7zf5'
131+
132+let puzzlePlutoPool = addressFromStringValue("3P93Kqz8PUbCudvMyjbci54WxQrtBtw4dbZ")
133+
134+func getIntegerByKey (key) = valueOrElse(getInteger(this, key), 35)
135+
136+
137+let a = getIntegerByKey("montant")
138+
139+@Callable(i)
140+func set (a) = if ((i.caller != this))
141+    then throw("you are not allowed to set!")
142+    else [IntegerEntry("montant", a)]
143+
144+
145+
146+@Callable(i)
147+func a1 () = if ((i.caller != this))
148+    then throw("you are not allowed to arb!")
149+    else {
150+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
151+        if ((usdnBalanceBefore == usdnBalanceBefore))
152+            then {
153+                let wavesBalanceBefore = wavesBalance(this).available
154+                if ((wavesBalanceBefore == wavesBalanceBefore))
155+                    then {
156+                        let buyOnPuzzle = invoke(nonRoutingPuzzlePool, "swap", ["WAVES", 1], [AttachedPayment(usdnAssetId, (a * 1000000))])
157+                        if ((buyOnPuzzle == buyOnPuzzle))
158+                            then {
159+                                let wavesBalToSwap = (wavesBalance(this).available - wavesBalanceBefore)
160+                                if ((0 >= wavesBalToSwap))
161+                                    then throw("nothing to arb")
162+                                    else {
163+                                        let putTheTokenInThePool = invoke(wxPool, "putOneTkn", [1, false], [AttachedPayment(unit, wavesBalToSwap)])
164+                                        if ((putTheTokenInThePool == putTheTokenInThePool))
165+                                            then {
166+                                                let lpTokenBalance = assetBalance(this, usdnWavesLPTokenAssetId)
167+                                                if ((lpTokenBalance == lpTokenBalance))
168+                                                    then {
169+                                                        let sellPoolToken = invoke(wxPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(usdnWavesLPTokenAssetId, lpTokenBalance)])
170+                                                        if ((sellPoolToken == sellPoolToken))
171+                                                            then {
172+                                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
173+                                                                if ((usdnBalanceAfter == usdnBalanceAfter))
174+                                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
196+func a2 () = if ((i.caller != this))
197+    then throw("you are not allowed to arb!")
198+    else {
199+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
200+        if ((usdnBalanceBefore == usdnBalanceBefore))
201+            then {
202+                let wavesBalanceBefore = wavesBalance(this).available
203+                if ((wavesBalanceBefore == wavesBalanceBefore))
204+                    then {
205+                        let putTheTokenInThePool = invoke(wxPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
206+                        if ((putTheTokenInThePool == putTheTokenInThePool))
207+                            then {
208+                                let lpTokenBalance = assetBalance(this, usdnWavesLPTokenAssetId)
209+                                if ((lpTokenBalance == lpTokenBalance))
210+                                    then {
211+                                        let sellPoolToken = invoke(wxPool, "getOneTkn", ["WAVES", 1], [AttachedPayment(usdnWavesLPTokenAssetId, lpTokenBalance)])
212+                                        if ((sellPoolToken == sellPoolToken))
213+                                            then {
214+                                                let wavesBalToSwap = (wavesBalance(this).available - wavesBalanceBefore)
215+                                                if ((0 >= wavesBalToSwap))
216+                                                    then throw("nothing to arb")
217+                                                    else {
218+                                                        let buyOnPuzzle = invoke(nonRoutingPuzzlePool, "swap", [usdnAssetIdString, 1], [AttachedPayment(unit, wavesBalToSwap)])
219+                                                        if ((buyOnPuzzle == buyOnPuzzle))
220+                                                            then {
221+                                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
222+                                                                if ((usdnBalanceAfter == usdnBalanceAfter))
223+                                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
245+func a3 () = if ((i.caller != this))
246+    then throw("you are not allowed to arb!")
247+    else {
248+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
249+        if ((usdnBalanceBefore == usdnBalanceBefore))
250+            then {
251+                let buySurfOnPuzzle = invoke(nonRoutingPuzzleSurfPool, "swap", [surfAssetIdString, 1], [AttachedPayment(usdnAssetId, (a * 1000000))])
252+                if ((buySurfOnPuzzle == buySurfOnPuzzle))
253+                    then {
254+                        let surfBalToSwap = assetBalance(this, surfAssetId)
255+                        let swapSurfOnSwop = invoke(swopSurfPool, "exchange", [1], [AttachedPayment(surfAssetId, surfBalToSwap)])
256+                        if ((swapSurfOnSwop == swapSurfOnSwop))
257+                            then {
258+                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
259+                                if ((usdnBalanceAfter == usdnBalanceAfter))
260+                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
275+func a4 () = if ((i.caller != this))
276+    then throw("you are not allowed to arb!")
277+    else {
278+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
279+        if ((usdnBalanceBefore == usdnBalanceBefore))
280+            then {
281+                let swapToSurfOnSwop = invoke(swopSurfPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
282+                if ((swapToSurfOnSwop == swapToSurfOnSwop))
283+                    then {
284+                        let surfBalToSwap = assetBalance(this, surfAssetId)
285+                        let sellSurfOnPuzzle = invoke(nonRoutingPuzzleSurfPool, "swap", [usdnAssetIdString, 1], [AttachedPayment(surfAssetId, surfBalToSwap)])
286+                        if ((sellSurfOnPuzzle == sellSurfOnPuzzle))
287+                            then {
288+                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
289+                                if ((usdnBalanceAfter == usdnBalanceAfter))
290+                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
305+func a5 () = if ((i.caller != this))
306+    then throw("you are not allowed to arb!")
307+    else {
308+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
309+        if ((usdnBalanceBefore == usdnBalanceBefore))
310+            then {
311+                let putTheTokenInThePool = invoke(wxWxPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
312+                if ((putTheTokenInThePool == putTheTokenInThePool))
313+                    then {
314+                        let lpTokenBalance = assetBalance(this, usdnWxLPTokenAssetId)
315+                        if ((lpTokenBalance == lpTokenBalance))
316+                            then {
317+                                let sellPoolToken = invoke(wxWxPool, "getOneTkn", [wxAssetIdString, 1], [AttachedPayment(usdnWxLPTokenAssetId, lpTokenBalance)])
318+                                if ((sellPoolToken == sellPoolToken))
319+                                    then {
320+                                        let wxBalToSwap = assetBalance(this, wxAssetId)
321+                                        let swapWxOnSwop = invoke(swopWxPool, "exchange", [1], [AttachedPayment(wxAssetId, wxBalToSwap)])
322+                                        if ((swapWxOnSwop == swapWxOnSwop))
323+                                            then {
324+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
325+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
326+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
345+func a6 () = if ((i.caller != this))
346+    then throw("you are not allowed to arb!")
347+    else {
348+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
349+        if ((usdnBalanceBefore == usdnBalanceBefore))
350+            then {
351+                let swapToWxOnSwop = invoke(swopWxPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
352+                if ((swapToWxOnSwop == swapToWxOnSwop))
353+                    then {
354+                        let wxBalToSwap = assetBalance(this, wxAssetId)
355+                        let putTheTokenInThePool = invoke(wxWxPool, "putOneTkn", [1, false], [AttachedPayment(wxAssetId, wxBalToSwap)])
356+                        if ((putTheTokenInThePool == putTheTokenInThePool))
357+                            then {
358+                                let lpTokenBalance = assetBalance(this, usdnWxLPTokenAssetId)
359+                                if ((lpTokenBalance == lpTokenBalance))
360+                                    then {
361+                                        let sellPoolToken = invoke(wxWxPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(usdnWxLPTokenAssetId, lpTokenBalance)])
362+                                        if ((sellPoolToken == sellPoolToken))
363+                                            then {
364+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
365+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
366+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
385+func a7 () = if ((i.caller != this))
386+    then throw("you are not allowed to arb!")
387+    else {
388+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
389+        if ((usdnBalanceBefore == usdnBalanceBefore))
390+            then {
391+                let buyUsdcOnPuzzle = invoke(puzzleUsdcPool, "swap", [usdcAssetIdString, 1], [AttachedPayment(usdnAssetId, (a * 1000000))])
392+                if ((buyUsdcOnPuzzle == buyUsdcOnPuzzle))
393+                    then {
394+                        let usdcBalToSwap = assetBalance(this, usdcAssetId)
395+                        if ((usdcBalToSwap == usdcBalToSwap))
396+                            then {
397+                                let putTheTokenInThePool = invoke(wxUsdcPool, "putOneTknV2", [1, false], [AttachedPayment(usdcAssetId, usdcBalToSwap)])
398+                                if ((putTheTokenInThePool == putTheTokenInThePool))
399+                                    then {
400+                                        let lpTokenBalance = assetBalance(this, usdcWxLPTokenAssetId)
401+                                        if ((lpTokenBalance == lpTokenBalance))
402+                                            then {
403+                                                let sellPoolToken = invoke(wxUsdcPool, "getOneTknV2", [usdnAssetIdString, 1], [AttachedPayment(usdcWxLPTokenAssetId, lpTokenBalance)])
404+                                                if ((sellPoolToken == sellPoolToken))
405+                                                    then {
406+                                                        let usdnBalanceAfter = assetBalance(this, usdnAssetId)
407+                                                        if ((usdnBalanceAfter == usdnBalanceAfter))
408+                                                            then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
429+func a8 () = if ((i.caller != this))
430+    then throw("you are not allowed to arb!")
431+    else {
432+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
433+        if ((usdnBalanceBefore == usdnBalanceBefore))
434+            then {
435+                let putTheTokenInThePool = invoke(wxUsdcPool, "putOneTknV2", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
436+                if ((putTheTokenInThePool == putTheTokenInThePool))
437+                    then {
438+                        let lpTokenBalance = assetBalance(this, usdcWxLPTokenAssetId)
439+                        if ((lpTokenBalance == lpTokenBalance))
440+                            then {
441+                                let sellPoolToken = invoke(wxUsdcPool, "getOneTknV2", [usdcAssetIdString, 1], [AttachedPayment(usdcWxLPTokenAssetId, lpTokenBalance)])
442+                                if ((sellPoolToken == sellPoolToken))
443+                                    then {
444+                                        let usdcBalToSwap = assetBalance(this, usdcAssetId)
445+                                        if ((usdcBalToSwap == usdcBalToSwap))
446+                                            then {
447+                                                let sellUsdcOnPuzzle = invoke(puzzleUsdcPool, "swap", [usdnAssetIdString, 1], [AttachedPayment(usdcAssetId, usdcBalToSwap)])
448+                                                if ((sellUsdcOnPuzzle == sellUsdcOnPuzzle))
449+                                                    then {
450+                                                        let usdnBalanceAfter = assetBalance(this, usdnAssetId)
451+                                                        if ((usdnBalanceAfter == usdnBalanceAfter))
452+                                                            then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
473+func a9 () = if ((i.caller != this))
474+    then throw("you are not allowed to arb!")
475+    else {
476+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
477+        if ((usdnBalanceBefore == usdnBalanceBefore))
478+            then {
479+                let buyUsdtOnPuzzle = invoke(puzzleUsdtPool, "swap", [usdtAssetIdString, 1], [AttachedPayment(usdnAssetId, (a * 1000000))])
480+                if ((buyUsdtOnPuzzle == buyUsdtOnPuzzle))
481+                    then {
482+                        let usdtBalToSwap = assetBalance(this, usdtAssetId)
483+                        if ((usdtBalToSwap == usdtBalToSwap))
484+                            then {
485+                                let putTheTokenInThePool = invoke(wxUsdtPool, "putOneTknV2", [1, false], [AttachedPayment(usdtAssetId, usdtBalToSwap)])
486+                                if ((putTheTokenInThePool == putTheTokenInThePool))
487+                                    then {
488+                                        let lpTokenBalance = assetBalance(this, usdtWxLPTokenAssetId)
489+                                        if ((lpTokenBalance == lpTokenBalance))
490+                                            then {
491+                                                let sellPoolToken = invoke(wxUsdtPool, "getOneTknV2", [usdnAssetIdString, 1], [AttachedPayment(usdtWxLPTokenAssetId, lpTokenBalance)])
492+                                                if ((sellPoolToken == sellPoolToken))
493+                                                    then {
494+                                                        let usdnBalanceAfter = assetBalance(this, usdnAssetId)
495+                                                        if ((usdnBalanceAfter == usdnBalanceAfter))
496+                                                            then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
517+func a10 () = if ((i.caller != this))
518+    then throw("you are not allowed to arb!")
519+    else {
520+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
521+        if ((usdnBalanceBefore == usdnBalanceBefore))
522+            then {
523+                let putTheTokenInThePool = invoke(wxUsdtPool, "putOneTknV2", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
524+                if ((putTheTokenInThePool == putTheTokenInThePool))
525+                    then {
526+                        let lpTokenBalance = assetBalance(this, usdtWxLPTokenAssetId)
527+                        if ((lpTokenBalance == lpTokenBalance))
528+                            then {
529+                                let sellPoolToken = invoke(wxUsdtPool, "getOneTknV2", [usdtAssetIdString, 1], [AttachedPayment(usdtWxLPTokenAssetId, lpTokenBalance)])
530+                                if ((sellPoolToken == sellPoolToken))
531+                                    then {
532+                                        let usdtBalToSwap = assetBalance(this, usdtAssetId)
533+                                        if ((usdtBalToSwap == usdtBalToSwap))
534+                                            then {
535+                                                let sellUsdtOnPuzzle = invoke(puzzleUsdtPool, "swap", [usdnAssetIdString, 1], [AttachedPayment(usdtAssetId, usdtBalToSwap)])
536+                                                if ((sellUsdtOnPuzzle == sellUsdtOnPuzzle))
537+                                                    then {
538+                                                        let usdnBalanceAfter = assetBalance(this, usdnAssetId)
539+                                                        if ((usdnBalanceAfter == usdnBalanceAfter))
540+                                                            then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
561+func a11 () = if ((i.caller != this))
562+    then throw("you are not allowed to arb!")
563+    else {
564+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
565+        if ((usdnBalanceBefore == usdnBalanceBefore))
566+            then {
567+                let buyTsnOnPuzzle = invoke(puzzleTsnPool, "swap", [tsnAssetIdString, 1], [AttachedPayment(usdnAssetId, (a * 1000000))])
568+                if ((buyTsnOnPuzzle == buyTsnOnPuzzle))
569+                    then {
570+                        let tsnBalToSwap = assetBalance(this, tsnAssetId)
571+                        if ((tsnBalToSwap == tsnBalToSwap))
572+                            then {
573+                                let putTheTokenInThePool = invoke(wxTsnPool, "putOneTkn", [1, false], [AttachedPayment(tsnAssetId, tsnBalToSwap)])
574+                                if ((putTheTokenInThePool == putTheTokenInThePool))
575+                                    then {
576+                                        let lpTokenBalance = assetBalance(this, tsnWxLPTokenAssetId)
577+                                        if ((lpTokenBalance == lpTokenBalance))
578+                                            then {
579+                                                let sellPoolToken = invoke(wxTsnPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(tsnWxLPTokenAssetId, lpTokenBalance)])
580+                                                if ((sellPoolToken == sellPoolToken))
581+                                                    then {
582+                                                        let usdnBalanceAfter = assetBalance(this, usdnAssetId)
583+                                                        if ((usdnBalanceAfter == usdnBalanceAfter))
584+                                                            then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
605+func a12 () = if ((i.caller != this))
606+    then throw("you are not allowed to arb!")
607+    else {
608+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
609+        if ((usdnBalanceBefore == usdnBalanceBefore))
610+            then {
611+                let putTheTokenInThePool = invoke(wxTsnPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
612+                if ((putTheTokenInThePool == putTheTokenInThePool))
613+                    then {
614+                        let lpTokenBalance = assetBalance(this, tsnWxLPTokenAssetId)
615+                        if ((lpTokenBalance == lpTokenBalance))
616+                            then {
617+                                let sellPoolToken = invoke(wxTsnPool, "getOneTkn", [tsnAssetIdString, 1], [AttachedPayment(tsnWxLPTokenAssetId, lpTokenBalance)])
618+                                if ((sellPoolToken == sellPoolToken))
619+                                    then {
620+                                        let tsnBalToSwap = assetBalance(this, tsnAssetId)
621+                                        if ((tsnBalToSwap == tsnBalToSwap))
622+                                            then {
623+                                                let selltsnOnPuzzle = invoke(puzzleTsnPool, "swap", [usdnAssetIdString, 1], [AttachedPayment(tsnAssetId, tsnBalToSwap)])
624+                                                if ((selltsnOnPuzzle == selltsnOnPuzzle))
625+                                                    then {
626+                                                        let usdnBalanceAfter = assetBalance(this, usdnAssetId)
627+                                                        if ((usdnBalanceAfter == usdnBalanceAfter))
628+                                                            then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
649+func a13 () = if ((i.caller != this))
650+    then throw("you are not allowed to arb!")
651+    else {
652+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
653+        if ((usdnBalanceBefore == usdnBalanceBefore))
654+            then {
655+                let putTheTokenInThePool = invoke(wxBtcPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
656+                if ((putTheTokenInThePool == putTheTokenInThePool))
657+                    then {
658+                        let lpTokenBalance = assetBalance(this, btcWxLPTokenAssetId)
659+                        if ((lpTokenBalance == lpTokenBalance))
660+                            then {
661+                                let sellPoolToken = invoke(wxBtcPool, "getOneTkn", [btcAssetIdString, 1], [AttachedPayment(btcWxLPTokenAssetId, lpTokenBalance)])
662+                                if ((sellPoolToken == sellPoolToken))
663+                                    then {
664+                                        let btcBalToSwap = assetBalance(this, btcAssetId)
665+                                        let swapBtcOnSwop = invoke(swopBtcPool, "exchange", [1], [AttachedPayment(btcAssetId, btcBalToSwap)])
666+                                        if ((swapBtcOnSwop == swapBtcOnSwop))
667+                                            then {
668+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
669+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
670+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
689+func a14 () = if ((i.caller != this))
690+    then throw("you are not allowed to arb!")
691+    else {
692+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
693+        if ((usdnBalanceBefore == usdnBalanceBefore))
694+            then {
695+                let swapToBtcOnSwop = invoke(swopBtcPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
696+                if ((swapToBtcOnSwop == swapToBtcOnSwop))
697+                    then {
698+                        let btcBalToSwap = assetBalance(this, btcAssetId)
699+                        let putTheTokenInThePool = invoke(wxBtcPool, "putOneTkn", [1, false], [AttachedPayment(btcAssetId, btcBalToSwap)])
700+                        if ((putTheTokenInThePool == putTheTokenInThePool))
701+                            then {
702+                                let lpTokenBalance = assetBalance(this, btcWxLPTokenAssetId)
703+                                if ((lpTokenBalance == lpTokenBalance))
704+                                    then {
705+                                        let sellPoolToken = invoke(wxBtcPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(btcWxLPTokenAssetId, lpTokenBalance)])
706+                                        if ((sellPoolToken == sellPoolToken))
707+                                            then {
708+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
709+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
710+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
729+func a15 () = if ((i.caller != this))
730+    then throw("you are not allowed to arb!")
731+    else {
732+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
733+        if ((usdnBalanceBefore == usdnBalanceBefore))
734+            then {
735+                let putTheTokenInThePool = invoke(wxEthPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
736+                if ((putTheTokenInThePool == putTheTokenInThePool))
737+                    then {
738+                        let lpTokenBalance = assetBalance(this, ethWxLPTokenAssetId)
739+                        if ((lpTokenBalance == lpTokenBalance))
740+                            then {
741+                                let sellPoolToken = invoke(wxEthPool, "getOneTkn", [ethAssetIdString, 1], [AttachedPayment(ethWxLPTokenAssetId, lpTokenBalance)])
742+                                if ((sellPoolToken == sellPoolToken))
743+                                    then {
744+                                        let ethBalToSwap = assetBalance(this, ethAssetId)
745+                                        let swapEthOnSwop = invoke(swopEthPool, "exchange", [1], [AttachedPayment(ethAssetId, ethBalToSwap)])
746+                                        if ((swapEthOnSwop == swapEthOnSwop))
747+                                            then {
748+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
749+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
750+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
769+func a16 () = if ((i.caller != this))
770+    then throw("you are not allowed to arb!")
771+    else {
772+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
773+        if ((usdnBalanceBefore == usdnBalanceBefore))
774+            then {
775+                let swapToEthOnSwop = invoke(swopEthPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
776+                if ((swapToEthOnSwop == swapToEthOnSwop))
777+                    then {
778+                        let ethBalToSwap = assetBalance(this, ethAssetId)
779+                        let putTheTokenInThePool = invoke(wxEthPool, "putOneTkn", [1, false], [AttachedPayment(ethAssetId, ethBalToSwap)])
780+                        if ((putTheTokenInThePool == putTheTokenInThePool))
781+                            then {
782+                                let lpTokenBalance = assetBalance(this, ethWxLPTokenAssetId)
783+                                if ((lpTokenBalance == lpTokenBalance))
784+                                    then {
785+                                        let sellPoolToken = invoke(wxEthPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(ethWxLPTokenAssetId, lpTokenBalance)])
786+                                        if ((sellPoolToken == sellPoolToken))
787+                                            then {
788+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
789+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
790+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
809+func a17 () = if ((i.caller != this))
810+    then throw("you are not allowed to arb!")
811+    else {
812+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
813+        if ((usdnBalanceBefore == usdnBalanceBefore))
814+            then {
815+                let putTheTokenInThePool = invoke(wxLtcPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
816+                if ((putTheTokenInThePool == putTheTokenInThePool))
817+                    then {
818+                        let lpTokenBalance = assetBalance(this, ltcWxLPTokenAssetId)
819+                        if ((lpTokenBalance == lpTokenBalance))
820+                            then {
821+                                let sellPoolToken = invoke(wxLtcPool, "getOneTkn", [ltcAssetIdString, 1], [AttachedPayment(ltcWxLPTokenAssetId, lpTokenBalance)])
822+                                if ((sellPoolToken == sellPoolToken))
823+                                    then {
824+                                        let ltcBalToSwap = assetBalance(this, ltcAssetId)
825+                                        let swapLtcOnSwop = invoke(swopLtcPool, "exchange", [1], [AttachedPayment(ltcAssetId, ltcBalToSwap)])
826+                                        if ((swapLtcOnSwop == swapLtcOnSwop))
827+                                            then {
828+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
829+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
830+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
849+func a18 () = if ((i.caller != this))
850+    then throw("you are not allowed to arb!")
851+    else {
852+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
853+        if ((usdnBalanceBefore == usdnBalanceBefore))
854+            then {
855+                let swapToLtcOnSwop = invoke(swopLtcPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
856+                if ((swapToLtcOnSwop == swapToLtcOnSwop))
857+                    then {
858+                        let ltcBalToSwap = assetBalance(this, ltcAssetId)
859+                        let putTheTokenInThePool = invoke(wxLtcPool, "putOneTkn", [1, false], [AttachedPayment(ltcAssetId, ltcBalToSwap)])
860+                        if ((putTheTokenInThePool == putTheTokenInThePool))
861+                            then {
862+                                let lpTokenBalance = assetBalance(this, ltcWxLPTokenAssetId)
863+                                if ((lpTokenBalance == lpTokenBalance))
864+                                    then {
865+                                        let sellPoolToken = invoke(wxLtcPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(ltcWxLPTokenAssetId, lpTokenBalance)])
866+                                        if ((sellPoolToken == sellPoolToken))
867+                                            then {
868+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
869+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
870+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
889+func a19 () = if ((i.caller != this))
890+    then throw("you are not allowed to arb!")
891+    else {
892+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
893+        if ((usdnBalanceBefore == usdnBalanceBefore))
894+            then {
895+                let putTheTokenInThePool = invoke(wxWestPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
896+                if ((putTheTokenInThePool == putTheTokenInThePool))
897+                    then {
898+                        let lpTokenBalance = assetBalance(this, westWxLPTokenAssetId)
899+                        if ((lpTokenBalance == lpTokenBalance))
900+                            then {
901+                                let sellPoolToken = invoke(wxWestPool, "getOneTkn", [westAssetIdString, 1], [AttachedPayment(westWxLPTokenAssetId, lpTokenBalance)])
902+                                if ((sellPoolToken == sellPoolToken))
903+                                    then {
904+                                        let westBalToSwap = assetBalance(this, westAssetId)
905+                                        let swapWestOnSwop = invoke(swopWestPool, "exchange", [1], [AttachedPayment(westAssetId, westBalToSwap)])
906+                                        if ((swapWestOnSwop == swapWestOnSwop))
907+                                            then {
908+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
909+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
910+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
929+func a20 () = if ((i.caller != this))
930+    then throw("you are not allowed to arb!")
931+    else {
932+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
933+        if ((usdnBalanceBefore == usdnBalanceBefore))
934+            then {
935+                let swapToWestOnSwop = invoke(swopWestPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
936+                if ((swapToWestOnSwop == swapToWestOnSwop))
937+                    then {
938+                        let westBalToSwap = assetBalance(this, westAssetId)
939+                        let putTheTokenInThePool = invoke(wxWestPool, "putOneTkn", [1, false], [AttachedPayment(westAssetId, westBalToSwap)])
940+                        if ((putTheTokenInThePool == putTheTokenInThePool))
941+                            then {
942+                                let lpTokenBalance = assetBalance(this, westWxLPTokenAssetId)
943+                                if ((lpTokenBalance == lpTokenBalance))
944+                                    then {
945+                                        let sellPoolToken = invoke(wxWestPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(westWxLPTokenAssetId, lpTokenBalance)])
946+                                        if ((sellPoolToken == sellPoolToken))
947+                                            then {
948+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
949+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
950+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
969+func a21 () = if ((i.caller != this))
970+    then throw("you are not allowed to arb!")
971+    else {
972+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
973+        if ((usdnBalanceBefore == usdnBalanceBefore))
974+            then {
975+                let putTheTokenInThePool = invoke(wxEggPool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (a * 1000000))])
976+                if ((putTheTokenInThePool == putTheTokenInThePool))
977+                    then {
978+                        let lpTokenBalance = assetBalance(this, eggWxLPTokenAssetId)
979+                        if ((lpTokenBalance == lpTokenBalance))
980+                            then {
981+                                let sellPoolToken = invoke(wxEggPool, "getOneTkn", [eggAssetIdString, 1], [AttachedPayment(eggWxLPTokenAssetId, lpTokenBalance)])
982+                                if ((sellPoolToken == sellPoolToken))
983+                                    then {
984+                                        let eggBalToSwap = assetBalance(this, eggAssetId)
985+                                        let swapEggOnSwop = invoke(swopEggPool, "exchange", [1], [AttachedPayment(eggAssetId, eggBalToSwap)])
986+                                        if ((swapEggOnSwop == swapEggOnSwop))
987+                                            then {
988+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
989+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
990+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
1009+func a22 () = if ((i.caller != this))
1010+    then throw("you are not allowed to arb!")
1011+    else {
1012+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
1013+        if ((usdnBalanceBefore == usdnBalanceBefore))
1014+            then {
1015+                let swapToEggOnSwop = invoke(swopEggPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
1016+                if ((swapToEggOnSwop == swapToEggOnSwop))
1017+                    then {
1018+                        let eggBalToSwap = assetBalance(this, eggAssetId)
1019+                        let putTheTokenInThePool = invoke(wxEggPool, "putOneTkn", [1, false], [AttachedPayment(eggAssetId, eggBalToSwap)])
1020+                        if ((putTheTokenInThePool == putTheTokenInThePool))
1021+                            then {
1022+                                let lpTokenBalance = assetBalance(this, eggWxLPTokenAssetId)
1023+                                if ((lpTokenBalance == lpTokenBalance))
1024+                                    then {
1025+                                        let sellPoolToken = invoke(wxEggPool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(eggWxLPTokenAssetId, lpTokenBalance)])
1026+                                        if ((sellPoolToken == sellPoolToken))
1027+                                            then {
1028+                                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
1029+                                                if ((usdnBalanceAfter == usdnBalanceAfter))
1030+                                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
1049+func a23 () = if ((i.caller != this))
1050+    then throw("you are not allowed to arb!")
1051+    else {
1052+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
1053+        if ((usdnBalanceBefore == usdnBalanceBefore))
1054+            then {
1055+                let buyPlutoOnPuzzle = invoke(puzzlePlutoPool, "swap", [plutoAssetIdString, 1], [AttachedPayment(usdnAssetId, (a * 1000000))])
1056+                if ((buyPlutoOnPuzzle == buyPlutoOnPuzzle))
1057+                    then {
1058+                        let plutoBalToSwap = assetBalance(this, plutoAssetId)
1059+                        let swapPlutoOnSwop = invoke(swopPlutoPool, "exchange", [1], [AttachedPayment(plutoAssetId, plutoBalToSwap)])
1060+                        if ((swapPlutoOnSwop == swapPlutoOnSwop))
1061+                            then {
1062+                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
1063+                                if ((usdnBalanceAfter == usdnBalanceAfter))
1064+                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(i)
1079+func a24 () = if ((i.caller != this))
1080+    then throw("you are not allowed to arb!")
1081+    else {
1082+        let usdnBalanceBefore = assetBalance(this, usdnAssetId)
1083+        if ((usdnBalanceBefore == usdnBalanceBefore))
1084+            then {
1085+                let swapToPlutoOnSwop = invoke(swopPlutoPool, "exchange", [1], [AttachedPayment(usdnAssetId, (a * 1000000))])
1086+                if ((swapToPlutoOnSwop == swapToPlutoOnSwop))
1087+                    then {
1088+                        let plutoBalToSwap = assetBalance(this, plutoAssetId)
1089+                        let sellPlutoOnPuzzle = invoke(puzzlePlutoPool, "swap", [usdnAssetIdString, 1], [AttachedPayment(plutoAssetId, plutoBalToSwap)])
1090+                        if ((sellPlutoOnPuzzle == sellPlutoOnPuzzle))
1091+                            then {
1092+                                let usdnBalanceAfter = assetBalance(this, usdnAssetId)
1093+                                if ((usdnBalanceAfter == usdnBalanceAfter))
1094+                                    then if ((0 >= (usdnBalanceAfter - usdnBalanceBefore)))
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(tx)
1108+func verify () = sigVerify_128Kb(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
1109+
github/deemru/w8io/6500d08 
80.92 ms ◑