tx · GnP1mnZhHuB4famGD2RfhVUHoyRK1mq2a8h7jTReEaw2

3P5wA45whe3XB4ECK6UYofNM3uFHFxE4KTn:  -0.04000000 Waves

2023.05.09 12:55 [3635653] smart account 3P5wA45whe3XB4ECK6UYofNM3uFHFxE4KTn > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GnP1mnZhHuB4famGD2RfhVUHoyRK1mq2a8h7jTReEaw2",
    "fee": 4000000,
    "feeAssetId": null,
    "timestamp": 1683626209670,
    "version": 2,
    "chainId": 87,
    "sender": "3P5wA45whe3XB4ECK6UYofNM3uFHFxE4KTn",
    "senderPublicKey": "77PTtvVsSSK5NDQN4NdKYYvRFDV34gUPe5hMXgrCQg1B",
    "proofs": [
        "5fFbciLhtULHQmRkdbHccLqgaTZ4VCpe8mTMDBTYwhcryWHrv4NNqvto7WTguTVSdtLzyBPY5ZULi9fWmQ1T3GKf"
    ],
    "script": "base64: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",
    "height": 3635653,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: D8N7EvbYzCmqS6pBS9B9YAwgL93J96yJUjPjMahKUZhY
Next: GjUnsxBbhZoxWm3nj4UoPzjWh8TKyLCr4pnLzFVQKAXD

Diff: 

OldNewDifferences
1212         ""
1313 }
1414 
15+let w2 = match getString(this, "w2") {
16+    case r: String => 
17+        r
18+    case _ => 
19+        ""
20+}
21+
22+let USDN_ASSET_ID = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
23+
1524 let WX_SWAP_DAPP = Address(base58'3P68zNiufsu1viZpu1aY3cdahRRKcvV5N93')
1625 
1726 let assets_in = ["DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"]
18-
19-func getBalance (assetId) = match assetId {
20-    case b: ByteVector => 
21-        assetBalance(this, b)
22-    case _ => 
23-        wavesBalance(this).available
24-}
25-
2627 
2728 func getBase1 (data) = {
2829     let p_data = split_4C(data, "_")
7879         0
7980 }
8081 
82+
83+let Scale6 = 1000000
84+
85+let Scale6BigInt = toBigInt(Scale6)
86+
87+let Scale8 = 100000000
88+
89+let Scale8BigInt = toBigInt(Scale8)
90+
91+let ZeroBigInt = toBigInt(0)
92+
93+let SEP = "__"
94+
95+let InScale = 100000000
96+
97+let InDecimals = 8
98+
99+let InScaleBigInt = toBigInt(InScale)
100+
101+let InAsset = unit
102+
103+let InAssetStr = "WAVES"
104+
105+let wxSwapAddress = Address(base58'3P68zNiufsu1viZpu1aY3cdahRRKcvV5N93')
106+
107+let thisAddressStr = toString(this)
108+
109+func getIntOrZero (key) = valueOrElse(getInteger(key), 0)
110+
111+
112+func getBalance (asset) = if ((asset == unit))
113+    then wavesBalance(this).regular
114+    else assetBalance(this, value(asset))
115+
116+
117+func getAssetOrWaves (assetStr) = if ((assetStr == "WAVES"))
118+    then unit
119+    else fromBase58String(assetStr)
120+
121+
122+let inBalance = getBalance(InAsset)
123+
124+let inBalanceBigInt = toBigInt(inBalance)
125+
126+func getSwopPool (pool) = {
127+    let assetIdAStr = getStringValue(pool, "A_asset_id")
128+    let assetIdBStr = getStringValue(pool, "B_asset_id")
129+    let assetIdA = getAssetOrWaves(assetIdAStr)
130+    let assetIdB = getAssetOrWaves(assetIdBStr)
131+    let balanceA = getIntegerValue(pool, "A_asset_balance")
132+    let balanceB = getIntegerValue(pool, "B_asset_balance")
133+    let outFee = (Scale6BigInt - toBigInt(getIntegerValue(pool, "commission")))
134+    $Tuple9(toBigInt(balanceA), toBigInt(balanceB), assetIdA, assetIdB, assetIdAStr, assetIdBStr, Scale6BigInt, outFee, pool)
135+    }
136+
137+
138+func keyAdditionalBalance (assetId) = makeString(["%s%s", "stakedBalance", assetId], SEP)
139+
140+
141+func keyStakingAssetBalance (assetId) = makeString(["%s%s", "shareAssetBalance", assetId], SEP)
142+
143+
144+func getAdditionalBalanceOrZero (pool,assetId) = valueOrElse(getInteger(pool, keyAdditionalBalance(assetId)), 0)
145+
146+
147+func getStakingAssetBalanceOrZero (pool,assetId) = valueOrElse(getInteger(pool, keyStakingAssetBalance(assetId)), 0)
148+
149+
150+func getWxAccountBalance (pool,assetId) = {
151+    let balanceOnPool = if ((assetId == "WAVES"))
152+        then wavesBalance(pool).available
153+        else assetBalance(pool, fromBase58String(assetId))
154+    let totalBalance = ((balanceOnPool + getAdditionalBalanceOrZero(pool, assetId)) - getStakingAssetBalanceOrZero(pool, assetId))
155+    max([0, totalBalance])
156+    }
157+
158+
159+func getWxPool (pool) = {
160+    let assetIdAStr = getStringValue(pool, "%s__amountAsset")
161+    let assetIdBStr = getStringValue(pool, "%s__priceAsset")
162+    let assetIdA = getAssetOrWaves(assetIdAStr)
163+    let assetIdB = getAssetOrWaves(assetIdBStr)
164+    let balanceA = getWxAccountBalance(pool, assetIdAStr)
165+    let balanceB = getWxAccountBalance(pool, assetIdBStr)
166+    let protocolFee = getIntegerValue(wxSwapAddress, "%s__protocolFee")
167+    let poolFee = getIntegerValue(wxSwapAddress, "%s__poolFee")
168+    let inFee = (Scale6BigInt - fraction(toBigInt((protocolFee + poolFee)), Scale6BigInt, Scale8BigInt))
169+    $Tuple9(toBigInt(balanceA), toBigInt(balanceB), assetIdA, assetIdB, assetIdAStr, assetIdBStr, inFee, Scale6BigInt, wxSwapAddress)
170+    }
171+
172+
173+func calcSwap (pmtAmount,tokenFrom,tokenTo,inFee,outFee) = {
174+    let cleanAmount = fraction(pmtAmount, inFee, Scale6BigInt)
175+    let amountWithoutFee = fraction(tokenTo, cleanAmount, (cleanAmount + tokenFrom))
176+    let amountWithFee = fraction(amountWithoutFee, outFee, Scale6BigInt)
177+    amountWithFee
178+    }
179+
180+
181+func estimateSwap (poolInfo,inAsset,inAmount) = {
182+    let routeArgs = if ((inAsset == poolInfo._3))
183+        then $Tuple3(poolInfo._4, poolInfo._6, calcSwap(inAmount, poolInfo._1, poolInfo._2, poolInfo._7, poolInfo._8))
184+        else $Tuple3(poolInfo._3, poolInfo._5, calcSwap(inAmount, poolInfo._2, poolInfo._1, poolInfo._7, poolInfo._8))
185+    let dappArgs = if ((poolInfo._9 == wxSwapAddress))
186+        then $Tuple2("swap", [0, routeArgs._2, thisAddressStr])
187+        else $Tuple2("exchange", [1])
188+    $Tuple4(routeArgs._1, routeArgs._3, dappArgs._1, dappArgs._2)
189+    }
190+
191+
192+func estimateRoute (pool1,pool2,pool3,pool1Reverse,pool2Reverse,pool3Reverse) = {
193+    let a12 = if (pool1Reverse)
194+        then pool1._2
195+        else pool1._1
196+    let a21 = if (pool1Reverse)
197+        then pool1._1
198+        else pool1._2
199+    let a23 = if (pool2Reverse)
200+        then pool2._2
201+        else pool2._1
202+    let a32 = if (pool2Reverse)
203+        then pool2._1
204+        else pool2._2
205+    let a31 = if (pool3Reverse)
206+        then pool3._2
207+        else pool3._1
208+    let a13 = if (pool3Reverse)
209+        then pool3._1
210+        else pool3._2
211+    let aaDenominator = (a23 + fraction(fraction(a21, pool1._8, Scale6BigInt), pool2._7, Scale6BigInt))
212+    let aa13 = fraction(a12, a23, aaDenominator)
213+    let aa31 = fraction(fraction(fraction(a21, a32, aaDenominator), pool2._7, Scale6BigInt), pool2._8, Scale6BigInt)
214+    let aDenominator = (a31 + fraction(fraction(aa31, pool1._7, Scale6BigInt), pool1._8, Scale6BigInt))
215+    let a = fraction(aa13, a31, aDenominator)
216+    let aa = fraction(fraction(fraction(aa31, a13, aDenominator), pool3._7, Scale6BigInt), pool3._8, Scale6BigInt)
217+    let delta = fraction((sqrtBigInt(fraction(fraction(fraction(aa, a, InScaleBigInt), pool1._7, Scale6BigInt), pool1._8, Scale6BigInt), InDecimals, InDecimals, CEILING) - a), Scale6BigInt, pool1._7)
218+    if ((ZeroBigInt >= delta))
219+        then $Tuple2(0, nil)
220+        else {
221+            let input = if ((delta > inBalanceBigInt))
222+                then inBalanceBigInt
223+                else delta
224+            let swap1 = estimateSwap(pool1, InAsset, input)
225+            let swap2 = estimateSwap(pool2, swap1._1, swap1._2)
226+            let swap3 = estimateSwap(pool3, swap2._1, swap2._2)
227+            $Tuple2(toInt((swap3._2 - input)), [$Tuple5(pool1._9, swap1._3, swap1._4, InAsset, toInt(input)), $Tuple5(pool2._9, swap2._3, swap2._4, swap1._1, toInt(swap1._2)), $Tuple5(pool3._9, swap3._3, swap3._4, swap2._1, toInt(swap2._2))])
228+            }
229+    }
230+
231+
232+func invokeSwap (args) = {
233+    let currentBalance = getBalance(args._4)
234+    let trimmedAmount = if ((args._5 > currentBalance))
235+        then currentBalance
236+        else args._5
237+    let resultAmount = if ((args._4 == InAsset))
238+        then trimmedAmount
239+        else if ((currentBalance > args._5))
240+            then currentBalance
241+            else trimmedAmount
242+    invoke(args._1, args._2, args._3, [AttachedPayment(args._4, resultAmount)])
243+    }
244+
245+
246+let swop_btcwxg_xtn = getSwopPool(Address(base58'3PACj2DLTw3uUhsUmT98zHU5M4hPufbHKav'))
247+
248+let swop_crvwxg_xtn = getSwopPool(Address(base58'3P9o2H6G5d2xXBTfBEwjzHc16RLSZLFLQjp'))
249+
250+let swop_egg_waves = getSwopPool(Address(base58'3PNVFWopwCD9CgGXkpYWEY94oQ5XCAEXBmQ'))
251+
252+let swop_ethwxg_xtn = getSwopPool(Address(base58'3PNEC4YKqZiMMytFrYRVtpW2ujvi3aGXRPm'))
253+
254+let swop_ethppt_waves = getSwopPool(Address(base58'3P3KU81iteCQxKb8u15yEPcABknLEcCvGyr'))
255+
256+let swop_enno_xtn = getSwopPool(Address(base58'3P8bovWtkLFVToB8LxP8AZLoWVwC8rDZLQQ'))
257+
258+let swop_ltcwxg_xtn = getSwopPool(Address(base58'3P32Rjpo9YHoHaorLSxvnV6CkKFXyfDCkJh'))
259+
260+let swop_nsbt_xtn = getSwopPool(Address(base58'3P2V63Xd6BviDkeMzxhUw2SJyojByRz8a8m'))
261+
262+let swop_pluto_xtn = getSwopPool(Address(base58'3PDSXwwA2xAtmxeo2bebDP3AA5ynZ2Krgnw'))
263+
264+let swop_pwr_xtn = getSwopPool(Address(base58'3P88KDKWHNKNdbZxe8FfAJP8coAhvfDtuzV'))
265+
266+let swop_puzzle_xtn = getSwopPool(Address(base58'3PBHyEwmERR1CEkrTNbPj2bgyisTfPRqfee'))
267+
268+let swop_puzzle_waves = getSwopPool(Address(base58'3PRFKemXs4rAJYGPccNtP63Kw2UzwEdH7sZ'))
269+
270+let swop_race_egg = getSwopPool(Address(base58'3P3Z8Gn665CJr14bTLv4d5USDBUQCTeeCaT'))
271+
272+let swop_sign_xtn = getSwopPool(Address(base58'3P4Ftyud3U3xnuR8sTc1RvV4iQD62TcKndy'))
273+
274+let swop_surf_xtn = getSwopPool(Address(base58'3PLp9KrdrbWAvSFHGJVEaszUubquz3M6mfe'))
275+
276+let swop_swop_xtn = getSwopPool(Address(base58'3P27S9V36kw2McjWRZ37AxTx8iwkd7HXw6W'))
277+
278+let swop_swop_waves = getSwopPool(Address(base58'3PH8Np6jwuoikvkHL2qmdpFEHBR4UV5vwSq'))
279+
280+let swop_tsn_xtn = getSwopPool(Address(base58'3PCwvns2dnmobD6Z4cR86v98s7LgMZYygEy'))
281+
282+let swop_vires_xtn = getSwopPool(Address(base58'3PJ48P3p2wvWUjgQaQiZ2cFbr8qmxMokBGd'))
283+
284+let swop_vvusdnlp_xtn = getSwopPool(Address(base58'3PCkJuWHu1QJLHvcdUegYczfNVohS6c1A6o'))
285+
286+let swop_usdcwxg_usdtwxg = getSwopPool(Address(base58'3PJgkN4gy6b8qpA86otcJ2KDTbL8ay2n91s'))
287+
288+let swop_waves_btcwxg = getSwopPool(Address(base58'3P8FVZgAJUAq32UEZtTw84qS4zLqEREiEiP'))
289+
290+let swop_waves_xtn = getSwopPool(Address(base58'3PHaNgomBkrvEL2QnuJarQVJa71wjw9qiqG'))
291+
292+let swop_west_east = getSwopPool(Address(base58'3PHTDdjz8Kb5JcAkhzfR57MCUYoe73pyxxK'))
293+
294+let swop_waves_eurn = getSwopPool(Address(base58'3PK7Xe5BiedRyxHLuMQx5ey9riUQqvUths2'))
295+
296+let swop_waves_usdcppt = getSwopPool(Address(base58'3PESG2RvmPdDrMCbCVvzJvqxDR9d2HcAE2z'))
297+
298+let swop_waves_usdtppt = getSwopPool(Address(base58'3P2M9btqYdpENh1SkaHFDdc8XSjXHNiAXF5'))
299+
300+let swop_wct_xtn = getSwopPool(Address(base58'3PMDFxmG9uXAbuQgiNogZCBQASvCHt1Mdar'))
301+
302+let swop_west_xtn = getSwopPool(Address(base58'3P6DLdJTP2EySq9MFdJu6beUevrQd2sVVBh'))
303+
304+let swop_wx_xtn = getSwopPool(Address(base58'3PKi4G3VX2k42ZSmNNrmvgdDH7JzRaUhY7R'))
305+
306+let swop_xtn_usdtwxg = getSwopPool(Address(base58'3PAunb4Dadc9rQM2VJNQBgQV3vrgF9z8Evq'))
307+
308+let wx_bnbppt_waves = getWxPool(Address(base58'3PErdCQg2f8WYGG7DzSiH5FBosdnPHE6cND'))
309+
310+let wx_bnbwxg_xtn = getWxPool(Address(base58'3P8NCvcipinDQVQZujpczBdvG7FL5EvTqLM'))
311+
312+let wx_btcwxg_xtn = getWxPool(Address(base58'3PCBWDTA6jrFswd7gQgaE3Xk7gLM5RKofvp'))
313+
314+let wx_crv_xtn = getWxPool(Address(base58'3PHBmNjbaT8Re837JUfPGXeaW8NKfBQPr1u'))
315+
316+let wx_east_xtn = getWxPool(Address(base58'3PHxdxsgxNwEjVRt45sjeUfNZZ8uHzYVpvH'))
317+
318+let wx_egg_waves = getWxPool(Address(base58'3PJkUhnAHMaBTjyc7FkBfHantNUy871kBBW'))
319+
320+let wx_egg_xtn = getWxPool(Address(base58'3P3Y38zymCHoTM6qcE9JcEA8rhaGTQbVMgu'))
321+
322+let wx_enno_xtn = getWxPool(Address(base58'3P2H4iQAfxQCJaFCNgRLmKkLvv2yDhV93QC'))
323+
324+let wx_ethppt_waves = getWxPool(Address(base58'3P2yiVnK48evTLr8MAZWavpE4WA4fw1weQg'))
325+
326+let wx_ethppt_usdtppt = getWxPool(Address(base58'3PATKQATPmnxLd5DjXg8FmbXXbKpA1BVAvS'))
327+
328+let wx_ethwxg_waves = getWxPool(Address(base58'3P3XGTN6s292g9iwYhs3TEqJqHiffQYojuE'))
329+
330+let wx_ethwxg_xtn = getWxPool(Address(base58'3PEMqetsaJDbYMw1XGovmE37FB8VUhGnX9A'))
331+
332+let wx_eurn_xtn = getWxPool(Address(base58'3P879DU3ycr2XWorD7rR5gSpn1CpYgHjgFT'))
333+
334+let wx_ltcwxg_xtn = getWxPool(Address(base58'3P94wvu5gA7VhjPgAB3twaeqdwHCwNK2vsn'))
335+
336+let wx_nsbt_waves = getWxPool(Address(base58'3PPR4zVfWP4w4rshP541aiFtPNQN2sNJwrY'))
337+
338+let wx_nsbt_xtn = getWxPool(Address(base58'3P97XQCT9VYMXBxasVpDsE7eZfQ6cR9eS9n'))
339+
340+let wx_pluto_waves = getWxPool(Address(base58'3P6ZipK8ydb4qHmufCquh98g9KW6EwaeJfk'))
341+
342+let wx_pluto_xtn = getWxPool(Address(base58'3PEkD5LuHGWhUfgBW1owZFxVydYoWjV6Jia'))
343+
344+let wx_puzzle_waves = getWxPool(Address(base58'3PQaYm4pbRVrNTTnL8pDJZTxhcmD4jRskrz'))
345+
346+let wx_puzzle_xtn = getWxPool(Address(base58'3P615yXeQ9Qu4qBM1QGimGzixyMS5W4Ktug'))
347+
348+let wx_pwr_waves = getWxPool(Address(base58'3PDi7Qq8pLQYvtKyTfQuqqPUWyhoYbU957t'))
349+
350+let wx_race_xtn = getWxPool(Address(base58'3P2nHbqMt7hiYKQjYLT3AEDteS4SYGeHTuc'))
351+
352+let wx_sign_xtn = getWxPool(Address(base58'3P6UuvAt9RFuVznvjAQ7c2RrU25iU917WTN'))
353+
354+let wx_surf_waves = getWxPool(Address(base58'3PNnCngfvAzyvAQ1cEudZ3o6o3tFktsBVz5'))
355+
356+let wx_surf_usdcwxg = getWxPool(Address(base58'3PBfTdcoKmMNxZcjP8eTokbLFqYTUdoNKWL'))
357+
358+let wx_surf_usdtwxg = getWxPool(Address(base58'3PM6YyJauiFTZzVLuRcCkDwWBvWTvPYo1ZM'))
359+
360+let wx_swaves_waves = getWxPool(Address(base58'3PDVaJDqCadWeBugf768XeKiXtCCLUrYMge'))
361+
362+let wx_swaves_xtn = getWxPool(Address(base58'3PEmxUzcCbsAcw6Q3VNLTWdd8bjc8KBUEDz'))
363+
364+let wx_swop_waves = getWxPool(Address(base58'3PA8nK44sopUpXNcCRTpPSH2F7yjvxzx5cw'))
365+
366+let wx_swop_xtn = getWxPool(Address(base58'3PCApn7kL3UMdCVYA2Ln2UcQvfnkFRL1qDC'))
367+
368+let wx_usdtppt_xtn = getWxPool(Address(base58'3P5kfoYW7jPa9zYoTkN6Z6z8xtw8JGhymYB'))
369+
370+let wx_tsn_xtn = getWxPool(Address(base58'3PH832eKnw67PFvJfUg9Knz6BHM87QvjMeL'))
371+
372+let wx_vires_waves = getWxPool(Address(base58'3P7Z7X5kKXN4TpZ2SmqP2xyLGuotAqht1pU'))
373+
374+let wx_vires_xtn = getWxPool(Address(base58'3P5HjPowgipiVB3UvXphDiPvKs424WC9xQw'))
375+
376+let wx_vvusdnlp_xtn = getWxPool(Address(base58'3P9UJxhsqj1UkqPDtM16yi9aGE26V5tdH6i'))
377+
378+let wx_waves_btcwxg = getWxPool(Address(base58'3PPQDcvXuwVToC2QNWzPwxmLxLzMw9Eoe8C'))
379+
380+let wx_waves_busdwxg = getWxPool(Address(base58'3P9vSwu2eLLmyAi8BdEoZvTwsxSWjsAh8Jm'))
381+
382+let wx_waves_xtn = getWxPool(Address(base58'3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g'))
383+
384+let wx_waves_usdtppt = getWxPool(Address(base58'3PPeWowdyQLKwW9AExN5CgFa7X9ts7D4LkM'))
385+
386+let wx_waves_usdcwxg = getWxPool(Address(base58'3P3g3eipfG2NZKKQE8DZXt2E9tRJqii9jcX'))
387+
388+let wx_waves_usdtwxg = getWxPool(Address(base58'3PKMVZ7kQeaREajYi8Yc25Ro6mcNw5D6QSa'))
389+
390+let wx_wct_xtn = getWxPool(Address(base58'3P4bKahCwC2kPg8QcT8Pw5Br58hVgpziGsB'))
391+
392+let wx_west_waves = getWxPool(Address(base58'3PCA7wkovBpAGgm5e6rZMXyXY97jUwVENWe'))
393+
394+let wx_west_xtn = getWxPool(Address(base58'3PFxchXqKNjgP1CcbgFZjHyrEj9xMbSeLU3'))
395+
396+let wx_wx_usdtwxg = getWxPool(Address(base58'3PHiXGo7NTRoC2KqkMZ1y9LaA2QSrroGs8y'))
397+
398+let wx_wx_waves = getWxPool(Address(base58'3PFzaH2ghpwANHFgjeva83N1yxzErELx2eh'))
399+
400+let wx_wx_xtn = getWxPool(Address(base58'3PCENpEKe8atwELZ7oCSmcdEfcRuKTrUx99'))
401+
402+let routes = [$Tuple6(wx_waves_xtn, wx_wx_xtn, wx_wx_waves, false, true, false), $Tuple6(wx_wx_waves, wx_wx_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_btcwxg_xtn, wx_waves_btcwxg, false, true, true), $Tuple6(wx_waves_btcwxg, wx_btcwxg_xtn, wx_waves_xtn, false, false, true), $Tuple6(wx_waves_xtn, wx_ethwxg_xtn, wx_ethwxg_waves, false, true, false), $Tuple6(wx_ethwxg_waves, wx_ethwxg_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, swop_pwr_xtn, wx_pwr_waves, false, true, false), $Tuple6(wx_pwr_waves, swop_pwr_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_surf_waves, wx_surf_usdtwxg, wx_waves_usdtwxg, true, false, true), $Tuple6(wx_waves_usdtwxg, wx_surf_usdtwxg, wx_surf_waves, false, true, false), $Tuple6(wx_surf_waves, wx_surf_usdcwxg, wx_waves_usdcwxg, true, false, true), $Tuple6(wx_waves_usdcwxg, wx_surf_usdcwxg, wx_surf_waves, false, true, false), $Tuple6(wx_wx_waves, wx_wx_usdtwxg, wx_waves_usdtwxg, true, false, true), $Tuple6(wx_waves_usdtwxg, wx_wx_usdtwxg, wx_wx_waves, false, true, false), $Tuple6(wx_waves_xtn, wx_nsbt_xtn, wx_nsbt_waves, false, true, false), $Tuple6(wx_nsbt_waves, wx_nsbt_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_swaves_xtn, wx_swaves_waves, false, true, false), $Tuple6(wx_swaves_waves, wx_swaves_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_vires_xtn, wx_vires_waves, false, true, false), $Tuple6(wx_vires_waves, wx_vires_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_usdtppt_xtn, wx_waves_usdtppt, false, true, true), $Tuple6(wx_waves_usdtppt, wx_usdtppt_xtn, wx_waves_xtn, false, false, true), $Tuple6(wx_waves_usdtppt, wx_ethppt_usdtppt, wx_ethppt_waves, false, true, false), $Tuple6(wx_ethppt_waves, wx_ethppt_usdtppt, wx_waves_usdtppt, true, false, true)]
81403 
82404 @Callable(i)
83405 func s () = if ((i.caller != this))
10191341         }
10201342 
10211343 
1344+
1345+@Callable(i)
1346+func default () = if ((i.caller != this))
1347+    then throw("No touching")
1348+    else {
1349+        func accumFunction (accum,next) =         {
1350+            let estimation = estimateRoute(next._1, next._2, next._3, next._4, next._5, next._6)
1351+            $Tuple2((accum._1 :+ estimation._1), (accum._2 :+ estimation._2))
1352+            }
1353+
1354+        let fold = {
1355+            let $l = routes
1356+            let $s = size($l)
1357+            let $acc0 = $Tuple2(nil, nil)
1358+            func $f0_1 ($a,$i) =             if (($i >= $s))
1359+                then $a
1360+                else accumFunction($a, $l[$i])
1361+
1362+            func $f0_2 ($a,$i) =             if (($i >= $s))
1363+                then $a
1364+                else throw("List size exceeds 24")
1365+
1366+            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24)
1367+            }
1368+        let maxSwapProfit = max(fold._1)
1369+        if ((0 >= maxSwapProfit))
1370+            then throw("Estimate fail")
1371+            else {
1372+                let estimatedResult = fold._2[value(indexOf(fold._1, maxSwapProfit))]
1373+                let result1 = invokeSwap(estimatedResult[0])
1374+                if ((result1 == result1))
1375+                    then {
1376+                        let result2 = invokeSwap(estimatedResult[1])
1377+                        if ((result2 == result2))
1378+                            then {
1379+                                let result3 = invokeSwap(estimatedResult[2])
1380+                                if ((result3 == result3))
1381+                                    then {
1382+                                        let profit = (getBalance(InAsset) - inBalance)
1383+                                        let pureProfit = (profit - 1500000)
1384+                                        if ((0 >= pureProfit))
1385+                                            then throw("Execute fail")
1386+                                            else nil
1387+                                        }
1388+                                    else throw("Strict value is not equal to itself.")
1389+                                }
1390+                            else throw("Strict value is not equal to itself.")
1391+                        }
1392+                    else throw("Strict value is not equal to itself.")
1393+                }
1394+        }
1395+
1396+
10221397 @Verifier(tx)
10231398 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
10241399 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let TOKEN = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
55 
66 let fee_scale = 1000000
77 
88 let w1 = match getString(this, "w1") {
99     case r: String => 
1010         r
1111     case _ => 
1212         ""
1313 }
1414 
15+let w2 = match getString(this, "w2") {
16+    case r: String => 
17+        r
18+    case _ => 
19+        ""
20+}
21+
22+let USDN_ASSET_ID = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
23+
1524 let WX_SWAP_DAPP = Address(base58'3P68zNiufsu1viZpu1aY3cdahRRKcvV5N93')
1625 
1726 let assets_in = ["DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"]
18-
19-func getBalance (assetId) = match assetId {
20-    case b: ByteVector => 
21-        assetBalance(this, b)
22-    case _ => 
23-        wavesBalance(this).available
24-}
25-
2627 
2728 func getBase1 (data) = {
2829     let p_data = split_4C(data, "_")
2930     let a = p_data[0]
3031     let a2 = p_data[1]
3132     let assetIn = assets_in[value(parseInt(p_data[2]))]
3233     let amountIn = p_data[3]
3334     $Tuple4(a, a2, assetIn, amountIn)
3435     }
3536 
3637 
3738 func getBase2 (data) = {
3839     let p_data = split(data, "_")
3940     let p1 = p_data[0]
4041     let t = p_data[1]
4142     $Tuple2(p1, t)
4243     }
4344 
4445 
4546 func getAssetBytes (assetId) = if ((assetId == "WAVES"))
4647     then unit
4748     else fromBase58String(assetId)
4849 
4950 
5051 func swap_wx (p,asset,amount,a) = {
5152     let call = invoke(WX_SWAP_DAPP, "swap", [1, a, toString(this)], [AttachedPayment(getAssetBytes(asset), amount)])
5253     if ((call == call))
5354         then nil
5455         else throw("Strict value is not equal to itself.")
5556     }
5657 
5758 
5859 func swap_swop (p,asset,amount) = {
5960     let swap = invoke(Address(fromBase58String(p)), "exchange", [1], [AttachedPayment(getAssetBytes(asset), amount)])
6061     if ((swap == swap))
6162         then nil
6263         else throw("Strict value is not equal to itself.")
6364     }
6465 
6566 
6667 func swap_puzzle (p,asset,amount,assetOut) = {
6768     let swap = invoke(Address(fromBase58String(p)), "swap", [assetOut, 1], [AttachedPayment(getAssetBytes(asset), amount)])
6869     if ((swap == swap))
6970         then nil
7071         else throw("Strict value is not equal to itself.")
7172     }
7273 
7374 
7475 func ucheck (id) = match transactionHeightById(id) {
7576     case h: Int => 
7677         h
7778     case _ => 
7879         0
7980 }
8081 
82+
83+let Scale6 = 1000000
84+
85+let Scale6BigInt = toBigInt(Scale6)
86+
87+let Scale8 = 100000000
88+
89+let Scale8BigInt = toBigInt(Scale8)
90+
91+let ZeroBigInt = toBigInt(0)
92+
93+let SEP = "__"
94+
95+let InScale = 100000000
96+
97+let InDecimals = 8
98+
99+let InScaleBigInt = toBigInt(InScale)
100+
101+let InAsset = unit
102+
103+let InAssetStr = "WAVES"
104+
105+let wxSwapAddress = Address(base58'3P68zNiufsu1viZpu1aY3cdahRRKcvV5N93')
106+
107+let thisAddressStr = toString(this)
108+
109+func getIntOrZero (key) = valueOrElse(getInteger(key), 0)
110+
111+
112+func getBalance (asset) = if ((asset == unit))
113+    then wavesBalance(this).regular
114+    else assetBalance(this, value(asset))
115+
116+
117+func getAssetOrWaves (assetStr) = if ((assetStr == "WAVES"))
118+    then unit
119+    else fromBase58String(assetStr)
120+
121+
122+let inBalance = getBalance(InAsset)
123+
124+let inBalanceBigInt = toBigInt(inBalance)
125+
126+func getSwopPool (pool) = {
127+    let assetIdAStr = getStringValue(pool, "A_asset_id")
128+    let assetIdBStr = getStringValue(pool, "B_asset_id")
129+    let assetIdA = getAssetOrWaves(assetIdAStr)
130+    let assetIdB = getAssetOrWaves(assetIdBStr)
131+    let balanceA = getIntegerValue(pool, "A_asset_balance")
132+    let balanceB = getIntegerValue(pool, "B_asset_balance")
133+    let outFee = (Scale6BigInt - toBigInt(getIntegerValue(pool, "commission")))
134+    $Tuple9(toBigInt(balanceA), toBigInt(balanceB), assetIdA, assetIdB, assetIdAStr, assetIdBStr, Scale6BigInt, outFee, pool)
135+    }
136+
137+
138+func keyAdditionalBalance (assetId) = makeString(["%s%s", "stakedBalance", assetId], SEP)
139+
140+
141+func keyStakingAssetBalance (assetId) = makeString(["%s%s", "shareAssetBalance", assetId], SEP)
142+
143+
144+func getAdditionalBalanceOrZero (pool,assetId) = valueOrElse(getInteger(pool, keyAdditionalBalance(assetId)), 0)
145+
146+
147+func getStakingAssetBalanceOrZero (pool,assetId) = valueOrElse(getInteger(pool, keyStakingAssetBalance(assetId)), 0)
148+
149+
150+func getWxAccountBalance (pool,assetId) = {
151+    let balanceOnPool = if ((assetId == "WAVES"))
152+        then wavesBalance(pool).available
153+        else assetBalance(pool, fromBase58String(assetId))
154+    let totalBalance = ((balanceOnPool + getAdditionalBalanceOrZero(pool, assetId)) - getStakingAssetBalanceOrZero(pool, assetId))
155+    max([0, totalBalance])
156+    }
157+
158+
159+func getWxPool (pool) = {
160+    let assetIdAStr = getStringValue(pool, "%s__amountAsset")
161+    let assetIdBStr = getStringValue(pool, "%s__priceAsset")
162+    let assetIdA = getAssetOrWaves(assetIdAStr)
163+    let assetIdB = getAssetOrWaves(assetIdBStr)
164+    let balanceA = getWxAccountBalance(pool, assetIdAStr)
165+    let balanceB = getWxAccountBalance(pool, assetIdBStr)
166+    let protocolFee = getIntegerValue(wxSwapAddress, "%s__protocolFee")
167+    let poolFee = getIntegerValue(wxSwapAddress, "%s__poolFee")
168+    let inFee = (Scale6BigInt - fraction(toBigInt((protocolFee + poolFee)), Scale6BigInt, Scale8BigInt))
169+    $Tuple9(toBigInt(balanceA), toBigInt(balanceB), assetIdA, assetIdB, assetIdAStr, assetIdBStr, inFee, Scale6BigInt, wxSwapAddress)
170+    }
171+
172+
173+func calcSwap (pmtAmount,tokenFrom,tokenTo,inFee,outFee) = {
174+    let cleanAmount = fraction(pmtAmount, inFee, Scale6BigInt)
175+    let amountWithoutFee = fraction(tokenTo, cleanAmount, (cleanAmount + tokenFrom))
176+    let amountWithFee = fraction(amountWithoutFee, outFee, Scale6BigInt)
177+    amountWithFee
178+    }
179+
180+
181+func estimateSwap (poolInfo,inAsset,inAmount) = {
182+    let routeArgs = if ((inAsset == poolInfo._3))
183+        then $Tuple3(poolInfo._4, poolInfo._6, calcSwap(inAmount, poolInfo._1, poolInfo._2, poolInfo._7, poolInfo._8))
184+        else $Tuple3(poolInfo._3, poolInfo._5, calcSwap(inAmount, poolInfo._2, poolInfo._1, poolInfo._7, poolInfo._8))
185+    let dappArgs = if ((poolInfo._9 == wxSwapAddress))
186+        then $Tuple2("swap", [0, routeArgs._2, thisAddressStr])
187+        else $Tuple2("exchange", [1])
188+    $Tuple4(routeArgs._1, routeArgs._3, dappArgs._1, dappArgs._2)
189+    }
190+
191+
192+func estimateRoute (pool1,pool2,pool3,pool1Reverse,pool2Reverse,pool3Reverse) = {
193+    let a12 = if (pool1Reverse)
194+        then pool1._2
195+        else pool1._1
196+    let a21 = if (pool1Reverse)
197+        then pool1._1
198+        else pool1._2
199+    let a23 = if (pool2Reverse)
200+        then pool2._2
201+        else pool2._1
202+    let a32 = if (pool2Reverse)
203+        then pool2._1
204+        else pool2._2
205+    let a31 = if (pool3Reverse)
206+        then pool3._2
207+        else pool3._1
208+    let a13 = if (pool3Reverse)
209+        then pool3._1
210+        else pool3._2
211+    let aaDenominator = (a23 + fraction(fraction(a21, pool1._8, Scale6BigInt), pool2._7, Scale6BigInt))
212+    let aa13 = fraction(a12, a23, aaDenominator)
213+    let aa31 = fraction(fraction(fraction(a21, a32, aaDenominator), pool2._7, Scale6BigInt), pool2._8, Scale6BigInt)
214+    let aDenominator = (a31 + fraction(fraction(aa31, pool1._7, Scale6BigInt), pool1._8, Scale6BigInt))
215+    let a = fraction(aa13, a31, aDenominator)
216+    let aa = fraction(fraction(fraction(aa31, a13, aDenominator), pool3._7, Scale6BigInt), pool3._8, Scale6BigInt)
217+    let delta = fraction((sqrtBigInt(fraction(fraction(fraction(aa, a, InScaleBigInt), pool1._7, Scale6BigInt), pool1._8, Scale6BigInt), InDecimals, InDecimals, CEILING) - a), Scale6BigInt, pool1._7)
218+    if ((ZeroBigInt >= delta))
219+        then $Tuple2(0, nil)
220+        else {
221+            let input = if ((delta > inBalanceBigInt))
222+                then inBalanceBigInt
223+                else delta
224+            let swap1 = estimateSwap(pool1, InAsset, input)
225+            let swap2 = estimateSwap(pool2, swap1._1, swap1._2)
226+            let swap3 = estimateSwap(pool3, swap2._1, swap2._2)
227+            $Tuple2(toInt((swap3._2 - input)), [$Tuple5(pool1._9, swap1._3, swap1._4, InAsset, toInt(input)), $Tuple5(pool2._9, swap2._3, swap2._4, swap1._1, toInt(swap1._2)), $Tuple5(pool3._9, swap3._3, swap3._4, swap2._1, toInt(swap2._2))])
228+            }
229+    }
230+
231+
232+func invokeSwap (args) = {
233+    let currentBalance = getBalance(args._4)
234+    let trimmedAmount = if ((args._5 > currentBalance))
235+        then currentBalance
236+        else args._5
237+    let resultAmount = if ((args._4 == InAsset))
238+        then trimmedAmount
239+        else if ((currentBalance > args._5))
240+            then currentBalance
241+            else trimmedAmount
242+    invoke(args._1, args._2, args._3, [AttachedPayment(args._4, resultAmount)])
243+    }
244+
245+
246+let swop_btcwxg_xtn = getSwopPool(Address(base58'3PACj2DLTw3uUhsUmT98zHU5M4hPufbHKav'))
247+
248+let swop_crvwxg_xtn = getSwopPool(Address(base58'3P9o2H6G5d2xXBTfBEwjzHc16RLSZLFLQjp'))
249+
250+let swop_egg_waves = getSwopPool(Address(base58'3PNVFWopwCD9CgGXkpYWEY94oQ5XCAEXBmQ'))
251+
252+let swop_ethwxg_xtn = getSwopPool(Address(base58'3PNEC4YKqZiMMytFrYRVtpW2ujvi3aGXRPm'))
253+
254+let swop_ethppt_waves = getSwopPool(Address(base58'3P3KU81iteCQxKb8u15yEPcABknLEcCvGyr'))
255+
256+let swop_enno_xtn = getSwopPool(Address(base58'3P8bovWtkLFVToB8LxP8AZLoWVwC8rDZLQQ'))
257+
258+let swop_ltcwxg_xtn = getSwopPool(Address(base58'3P32Rjpo9YHoHaorLSxvnV6CkKFXyfDCkJh'))
259+
260+let swop_nsbt_xtn = getSwopPool(Address(base58'3P2V63Xd6BviDkeMzxhUw2SJyojByRz8a8m'))
261+
262+let swop_pluto_xtn = getSwopPool(Address(base58'3PDSXwwA2xAtmxeo2bebDP3AA5ynZ2Krgnw'))
263+
264+let swop_pwr_xtn = getSwopPool(Address(base58'3P88KDKWHNKNdbZxe8FfAJP8coAhvfDtuzV'))
265+
266+let swop_puzzle_xtn = getSwopPool(Address(base58'3PBHyEwmERR1CEkrTNbPj2bgyisTfPRqfee'))
267+
268+let swop_puzzle_waves = getSwopPool(Address(base58'3PRFKemXs4rAJYGPccNtP63Kw2UzwEdH7sZ'))
269+
270+let swop_race_egg = getSwopPool(Address(base58'3P3Z8Gn665CJr14bTLv4d5USDBUQCTeeCaT'))
271+
272+let swop_sign_xtn = getSwopPool(Address(base58'3P4Ftyud3U3xnuR8sTc1RvV4iQD62TcKndy'))
273+
274+let swop_surf_xtn = getSwopPool(Address(base58'3PLp9KrdrbWAvSFHGJVEaszUubquz3M6mfe'))
275+
276+let swop_swop_xtn = getSwopPool(Address(base58'3P27S9V36kw2McjWRZ37AxTx8iwkd7HXw6W'))
277+
278+let swop_swop_waves = getSwopPool(Address(base58'3PH8Np6jwuoikvkHL2qmdpFEHBR4UV5vwSq'))
279+
280+let swop_tsn_xtn = getSwopPool(Address(base58'3PCwvns2dnmobD6Z4cR86v98s7LgMZYygEy'))
281+
282+let swop_vires_xtn = getSwopPool(Address(base58'3PJ48P3p2wvWUjgQaQiZ2cFbr8qmxMokBGd'))
283+
284+let swop_vvusdnlp_xtn = getSwopPool(Address(base58'3PCkJuWHu1QJLHvcdUegYczfNVohS6c1A6o'))
285+
286+let swop_usdcwxg_usdtwxg = getSwopPool(Address(base58'3PJgkN4gy6b8qpA86otcJ2KDTbL8ay2n91s'))
287+
288+let swop_waves_btcwxg = getSwopPool(Address(base58'3P8FVZgAJUAq32UEZtTw84qS4zLqEREiEiP'))
289+
290+let swop_waves_xtn = getSwopPool(Address(base58'3PHaNgomBkrvEL2QnuJarQVJa71wjw9qiqG'))
291+
292+let swop_west_east = getSwopPool(Address(base58'3PHTDdjz8Kb5JcAkhzfR57MCUYoe73pyxxK'))
293+
294+let swop_waves_eurn = getSwopPool(Address(base58'3PK7Xe5BiedRyxHLuMQx5ey9riUQqvUths2'))
295+
296+let swop_waves_usdcppt = getSwopPool(Address(base58'3PESG2RvmPdDrMCbCVvzJvqxDR9d2HcAE2z'))
297+
298+let swop_waves_usdtppt = getSwopPool(Address(base58'3P2M9btqYdpENh1SkaHFDdc8XSjXHNiAXF5'))
299+
300+let swop_wct_xtn = getSwopPool(Address(base58'3PMDFxmG9uXAbuQgiNogZCBQASvCHt1Mdar'))
301+
302+let swop_west_xtn = getSwopPool(Address(base58'3P6DLdJTP2EySq9MFdJu6beUevrQd2sVVBh'))
303+
304+let swop_wx_xtn = getSwopPool(Address(base58'3PKi4G3VX2k42ZSmNNrmvgdDH7JzRaUhY7R'))
305+
306+let swop_xtn_usdtwxg = getSwopPool(Address(base58'3PAunb4Dadc9rQM2VJNQBgQV3vrgF9z8Evq'))
307+
308+let wx_bnbppt_waves = getWxPool(Address(base58'3PErdCQg2f8WYGG7DzSiH5FBosdnPHE6cND'))
309+
310+let wx_bnbwxg_xtn = getWxPool(Address(base58'3P8NCvcipinDQVQZujpczBdvG7FL5EvTqLM'))
311+
312+let wx_btcwxg_xtn = getWxPool(Address(base58'3PCBWDTA6jrFswd7gQgaE3Xk7gLM5RKofvp'))
313+
314+let wx_crv_xtn = getWxPool(Address(base58'3PHBmNjbaT8Re837JUfPGXeaW8NKfBQPr1u'))
315+
316+let wx_east_xtn = getWxPool(Address(base58'3PHxdxsgxNwEjVRt45sjeUfNZZ8uHzYVpvH'))
317+
318+let wx_egg_waves = getWxPool(Address(base58'3PJkUhnAHMaBTjyc7FkBfHantNUy871kBBW'))
319+
320+let wx_egg_xtn = getWxPool(Address(base58'3P3Y38zymCHoTM6qcE9JcEA8rhaGTQbVMgu'))
321+
322+let wx_enno_xtn = getWxPool(Address(base58'3P2H4iQAfxQCJaFCNgRLmKkLvv2yDhV93QC'))
323+
324+let wx_ethppt_waves = getWxPool(Address(base58'3P2yiVnK48evTLr8MAZWavpE4WA4fw1weQg'))
325+
326+let wx_ethppt_usdtppt = getWxPool(Address(base58'3PATKQATPmnxLd5DjXg8FmbXXbKpA1BVAvS'))
327+
328+let wx_ethwxg_waves = getWxPool(Address(base58'3P3XGTN6s292g9iwYhs3TEqJqHiffQYojuE'))
329+
330+let wx_ethwxg_xtn = getWxPool(Address(base58'3PEMqetsaJDbYMw1XGovmE37FB8VUhGnX9A'))
331+
332+let wx_eurn_xtn = getWxPool(Address(base58'3P879DU3ycr2XWorD7rR5gSpn1CpYgHjgFT'))
333+
334+let wx_ltcwxg_xtn = getWxPool(Address(base58'3P94wvu5gA7VhjPgAB3twaeqdwHCwNK2vsn'))
335+
336+let wx_nsbt_waves = getWxPool(Address(base58'3PPR4zVfWP4w4rshP541aiFtPNQN2sNJwrY'))
337+
338+let wx_nsbt_xtn = getWxPool(Address(base58'3P97XQCT9VYMXBxasVpDsE7eZfQ6cR9eS9n'))
339+
340+let wx_pluto_waves = getWxPool(Address(base58'3P6ZipK8ydb4qHmufCquh98g9KW6EwaeJfk'))
341+
342+let wx_pluto_xtn = getWxPool(Address(base58'3PEkD5LuHGWhUfgBW1owZFxVydYoWjV6Jia'))
343+
344+let wx_puzzle_waves = getWxPool(Address(base58'3PQaYm4pbRVrNTTnL8pDJZTxhcmD4jRskrz'))
345+
346+let wx_puzzle_xtn = getWxPool(Address(base58'3P615yXeQ9Qu4qBM1QGimGzixyMS5W4Ktug'))
347+
348+let wx_pwr_waves = getWxPool(Address(base58'3PDi7Qq8pLQYvtKyTfQuqqPUWyhoYbU957t'))
349+
350+let wx_race_xtn = getWxPool(Address(base58'3P2nHbqMt7hiYKQjYLT3AEDteS4SYGeHTuc'))
351+
352+let wx_sign_xtn = getWxPool(Address(base58'3P6UuvAt9RFuVznvjAQ7c2RrU25iU917WTN'))
353+
354+let wx_surf_waves = getWxPool(Address(base58'3PNnCngfvAzyvAQ1cEudZ3o6o3tFktsBVz5'))
355+
356+let wx_surf_usdcwxg = getWxPool(Address(base58'3PBfTdcoKmMNxZcjP8eTokbLFqYTUdoNKWL'))
357+
358+let wx_surf_usdtwxg = getWxPool(Address(base58'3PM6YyJauiFTZzVLuRcCkDwWBvWTvPYo1ZM'))
359+
360+let wx_swaves_waves = getWxPool(Address(base58'3PDVaJDqCadWeBugf768XeKiXtCCLUrYMge'))
361+
362+let wx_swaves_xtn = getWxPool(Address(base58'3PEmxUzcCbsAcw6Q3VNLTWdd8bjc8KBUEDz'))
363+
364+let wx_swop_waves = getWxPool(Address(base58'3PA8nK44sopUpXNcCRTpPSH2F7yjvxzx5cw'))
365+
366+let wx_swop_xtn = getWxPool(Address(base58'3PCApn7kL3UMdCVYA2Ln2UcQvfnkFRL1qDC'))
367+
368+let wx_usdtppt_xtn = getWxPool(Address(base58'3P5kfoYW7jPa9zYoTkN6Z6z8xtw8JGhymYB'))
369+
370+let wx_tsn_xtn = getWxPool(Address(base58'3PH832eKnw67PFvJfUg9Knz6BHM87QvjMeL'))
371+
372+let wx_vires_waves = getWxPool(Address(base58'3P7Z7X5kKXN4TpZ2SmqP2xyLGuotAqht1pU'))
373+
374+let wx_vires_xtn = getWxPool(Address(base58'3P5HjPowgipiVB3UvXphDiPvKs424WC9xQw'))
375+
376+let wx_vvusdnlp_xtn = getWxPool(Address(base58'3P9UJxhsqj1UkqPDtM16yi9aGE26V5tdH6i'))
377+
378+let wx_waves_btcwxg = getWxPool(Address(base58'3PPQDcvXuwVToC2QNWzPwxmLxLzMw9Eoe8C'))
379+
380+let wx_waves_busdwxg = getWxPool(Address(base58'3P9vSwu2eLLmyAi8BdEoZvTwsxSWjsAh8Jm'))
381+
382+let wx_waves_xtn = getWxPool(Address(base58'3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g'))
383+
384+let wx_waves_usdtppt = getWxPool(Address(base58'3PPeWowdyQLKwW9AExN5CgFa7X9ts7D4LkM'))
385+
386+let wx_waves_usdcwxg = getWxPool(Address(base58'3P3g3eipfG2NZKKQE8DZXt2E9tRJqii9jcX'))
387+
388+let wx_waves_usdtwxg = getWxPool(Address(base58'3PKMVZ7kQeaREajYi8Yc25Ro6mcNw5D6QSa'))
389+
390+let wx_wct_xtn = getWxPool(Address(base58'3P4bKahCwC2kPg8QcT8Pw5Br58hVgpziGsB'))
391+
392+let wx_west_waves = getWxPool(Address(base58'3PCA7wkovBpAGgm5e6rZMXyXY97jUwVENWe'))
393+
394+let wx_west_xtn = getWxPool(Address(base58'3PFxchXqKNjgP1CcbgFZjHyrEj9xMbSeLU3'))
395+
396+let wx_wx_usdtwxg = getWxPool(Address(base58'3PHiXGo7NTRoC2KqkMZ1y9LaA2QSrroGs8y'))
397+
398+let wx_wx_waves = getWxPool(Address(base58'3PFzaH2ghpwANHFgjeva83N1yxzErELx2eh'))
399+
400+let wx_wx_xtn = getWxPool(Address(base58'3PCENpEKe8atwELZ7oCSmcdEfcRuKTrUx99'))
401+
402+let routes = [$Tuple6(wx_waves_xtn, wx_wx_xtn, wx_wx_waves, false, true, false), $Tuple6(wx_wx_waves, wx_wx_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_btcwxg_xtn, wx_waves_btcwxg, false, true, true), $Tuple6(wx_waves_btcwxg, wx_btcwxg_xtn, wx_waves_xtn, false, false, true), $Tuple6(wx_waves_xtn, wx_ethwxg_xtn, wx_ethwxg_waves, false, true, false), $Tuple6(wx_ethwxg_waves, wx_ethwxg_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, swop_pwr_xtn, wx_pwr_waves, false, true, false), $Tuple6(wx_pwr_waves, swop_pwr_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_surf_waves, wx_surf_usdtwxg, wx_waves_usdtwxg, true, false, true), $Tuple6(wx_waves_usdtwxg, wx_surf_usdtwxg, wx_surf_waves, false, true, false), $Tuple6(wx_surf_waves, wx_surf_usdcwxg, wx_waves_usdcwxg, true, false, true), $Tuple6(wx_waves_usdcwxg, wx_surf_usdcwxg, wx_surf_waves, false, true, false), $Tuple6(wx_wx_waves, wx_wx_usdtwxg, wx_waves_usdtwxg, true, false, true), $Tuple6(wx_waves_usdtwxg, wx_wx_usdtwxg, wx_wx_waves, false, true, false), $Tuple6(wx_waves_xtn, wx_nsbt_xtn, wx_nsbt_waves, false, true, false), $Tuple6(wx_nsbt_waves, wx_nsbt_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_swaves_xtn, wx_swaves_waves, false, true, false), $Tuple6(wx_swaves_waves, wx_swaves_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_vires_xtn, wx_vires_waves, false, true, false), $Tuple6(wx_vires_waves, wx_vires_xtn, wx_waves_xtn, true, false, true), $Tuple6(wx_waves_xtn, wx_usdtppt_xtn, wx_waves_usdtppt, false, true, true), $Tuple6(wx_waves_usdtppt, wx_usdtppt_xtn, wx_waves_xtn, false, false, true), $Tuple6(wx_waves_usdtppt, wx_ethppt_usdtppt, wx_ethppt_waves, false, true, false), $Tuple6(wx_ethppt_waves, wx_ethppt_usdtppt, wx_waves_usdtppt, true, false, true)]
81403 
82404 @Callable(i)
83405 func s () = if ((i.caller != this))
84406     then throw("self")
85407     else [StringEntry("current", toBase58String(i.transactionId))]
86408 
87409 
88410 
89411 @Callable(i)
90412 func e () = if ((i.caller != this))
91413     then throw("self")
92414     else [DeleteEntry("current")]
93415 
94416 
95417 
96418 @Callable(i)
97419 func sf (fee) = if ((i.caller != this))
98420     then throw("self")
99421     else [IntegerEntry("fee", fee)]
100422 
101423 
102424 
103425 @Callable(i)
104426 func d () = if (!(containsElement(split_4C(w1, "|"), toBase58String(i.caller.bytes))))
105427     then throw("wl")
106428     else {
107429         let current =         match getString(this, "current") {
108430             case ret: String => 
109431                 throw("current")
110432             case _ => 
111433                 ""
112434         }
113435         let pmt = if ((size(i.payments) == 1))
114436             then i.payments[0]
115437             else throw("1 payment expected")
116438         if ((pmt.assetId != TOKEN))
117439             then throw("wrong token")
118440             else {
119441                 let caller = toBase58String(i.caller.bytes)
120442                 let currentAmount =                 match getInteger(this, ("deposit_" + caller)) {
121443                     case a: Int => 
122444                         a
123445                     case _ => 
124446                         0
125447                 }
126448                 let totalDeposit =                 match getInteger(this, "total_deposit") {
127449                     case a: Int => 
128450                         a
129451                     case _ => 
130452                         0
131453                 }
132454                 let newAmount = (currentAmount + pmt.amount)
133455 [IntegerEntry(("deposit_" + caller), newAmount), IntegerEntry("total_deposit", (totalDeposit + pmt.amount))]
134456                 }
135457         }
136458 
137459 
138460 
139461 @Callable(i)
140462 func w (amnt) = if ((this != i.caller))
141463     then throw("wl")
142464     else {
143465         let current =         match getString(this, "current") {
144466             case ret: String => 
145467                 throw("current")
146468             case _ => 
147469                 ""
148470         }
149471         let caller = toBase58String(i.caller.bytes)
150472         let currentAmount =         match getInteger(this, ("deposit_" + caller)) {
151473             case a: Int => 
152474                 a
153475             case _ => 
154476                 0
155477         }
156478         if ((amnt > currentAmount))
157479             then throw("w > d")
158480             else {
159481                 let newAmount = (currentAmount - amnt)
160482                 if ((0 > newAmount))
161483                     then throw("underflow")
162484                     else {
163485                         let totalDeposit =                         match getInteger(this, "total_deposit") {
164486                             case a: Int => 
165487                                 a
166488                             case _ => 
167489                                 0
168490                         }
169491 [IntegerEntry(("deposit_" + caller), newAmount), IntegerEntry("total_deposit", (totalDeposit - amnt)), ScriptTransfer(i.caller, amnt, TOKEN)]
170492                         }
171493                 }
172494         }
173495 
174496 
175497 
176498 @Callable(i)
177499 func x (amnt,a,f,data) = if ((this != i.caller))
178500     then throw("wl")
179501     else {
180502         let st = assetBalance(this, TOKEN)
181503         if ((st == st))
182504             then {
183505                 let ii = reentrantInvoke(addressFromStringValue(a), f, [data], [AttachedPayment(TOKEN, amnt)])
184506                 if ((ii == ii))
185507                     then {
186508                         let et = assetBalance(this, TOKEN)
187509                         if ((et == et))
188510                             then {
189511                                 let fee_r =                                 match getInteger(this, "fee") {
190512                                     case ret: Int => 
191513                                         ret
192514                                     case _ => 
193515                                         0
194516                                 }
195517                                 let fee = fraction(st, fee_r, fee_scale, DOWN)
196518                                 if (((st + fee) > et))
197519                                     then throw(("! " + toString((st + fee))))
198520                                     else nil
199521                                 }
200522                             else throw("Strict value is not equal to itself.")
201523                         }
202524                     else throw("Strict value is not equal to itself.")
203525                 }
204526             else throw("Strict value is not equal to itself.")
205527         }
206528 
207529 
208530 
209531 @Callable(i)
210532 func arbWaves (path,amount) = {
211533     let poolAddress = "3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g"
212534     let pool = addressFromStringValue(poolAddress)
213535     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
214536     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
215537     let usdnWavesLPTokenAssetId = base58'7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1'
216538     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
217539     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
218540     if ((i.caller != this))
219541         then throw("you are not allowed to arb!")
220542         else {
221543             let initialWavesBalance = wavesBalance(this).available
222544             if ((initialWavesBalance == initialWavesBalance))
223545                 then {
224546                     let initialAmount = assetBalance(this, usdnAssetId)
225547                     if ((initialAmount == initialAmount))
226548                         then {
227549                             let buyOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(usdnAssetId, (amount * 1000000))])
228550                             if ((buyOnPuzzle == buyOnPuzzle))
229551                                 then {
230552                                     let wavesTokenBalance = (wavesBalance(this).available - initialWavesBalance)
231553                                     if ((wavesTokenBalance == wavesTokenBalance))
232554                                         then {
233555                                             let putTheTokenInThePool = invoke(pool, "putOneTkn", [1, false], [AttachedPayment(unit, wavesTokenBalance)])
234556                                             if ((putTheTokenInThePool == putTheTokenInThePool))
235557                                                 then {
236558                                                     let lpTokenBalance = assetBalance(this, usdnWavesLPTokenAssetId)
237559                                                     if ((lpTokenBalance == lpTokenBalance))
238560                                                         then {
239561                                                             let sellPoolToken = invoke(pool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(usdnWavesLPTokenAssetId, lpTokenBalance)])
240562                                                             if ((sellPoolToken == sellPoolToken))
241563                                                                 then {
242564                                                                     let finalAmount = assetBalance(this, usdnAssetId)
243565                                                                     if ((finalAmount == finalAmount))
244566                                                                         then if ((initialAmount >= finalAmount))
245567                                                                             then throw("arb not successful!")
246568                                                                             else nil
247569                                                                         else throw("Strict value is not equal to itself.")
248570                                                                     }
249571                                                                 else throw("Strict value is not equal to itself.")
250572                                                             }
251573                                                         else throw("Strict value is not equal to itself.")
252574                                                     }
253575                                                 else throw("Strict value is not equal to itself.")
254576                                             }
255577                                         else throw("Strict value is not equal to itself.")
256578                                     }
257579                                 else throw("Strict value is not equal to itself.")
258580                             }
259581                         else throw("Strict value is not equal to itself.")
260582                     }
261583                 else throw("Strict value is not equal to itself.")
262584             }
263585     }
264586 
265587 
266588 
267589 @Callable(i)
268590 func arbWaves2 (path,amount) = {
269591     let poolAddress = "3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g"
270592     let pool = addressFromStringValue(poolAddress)
271593     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
272594     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
273595     let usdnWavesLPTokenAssetId = base58'7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1'
274596     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
275597     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
276598     if ((i.caller != this))
277599         then throw("you are not allowed to arb!")
278600         else {
279601             let initialWavesBalance = wavesBalance(this).available
280602             if ((initialWavesBalance == initialWavesBalance))
281603                 then {
282604                     let initialAmount = assetBalance(this, usdnAssetId)
283605                     if ((initialAmount == initialAmount))
284606                         then {
285607                             let putTheTokenInThePool = invoke(pool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (amount * 1000000))])
286608                             if ((putTheTokenInThePool == putTheTokenInThePool))
287609                                 then {
288610                                     let lpTokenBalance = assetBalance(this, usdnWavesLPTokenAssetId)
289611                                     if ((lpTokenBalance == lpTokenBalance))
290612                                         then {
291613                                             let sellPoolToken = invoke(pool, "getOneTkn", ["WAVES", 1], [AttachedPayment(usdnWavesLPTokenAssetId, lpTokenBalance)])
292614                                             if ((sellPoolToken == sellPoolToken))
293615                                                 then {
294616                                                     let wavesTokenBalance = (wavesBalance(this).available - initialWavesBalance)
295617                                                     if ((wavesTokenBalance == wavesTokenBalance))
296618                                                         then {
297619                                                             let sellOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(unit, wavesTokenBalance)])
298620                                                             if ((sellOnPuzzle == sellOnPuzzle))
299621                                                                 then {
300622                                                                     let finalAmount = assetBalance(this, usdnAssetId)
301623                                                                     if ((finalAmount == finalAmount))
302624                                                                         then if ((initialAmount >= finalAmount))
303625                                                                             then throw("arb not successful!")
304626                                                                             else nil
305627                                                                         else throw("Strict value is not equal to itself.")
306628                                                                     }
307629                                                                 else throw("Strict value is not equal to itself.")
308630                                                             }
309631                                                         else throw("Strict value is not equal to itself.")
310632                                                     }
311633                                                 else throw("Strict value is not equal to itself.")
312634                                             }
313635                                         else throw("Strict value is not equal to itself.")
314636                                     }
315637                                 else throw("Strict value is not equal to itself.")
316638                             }
317639                         else throw("Strict value is not equal to itself.")
318640                     }
319641                 else throw("Strict value is not equal to itself.")
320642             }
321643     }
322644 
323645 
324646 
325647 @Callable(i)
326648 func arbUSDC (path,amount) = {
327649     let poolAddress = "3PC3HtupBxBmy4WtZf1Tym1vrxg9MwbZRK1"
328650     let pool = addressFromStringValue(poolAddress)
329651     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
330652     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
331653     let usdcAssetIdString = "6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ"
332654     let usdcAssetId = base58'6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ'
333655     let usdnUsdcLPTokenAssetId = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
334656     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
335657     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
336658     if ((i.caller != this))
337659         then throw("you are not allowed to arb!")
338660         else {
339661             let initialAmount = assetBalance(this, usdnAssetId)
340662             if ((initialAmount == initialAmount))
341663                 then {
342664                     let initialAmountUSDC = assetBalance(this, usdcAssetId)
343665                     if ((initialAmountUSDC == initialAmountUSDC))
344666                         then {
345667                             let buyOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(usdnAssetId, (amount * 1000000))])
346668                             if ((buyOnPuzzle == buyOnPuzzle))
347669                                 then {
348670                                     let usdcTokenBalance = (assetBalance(this, usdcAssetId) - initialAmountUSDC)
349671                                     if ((usdcTokenBalance == usdcTokenBalance))
350672                                         then {
351673                                             let putTheTokenInThePool = invoke(pool, "putOneTknV2", [1, false], [AttachedPayment(usdcAssetId, usdcTokenBalance)])
352674                                             if ((putTheTokenInThePool == putTheTokenInThePool))
353675                                                 then {
354676                                                     let lpTokenBalance = assetBalance(this, usdnUsdcLPTokenAssetId)
355677                                                     if ((lpTokenBalance == lpTokenBalance))
356678                                                         then {
357679                                                             let sellPoolToken = invoke(pool, "getOneTknV2", [usdnAssetIdString, 1], [AttachedPayment(usdnUsdcLPTokenAssetId, lpTokenBalance)])
358680                                                             if ((sellPoolToken == sellPoolToken))
359681                                                                 then {
360682                                                                     let finalAmount = assetBalance(this, usdnAssetId)
361683                                                                     if ((finalAmount == finalAmount))
362684                                                                         then if ((initialAmount >= finalAmount))
363685                                                                             then throw("arb not successful!")
364686                                                                             else nil
365687                                                                         else throw("Strict value is not equal to itself.")
366688                                                                     }
367689                                                                 else throw("Strict value is not equal to itself.")
368690                                                             }
369691                                                         else throw("Strict value is not equal to itself.")
370692                                                     }
371693                                                 else throw("Strict value is not equal to itself.")
372694                                             }
373695                                         else throw("Strict value is not equal to itself.")
374696                                     }
375697                                 else throw("Strict value is not equal to itself.")
376698                             }
377699                         else throw("Strict value is not equal to itself.")
378700                     }
379701                 else throw("Strict value is not equal to itself.")
380702             }
381703     }
382704 
383705 
384706 
385707 @Callable(i)
386708 func arbUSDC2 (path,amount) = {
387709     let poolAddress = "3PC3HtupBxBmy4WtZf1Tym1vrxg9MwbZRK1"
388710     let pool = addressFromStringValue(poolAddress)
389711     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
390712     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
391713     let usdcAssetIdString = "6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ"
392714     let usdcAssetId = base58'6XtHjpXbs9RRJP2Sr9GUyVqzACcby9TkThHXnjVC5CDJ'
393715     let usdnUsdcLPTokenAssetId = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
394716     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
395717     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
396718     if ((i.caller != this))
397719         then throw("you are not allowed to arb!")
398720         else {
399721             let initialAmount = assetBalance(this, usdnAssetId)
400722             if ((initialAmount == initialAmount))
401723                 then {
402724                     let initialAmountUSDC = assetBalance(this, usdcAssetId)
403725                     if ((initialAmountUSDC == initialAmountUSDC))
404726                         then {
405727                             let putTheTokenInThePool = invoke(pool, "putOneTknV2", [1, false], [AttachedPayment(usdnAssetId, (amount * 1000000))])
406728                             if ((putTheTokenInThePool == putTheTokenInThePool))
407729                                 then {
408730                                     let lpTokenBalance = assetBalance(this, usdnUsdcLPTokenAssetId)
409731                                     if ((lpTokenBalance == lpTokenBalance))
410732                                         then {
411733                                             let sellPoolToken = invoke(pool, "getOneTknV2", [usdcAssetIdString, 1], [AttachedPayment(usdnUsdcLPTokenAssetId, lpTokenBalance)])
412734                                             if ((sellPoolToken == sellPoolToken))
413735                                                 then {
414736                                                     let usdcTokenBalance = (assetBalance(this, usdcAssetId) - initialAmountUSDC)
415737                                                     if ((usdcTokenBalance == usdcTokenBalance))
416738                                                         then {
417739                                                             let sellOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(usdcAssetId, usdcTokenBalance)])
418740                                                             if ((sellOnPuzzle == sellOnPuzzle))
419741                                                                 then {
420742                                                                     let finalAmount = assetBalance(this, usdnAssetId)
421743                                                                     if ((finalAmount == finalAmount))
422744                                                                         then if ((initialAmount >= finalAmount))
423745                                                                             then throw("arb not successful!")
424746                                                                             else nil
425747                                                                         else throw("Strict value is not equal to itself.")
426748                                                                     }
427749                                                                 else throw("Strict value is not equal to itself.")
428750                                                             }
429751                                                         else throw("Strict value is not equal to itself.")
430752                                                     }
431753                                                 else throw("Strict value is not equal to itself.")
432754                                             }
433755                                         else throw("Strict value is not equal to itself.")
434756                                     }
435757                                 else throw("Strict value is not equal to itself.")
436758                             }
437759                         else throw("Strict value is not equal to itself.")
438760                     }
439761                 else throw("Strict value is not equal to itself.")
440762             }
441763     }
442764 
443765 
444766 
445767 @Callable(i)
446768 func arbUSDT (path,amount) = {
447769     let poolAddress = "3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz"
448770     let pool = addressFromStringValue(poolAddress)
449771     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
450772     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
451773     let usdtAssetIdString = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
452774     let usdtAssetId = base58'34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ'
453775     let usdnUsdtLPTokenAssetId = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
454776     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
455777     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
456778     if ((i.caller != this))
457779         then throw("you are not allowed to arb!")
458780         else {
459781             let initialAmount = assetBalance(this, usdnAssetId)
460782             if ((initialAmount == initialAmount))
461783                 then {
462784                     let initialAmountUSDT = assetBalance(this, usdtAssetId)
463785                     if ((initialAmountUSDT == initialAmountUSDT))
464786                         then {
465787                             let buyOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(usdnAssetId, (amount * 1000000))])
466788                             if ((buyOnPuzzle == buyOnPuzzle))
467789                                 then {
468790                                     let usdtTokenBalance = (assetBalance(this, usdtAssetId) - initialAmountUSDT)
469791                                     if ((usdtTokenBalance == usdtTokenBalance))
470792                                         then {
471793                                             let putTheTokenInThePool = invoke(pool, "putOneTknV2", [1, false], [AttachedPayment(usdtAssetId, usdtTokenBalance)])
472794                                             if ((putTheTokenInThePool == putTheTokenInThePool))
473795                                                 then {
474796                                                     let lpTokenBalance = assetBalance(this, usdnUsdtLPTokenAssetId)
475797                                                     if ((lpTokenBalance == lpTokenBalance))
476798                                                         then {
477799                                                             let sellPoolToken = invoke(pool, "getOneTknV2", [usdnAssetIdString, 1], [AttachedPayment(usdnUsdtLPTokenAssetId, lpTokenBalance)])
478800                                                             if ((sellPoolToken == sellPoolToken))
479801                                                                 then {
480802                                                                     let finalAmount = assetBalance(this, usdnAssetId)
481803                                                                     if ((finalAmount == finalAmount))
482804                                                                         then if ((initialAmount >= finalAmount))
483805                                                                             then throw("arb not successful!")
484806                                                                             else nil
485807                                                                         else throw("Strict value is not equal to itself.")
486808                                                                     }
487809                                                                 else throw("Strict value is not equal to itself.")
488810                                                             }
489811                                                         else throw("Strict value is not equal to itself.")
490812                                                     }
491813                                                 else throw("Strict value is not equal to itself.")
492814                                             }
493815                                         else throw("Strict value is not equal to itself.")
494816                                     }
495817                                 else throw("Strict value is not equal to itself.")
496818                             }
497819                         else throw("Strict value is not equal to itself.")
498820                     }
499821                 else throw("Strict value is not equal to itself.")
500822             }
501823     }
502824 
503825 
504826 
505827 @Callable(i)
506828 func arbUSDT2 (path,amount) = {
507829     let poolAddress = "3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz"
508830     let pool = addressFromStringValue(poolAddress)
509831     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
510832     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
511833     let usdtAssetIdString = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
512834     let usdtAssetId = base58'34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ'
513835     let usdnUsdtLPTokenAssetId = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
514836     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
515837     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
516838     if ((i.caller != this))
517839         then throw("you are not allowed to arb!")
518840         else {
519841             let initialAmount = assetBalance(this, usdnAssetId)
520842             if ((initialAmount == initialAmount))
521843                 then {
522844                     let initialAmountUSDT = assetBalance(this, usdtAssetId)
523845                     if ((initialAmountUSDT == initialAmountUSDT))
524846                         then {
525847                             let putTheTokenInThePool = invoke(pool, "putOneTknV2", [1, false], [AttachedPayment(usdnAssetId, (amount * 1000000))])
526848                             if ((putTheTokenInThePool == putTheTokenInThePool))
527849                                 then {
528850                                     let lpTokenBalance = assetBalance(this, usdnUsdtLPTokenAssetId)
529851                                     if ((lpTokenBalance == lpTokenBalance))
530852                                         then {
531853                                             let sellPoolToken = invoke(pool, "getOneTknV2", [usdtAssetIdString, 1], [AttachedPayment(usdnUsdtLPTokenAssetId, lpTokenBalance)])
532854                                             if ((sellPoolToken == sellPoolToken))
533855                                                 then {
534856                                                     let usdtTokenBalance = (assetBalance(this, usdtAssetId) - initialAmountUSDT)
535857                                                     if ((usdtTokenBalance == usdtTokenBalance))
536858                                                         then {
537859                                                             let sellOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(usdtAssetId, usdtTokenBalance)])
538860                                                             if ((sellOnPuzzle == sellOnPuzzle))
539861                                                                 then {
540862                                                                     let finalAmount = assetBalance(this, usdnAssetId)
541863                                                                     if ((finalAmount == finalAmount))
542864                                                                         then if ((initialAmount >= finalAmount))
543865                                                                             then throw("arb not successful!")
544866                                                                             else nil
545867                                                                         else throw("Strict value is not equal to itself.")
546868                                                                     }
547869                                                                 else throw("Strict value is not equal to itself.")
548870                                                             }
549871                                                         else throw("Strict value is not equal to itself.")
550872                                                     }
551873                                                 else throw("Strict value is not equal to itself.")
552874                                             }
553875                                         else throw("Strict value is not equal to itself.")
554876                                     }
555877                                 else throw("Strict value is not equal to itself.")
556878                             }
557879                         else throw("Strict value is not equal to itself.")
558880                     }
559881                 else throw("Strict value is not equal to itself.")
560882             }
561883     }
562884 
563885 
564886 
565887 @Callable(i)
566888 func arbTSN (path,amount) = {
567889     let poolAddress = "3PH832eKnw67PFvJfUg9Knz6BHM87QvjMeL"
568890     let pool = addressFromStringValue(poolAddress)
569891     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
570892     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
571893     let tsnAssetId = base58'8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91'
572894     let usdnTsnLPTokenAssetId = base58'EbwpqrZjrvi7XLowkM5Z2rg7xVdzfg6S5ec9asarpAU9'
573895     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
574896     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
575897     if ((i.caller != this))
576898         then throw("you are not allowed to arb!")
577899         else {
578900             let initialAmount = assetBalance(this, usdnAssetId)
579901             if ((initialAmount == initialAmount))
580902                 then {
581903                     let initialAmountTSN = assetBalance(this, tsnAssetId)
582904                     if ((initialAmountTSN == initialAmountTSN))
583905                         then {
584906                             let buyOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(usdnAssetId, (amount * 1000000))])
585907                             if ((buyOnPuzzle == buyOnPuzzle))
586908                                 then {
587909                                     let tsnTokenBalance = (assetBalance(this, tsnAssetId) - initialAmountTSN)
588910                                     if ((tsnTokenBalance == tsnTokenBalance))
589911                                         then {
590912                                             let putTheTokenInThePool = invoke(pool, "putOneTkn", [1, false], [AttachedPayment(tsnAssetId, tsnTokenBalance)])
591913                                             if ((putTheTokenInThePool == putTheTokenInThePool))
592914                                                 then {
593915                                                     let lpTokenBalance = assetBalance(this, usdnTsnLPTokenAssetId)
594916                                                     if ((lpTokenBalance == lpTokenBalance))
595917                                                         then {
596918                                                             let sellPoolToken = invoke(pool, "getOneTkn", [usdnAssetIdString, 1], [AttachedPayment(usdnTsnLPTokenAssetId, lpTokenBalance)])
597919                                                             if ((sellPoolToken == sellPoolToken))
598920                                                                 then {
599921                                                                     let finalAmount = assetBalance(this, usdnAssetId)
600922                                                                     if ((finalAmount == finalAmount))
601923                                                                         then if ((initialAmount >= finalAmount))
602924                                                                             then throw("arb not successful!")
603925                                                                             else nil
604926                                                                         else throw("Strict value is not equal to itself.")
605927                                                                     }
606928                                                                 else throw("Strict value is not equal to itself.")
607929                                                             }
608930                                                         else throw("Strict value is not equal to itself.")
609931                                                     }
610932                                                 else throw("Strict value is not equal to itself.")
611933                                             }
612934                                         else throw("Strict value is not equal to itself.")
613935                                     }
614936                                 else throw("Strict value is not equal to itself.")
615937                             }
616938                         else throw("Strict value is not equal to itself.")
617939                     }
618940                 else throw("Strict value is not equal to itself.")
619941             }
620942     }
621943 
622944 
623945 
624946 @Callable(i)
625947 func arbTSN2 (path,amount) = {
626948     let poolAddress = "3PH832eKnw67PFvJfUg9Knz6BHM87QvjMeL"
627949     let pool = addressFromStringValue(poolAddress)
628950     let usdnAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
629951     let usdnAssetIdString = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
630952     let tsnAssetId = base58'8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91'
631953     let tsnAssetIdString = "8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91"
632954     let usdnTsnLPTokenAssetId = base58'EbwpqrZjrvi7XLowkM5Z2rg7xVdzfg6S5ec9asarpAU9'
633955     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
634956     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
635957     if ((i.caller != this))
636958         then throw("you are not allowed to arb!")
637959         else {
638960             let initialAmount = assetBalance(this, usdnAssetId)
639961             if ((initialAmount == initialAmount))
640962                 then {
641963                     let initialAmountTSN = assetBalance(this, tsnAssetId)
642964                     if ((initialAmountTSN == initialAmountTSN))
643965                         then {
644966                             let putTheTokenInThePool = invoke(pool, "putOneTkn", [1, false], [AttachedPayment(usdnAssetId, (amount * 1000000))])
645967                             if ((putTheTokenInThePool == putTheTokenInThePool))
646968                                 then {
647969                                     let lpTokenBalance = assetBalance(this, usdnTsnLPTokenAssetId)
648970                                     if ((lpTokenBalance == lpTokenBalance))
649971                                         then {
650972                                             let sellPoolToken = invoke(pool, "getOneTkn", [tsnAssetIdString, 1], [AttachedPayment(usdnTsnLPTokenAssetId, lpTokenBalance)])
651973                                             if ((sellPoolToken == sellPoolToken))
652974                                                 then {
653975                                                     let tsnTokenBalance = (assetBalance(this, tsnAssetId) - initialAmountTSN)
654976                                                     if ((tsnTokenBalance == tsnTokenBalance))
655977                                                         then {
656978                                                             let sellOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(tsnAssetId, tsnTokenBalance)])
657979                                                             if ((sellOnPuzzle == sellOnPuzzle))
658980                                                                 then {
659981                                                                     let finalAmount = assetBalance(this, usdnAssetId)
660982                                                                     if ((finalAmount == finalAmount))
661983                                                                         then if ((initialAmount >= finalAmount))
662984                                                                             then throw("arb not successful!")
663985                                                                             else nil
664986                                                                         else throw("Strict value is not equal to itself.")
665987                                                                     }
666988                                                                 else throw("Strict value is not equal to itself.")
667989                                                             }
668990                                                         else throw("Strict value is not equal to itself.")
669991                                                     }
670992                                                 else throw("Strict value is not equal to itself.")
671993                                             }
672994                                         else throw("Strict value is not equal to itself.")
673995                                     }
674996                                 else throw("Strict value is not equal to itself.")
675997                             }
676998                         else throw("Strict value is not equal to itself.")
677999                     }
6781000                 else throw("Strict value is not equal to itself.")
6791001             }
6801002     }
6811003 
6821004 
6831005 
6841006 @Callable(i)
6851007 func arbPool (firstAsset,secondAsset,poolAddress,lpToken,path,amount) = {
6861008     let pool = addressFromStringValue(poolAddress)
6871009     let firstAssetId = fromBase58String(firstAsset)
6881010     let secondAssetId = fromBase58String(secondAsset)
6891011     let lpTokenAssetId = fromBase58String(lpToken)
6901012     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
6911013     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
6921014     if ((i.caller != this))
6931015         then throw("you are not allowed to arb!")
6941016         else {
6951017             let initialAmount = assetBalance(this, firstAssetId)
6961018             if ((initialAmount == initialAmount))
6971019                 then {
6981020                     let initialAmountSecondAsset = assetBalance(this, secondAssetId)
6991021                     if ((initialAmountSecondAsset == initialAmountSecondAsset))
7001022                         then {
7011023                             let buyOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(firstAssetId, (amount * 1000000))])
7021024                             if ((buyOnPuzzle == buyOnPuzzle))
7031025                                 then {
7041026                                     let secondTokenBalance = (assetBalance(this, secondAssetId) - initialAmountSecondAsset)
7051027                                     if ((secondTokenBalance == secondTokenBalance))
7061028                                         then {
7071029                                             let putTheTokenInThePool = invoke(pool, "putOneTkn", [1, false], [AttachedPayment(secondAssetId, secondTokenBalance)])
7081030                                             if ((putTheTokenInThePool == putTheTokenInThePool))
7091031                                                 then {
7101032                                                     let lpTokenBalance = assetBalance(this, lpTokenAssetId)
7111033                                                     if ((lpTokenBalance == lpTokenBalance))
7121034                                                         then {
7131035                                                             let sellPoolToken = invoke(pool, "getOneTkn", [firstAsset, 1], [AttachedPayment(lpTokenAssetId, lpTokenBalance)])
7141036                                                             if ((sellPoolToken == sellPoolToken))
7151037                                                                 then {
7161038                                                                     let finalAmount = assetBalance(this, firstAssetId)
7171039                                                                     if ((finalAmount == finalAmount))
7181040                                                                         then if ((initialAmount >= finalAmount))
7191041                                                                             then throw("arb not successful!")
7201042                                                                             else nil
7211043                                                                         else throw("Strict value is not equal to itself.")
7221044                                                                     }
7231045                                                                 else throw("Strict value is not equal to itself.")
7241046                                                             }
7251047                                                         else throw("Strict value is not equal to itself.")
7261048                                                     }
7271049                                                 else throw("Strict value is not equal to itself.")
7281050                                             }
7291051                                         else throw("Strict value is not equal to itself.")
7301052                                     }
7311053                                 else throw("Strict value is not equal to itself.")
7321054                             }
7331055                         else throw("Strict value is not equal to itself.")
7341056                     }
7351057                 else throw("Strict value is not equal to itself.")
7361058             }
7371059     }
7381060 
7391061 
7401062 
7411063 @Callable(i)
7421064 func arbPool2 (firstAsset,secondAsset,poolAddress,lpToken,path,amount) = {
7431065     let pool = addressFromStringValue(poolAddress)
7441066     let firstAssetId = fromBase58String(firstAsset)
7451067     let secondAssetId = fromBase58String(secondAsset)
7461068     let lpTokenAssetId = fromBase58String(lpToken)
7471069     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
7481070     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
7491071     if ((i.caller != this))
7501072         then throw("you are not allowed to arb!")
7511073         else {
7521074             let initialAmount = assetBalance(this, firstAssetId)
7531075             if ((initialAmount == initialAmount))
7541076                 then {
7551077                     let initialAmountSecondAsset = assetBalance(this, secondAssetId)
7561078                     if ((initialAmountSecondAsset == initialAmountSecondAsset))
7571079                         then {
7581080                             let putTheTokenInThePool = invoke(pool, "putOneTkn", [1, false], [AttachedPayment(firstAssetId, (amount * 1000000))])
7591081                             if ((putTheTokenInThePool == putTheTokenInThePool))
7601082                                 then {
7611083                                     let lpTokenBalance = assetBalance(this, lpTokenAssetId)
7621084                                     if ((lpTokenBalance == lpTokenBalance))
7631085                                         then {
7641086                                             let sellPoolToken = invoke(pool, "getOneTkn", [secondAsset, 1], [AttachedPayment(lpTokenAssetId, lpTokenBalance)])
7651087                                             if ((sellPoolToken == sellPoolToken))
7661088                                                 then {
7671089                                                     let secondTokenBalance = (assetBalance(this, secondAssetId) - initialAmountSecondAsset)
7681090                                                     if ((secondTokenBalance == secondTokenBalance))
7691091                                                         then {
7701092                                                             let sellOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(secondAssetId, secondTokenBalance)])
7711093                                                             if ((sellOnPuzzle == sellOnPuzzle))
7721094                                                                 then {
7731095                                                                     let finalAmount = assetBalance(this, firstAssetId)
7741096                                                                     if ((finalAmount == finalAmount))
7751097                                                                         then if ((initialAmount >= finalAmount))
7761098                                                                             then throw("arb not successful!")
7771099                                                                             else nil
7781100                                                                         else throw("Strict value is not equal to itself.")
7791101                                                                     }
7801102                                                                 else throw("Strict value is not equal to itself.")
7811103                                                             }
7821104                                                         else throw("Strict value is not equal to itself.")
7831105                                                     }
7841106                                                 else throw("Strict value is not equal to itself.")
7851107                                             }
7861108                                         else throw("Strict value is not equal to itself.")
7871109                                     }
7881110                                 else throw("Strict value is not equal to itself.")
7891111                             }
7901112                         else throw("Strict value is not equal to itself.")
7911113                     }
7921114                 else throw("Strict value is not equal to itself.")
7931115             }
7941116     }
7951117 
7961118 
7971119 
7981120 @Callable(i)
7991121 func arbPoolV2 (firstAsset,secondAsset,poolAddress,lpToken,path,amount) = {
8001122     let pool = addressFromStringValue(poolAddress)
8011123     let firstAssetId = fromBase58String(firstAsset)
8021124     let secondAssetId = fromBase58String(secondAsset)
8031125     let lpTokenAssetId = fromBase58String(lpToken)
8041126     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
8051127     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
8061128     if ((i.caller != this))
8071129         then throw("you are not allowed to arb!")
8081130         else {
8091131             let initialAmount = assetBalance(this, firstAssetId)
8101132             if ((initialAmount == initialAmount))
8111133                 then {
8121134                     let initialAmountSecondAsset = assetBalance(this, secondAssetId)
8131135                     if ((initialAmountSecondAsset == initialAmountSecondAsset))
8141136                         then {
8151137                             let buyOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(firstAssetId, (amount * 1000000))])
8161138                             if ((buyOnPuzzle == buyOnPuzzle))
8171139                                 then {
8181140                                     let secondTokenBalance = (assetBalance(this, secondAssetId) - initialAmountSecondAsset)
8191141                                     if ((secondTokenBalance == secondTokenBalance))
8201142                                         then {
8211143                                             let putTheTokenInThePool = invoke(pool, "putOneTknV2", [1, false], [AttachedPayment(secondAssetId, secondTokenBalance)])
8221144                                             if ((putTheTokenInThePool == putTheTokenInThePool))
8231145                                                 then {
8241146                                                     let lpTokenBalance = assetBalance(this, lpTokenAssetId)
8251147                                                     if ((lpTokenBalance == lpTokenBalance))
8261148                                                         then {
8271149                                                             let sellPoolToken = invoke(pool, "getOneTknV2", [firstAsset, 1], [AttachedPayment(lpTokenAssetId, lpTokenBalance)])
8281150                                                             if ((sellPoolToken == sellPoolToken))
8291151                                                                 then {
8301152                                                                     let finalAmount = assetBalance(this, firstAssetId)
8311153                                                                     if ((finalAmount == finalAmount))
8321154                                                                         then if ((initialAmount >= finalAmount))
8331155                                                                             then throw("arb not successful!")
8341156                                                                             else nil
8351157                                                                         else throw("Strict value is not equal to itself.")
8361158                                                                     }
8371159                                                                 else throw("Strict value is not equal to itself.")
8381160                                                             }
8391161                                                         else throw("Strict value is not equal to itself.")
8401162                                                     }
8411163                                                 else throw("Strict value is not equal to itself.")
8421164                                             }
8431165                                         else throw("Strict value is not equal to itself.")
8441166                                     }
8451167                                 else throw("Strict value is not equal to itself.")
8461168                             }
8471169                         else throw("Strict value is not equal to itself.")
8481170                     }
8491171                 else throw("Strict value is not equal to itself.")
8501172             }
8511173     }
8521174 
8531175 
8541176 
8551177 @Callable(i)
8561178 func arbPool2V2 (firstAsset,secondAsset,poolAddress,lpToken,path,amount) = {
8571179     let pool = addressFromStringValue(poolAddress)
8581180     let firstAssetId = fromBase58String(firstAsset)
8591181     let secondAssetId = fromBase58String(secondAsset)
8601182     let lpTokenAssetId = fromBase58String(lpToken)
8611183     let puzzlePoolAddress = "3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU"
8621184     let puzzlePool = addressFromStringValue(puzzlePoolAddress)
8631185     if ((i.caller != this))
8641186         then throw("you are not allowed to arb!")
8651187         else {
8661188             let initialAmount = assetBalance(this, firstAssetId)
8671189             if ((initialAmount == initialAmount))
8681190                 then {
8691191                     let initialAmountSecondAsset = assetBalance(this, secondAssetId)
8701192                     if ((initialAmountSecondAsset == initialAmountSecondAsset))
8711193                         then {
8721194                             let putTheTokenInThePool = invoke(pool, "putOneTknV2", [1, false], [AttachedPayment(firstAssetId, (amount * 1000000))])
8731195                             if ((putTheTokenInThePool == putTheTokenInThePool))
8741196                                 then {
8751197                                     let lpTokenBalance = assetBalance(this, lpTokenAssetId)
8761198                                     if ((lpTokenBalance == lpTokenBalance))
8771199                                         then {
8781200                                             let sellPoolToken = invoke(pool, "getOneTknV2", [secondAsset, 1], [AttachedPayment(lpTokenAssetId, lpTokenBalance)])
8791201                                             if ((sellPoolToken == sellPoolToken))
8801202                                                 then {
8811203                                                     let secondTokenBalance = (assetBalance(this, secondAssetId) - initialAmountSecondAsset)
8821204                                                     if ((secondTokenBalance == secondTokenBalance))
8831205                                                         then {
8841206                                                             let sellOnPuzzle = invoke(puzzlePool, "swap", [path, 1], [AttachedPayment(secondAssetId, secondTokenBalance)])
8851207                                                             if ((sellOnPuzzle == sellOnPuzzle))
8861208                                                                 then {
8871209                                                                     let finalAmount = assetBalance(this, firstAssetId)
8881210                                                                     if ((finalAmount == finalAmount))
8891211                                                                         then if ((initialAmount >= finalAmount))
8901212                                                                             then throw("arb not successful!")
8911213                                                                             else nil
8921214                                                                         else throw("Strict value is not equal to itself.")
8931215                                                                     }
8941216                                                                 else throw("Strict value is not equal to itself.")
8951217                                                             }
8961218                                                         else throw("Strict value is not equal to itself.")
8971219                                                     }
8981220                                                 else throw("Strict value is not equal to itself.")
8991221                                             }
9001222                                         else throw("Strict value is not equal to itself.")
9011223                                     }
9021224                                 else throw("Strict value is not equal to itself.")
9031225                             }
9041226                         else throw("Strict value is not equal to itself.")
9051227                     }
9061228                 else throw("Strict value is not equal to itself.")
9071229             }
9081230     }
9091231 
9101232 
9111233 
9121234 @Callable(i)
9131235 func y (data) = if ((i.caller != this))
9141236     then throw("you are not allowed to arb!")
9151237     else {
9161238         let data_array = split_4C(data, "|")
9171239         let t030083064 = getBase1(data_array[0])
9181240         let a = t030083064._1
9191241         let a2 = t030083064._2
9201242         let assetIn = t030083064._3
9211243         let amountIn = t030083064._4
9221244         let t030693107 = getBase2(data_array[1])
9231245         let p1 = t030693107._1
9241246         let t1 = t030693107._2
9251247         let t031123150 = getBase2(data_array[2])
9261248         let p2 = t031123150._1
9271249         let t2 = t031123150._2
9281250         let t031553193 = getBase2(data_array[3])
9291251         let p3 = t031553193._1
9301252         let t3 = t031553193._2
9311253         let idu = if ((size(data_array[4]) > 1))
9321254             then split_4C(data_array[4], "-")
9331255             else nil
9341256         if (if (if ((size(idu) > 0))
9351257             then (ucheck(fromBase58String(idu[0])) > 0)
9361258             else false)
9371259             then true
9381260             else (1 >= size(data_array[4])))
9391261             then {
9401262                 let amount_bef_assetIn = getBalance(getAssetBytes(assetIn))
9411263                 if ((amount_bef_assetIn == amount_bef_assetIn))
9421264                     then {
9431265                         let ulimit = valueOrElse(getInteger(this, "ulimit"), 100)
9441266                         let max_amount = if ((size(idu) > 0))
9451267                             then fraction(amount_bef_assetIn, ulimit, 100)
9461268                             else amount_bef_assetIn
9471269                         let new_amountIn = if ((value(parseInt(amountIn)) > max_amount))
9481270                             then max_amount
9491271                             else value(parseInt(amountIn))
9501272                         if ((new_amountIn == new_amountIn))
9511273                             then {
9521274                                 let amount_bef_asset1 = getBalance(getAssetBytes(a))
9531275                                 if ((amount_bef_asset1 == amount_bef_asset1))
9541276                                     then {
9551277                                         let swap1 = if ((t1 == "W"))
9561278                                             then swap_wx(p1, assetIn, new_amountIn, a)
9571279                                             else if ((t1 == "S"))
9581280                                                 then swap_swop(p1, assetIn, new_amountIn)
9591281                                                 else swap_puzzle(p1, assetIn, new_amountIn, a)
9601282                                         if ((swap1 == swap1))
9611283                                             then {
9621284                                                 let nb = (getBalance(getAssetBytes(a)) - amount_bef_asset1)
9631285                                                 if ((nb == nb))
9641286                                                     then {
9651287                                                         let amount_bef_asset2 = getBalance(getAssetBytes(a2))
9661288                                                         if ((amount_bef_asset2 == amount_bef_asset2))
9671289                                                             then {
9681290                                                                 let swap2 = if ((t2 == "W"))
9691291                                                                     then swap_wx(p2, a, nb, a2)
9701292                                                                     else if ((t2 == "S"))
9711293                                                                         then swap_swop(p2, a, nb)
9721294                                                                         else swap_puzzle(p2, a, nb, a2)
9731295                                                                 if ((swap2 == swap2))
9741296                                                                     then {
9751297                                                                         let nb2 = (getBalance(getAssetBytes(a2)) - amount_bef_asset2)
9761298                                                                         if ((nb2 == nb2))
9771299                                                                             then {
9781300                                                                                 let amount_bef_base_asset = getBalance(getAssetBytes(assetIn))
9791301                                                                                 if ((amount_bef_base_asset == amount_bef_base_asset))
9801302                                                                                     then {
9811303                                                                                         let swap3 = if ((t3 == "W"))
9821304                                                                                             then swap_wx(p3, a2, nb2, assetIn)
9831305                                                                                             else if ((t3 == "S"))
9841306                                                                                                 then swap_swop(p3, a2, nb2)
9851307                                                                                                 else swap_puzzle(p3, a2, nb2, assetIn)
9861308                                                                                         if ((swap3 == swap3))
9871309                                                                                             then {
9881310                                                                                                 let nb3 = (getBalance(getAssetBytes(assetIn)) - amount_bef_base_asset)
9891311                                                                                                 if ((nb3 == nb3))
9901312                                                                                                     then {
9911313                                                                                                         let treshold = valueOrElse(getInteger(this, "treshold"), 150000)
9921314                                                                                                         if ((nb3 > (new_amountIn + treshold)))
9931315                                                                                                             then nil
9941316                                                                                                             else throw(((((((((("origin amountIn = " + amountIn) + ", new_amountIn = ") + toString(new_amountIn)) + ", newBal_1: ") + toString(nb)) + ", newBal_2: ") + toString(nb2)) + ", newBal_3: ") + toString(nb3)))
9951317                                                                                                         }
9961318                                                                                                     else throw("Strict value is not equal to itself.")
9971319                                                                                                 }
9981320                                                                                             else throw("Strict value is not equal to itself.")
9991321                                                                                         }
10001322                                                                                     else throw("Strict value is not equal to itself.")
10011323                                                                                 }
10021324                                                                             else throw("Strict value is not equal to itself.")
10031325                                                                         }
10041326                                                                     else throw("Strict value is not equal to itself.")
10051327                                                                 }
10061328                                                             else throw("Strict value is not equal to itself.")
10071329                                                         }
10081330                                                     else throw("Strict value is not equal to itself.")
10091331                                                 }
10101332                                             else throw("Strict value is not equal to itself.")
10111333                                         }
10121334                                     else throw("Strict value is not equal to itself.")
10131335                                 }
10141336                             else throw("Strict value is not equal to itself.")
10151337                         }
10161338                     else throw("Strict value is not equal to itself.")
10171339                 }
10181340             else nil
10191341         }
10201342 
10211343 
1344+
1345+@Callable(i)
1346+func default () = if ((i.caller != this))
1347+    then throw("No touching")
1348+    else {
1349+        func accumFunction (accum,next) =         {
1350+            let estimation = estimateRoute(next._1, next._2, next._3, next._4, next._5, next._6)
1351+            $Tuple2((accum._1 :+ estimation._1), (accum._2 :+ estimation._2))
1352+            }
1353+
1354+        let fold = {
1355+            let $l = routes
1356+            let $s = size($l)
1357+            let $acc0 = $Tuple2(nil, nil)
1358+            func $f0_1 ($a,$i) =             if (($i >= $s))
1359+                then $a
1360+                else accumFunction($a, $l[$i])
1361+
1362+            func $f0_2 ($a,$i) =             if (($i >= $s))
1363+                then $a
1364+                else throw("List size exceeds 24")
1365+
1366+            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24)
1367+            }
1368+        let maxSwapProfit = max(fold._1)
1369+        if ((0 >= maxSwapProfit))
1370+            then throw("Estimate fail")
1371+            else {
1372+                let estimatedResult = fold._2[value(indexOf(fold._1, maxSwapProfit))]
1373+                let result1 = invokeSwap(estimatedResult[0])
1374+                if ((result1 == result1))
1375+                    then {
1376+                        let result2 = invokeSwap(estimatedResult[1])
1377+                        if ((result2 == result2))
1378+                            then {
1379+                                let result3 = invokeSwap(estimatedResult[2])
1380+                                if ((result3 == result3))
1381+                                    then {
1382+                                        let profit = (getBalance(InAsset) - inBalance)
1383+                                        let pureProfit = (profit - 1500000)
1384+                                        if ((0 >= pureProfit))
1385+                                            then throw("Execute fail")
1386+                                            else nil
1387+                                        }
1388+                                    else throw("Strict value is not equal to itself.")
1389+                                }
1390+                            else throw("Strict value is not equal to itself.")
1391+                        }
1392+                    else throw("Strict value is not equal to itself.")
1393+                }
1394+        }
1395+
1396+
10221397 @Verifier(tx)
10231398 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
10241399 
github/deemru/w8io/3ef1775 
114.54 ms ◑