tx · DTePGL71bZ8wVdjD6t9faSZndz4t8qNP9WAPQQeoQ4G9

3PF8ihzUXp9QqvtcnpSveENQHqLDYGvbRvZ:  -0.02300000 Waves

2022.09.15 13:40 [3295609] smart account 3PF8ihzUXp9QqvtcnpSveENQHqLDYGvbRvZ > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DTePGL71bZ8wVdjD6t9faSZndz4t8qNP9WAPQQeoQ4G9",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1663238401433,
    "version": 2,
    "chainId": 87,
    "sender": "3PF8ihzUXp9QqvtcnpSveENQHqLDYGvbRvZ",
    "senderPublicKey": "9kcEZHonGr2aoSBCDgKiB7nf7C6dYThx4YnvpDKNSD77",
    "proofs": [
        "3B4U3weLccxhKkLcQLeSwNYe9Tex2WuwNcoY56CKFmJuTf4uVUuXtY9Jg1ABUyhtQ1iYY1yC9gzi5okTrApJU3sA"
    ],
    "script": "base64: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",
    "height": 3295609,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 8QuLefVAT8YVkZsUzukK5XbrBdgk9jLqffkNBNVC5cdE

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func getStringOrThrow (address,key) = valueOrErrorMessage(getString(address, key), ((("Can't read '" + key) + "' at address ") + toString(address)))
5+
6+
7+func getIntegerOrThrow (address,key) = valueOrErrorMessage(getInteger(address, key), ((("Can't read '" + key) + "' at address ") + toString(address)))
8+
9+
10+func parseAddressOrThrow (maybeAddress) = valueOrErrorMessage(addressFromString(maybeAddress), (("Can't parse address from '" + maybeAddress) + "'"))
11+
12+
13+func parseIntOrDefault (maybeInt,default) = valueOrElse(parseInt(maybeInt), default)
14+
15+
16+func parseIntOrThrow (maybeInt) = valueOrErrorMessage(parseInt(maybeInt), (("Can't parse integer from '" + maybeInt) + "'"))
17+
18+
19+func getAssetId (asset) = if ((asset == "WAVES"))
20+    then unit
21+    else fromBase58String(asset)
22+
23+
24+let collector = parseAddressOrThrow(getStringOrThrow(this, "collector"))
25+
26+let feeRate = getIntegerOrThrow(this, "fee-rate")
27+
28+let oracle = parseAddressOrThrow(getStringOrThrow(this, "oracle"))
29+
30+let swopfiRouting = parseAddressOrThrow(getStringOrThrow(this, "swopfi-routing"))
31+
32+let puzzleRouting = parseAddressOrThrow(getStringOrThrow(this, "puzzle-routing"))
33+
34+let pools = split(getStringOrThrow(oracle, "pools"), ",")
35+
36+let percentRate = getIntegerOrThrow(this, "percent-rate")
37+
38+let refKey = "keeper"
39+
40+let puzzleRewardAssetStr = getStringOrThrow(this, "puzzle-reward-token")
41+
42+let puzzleRewardAssetId = getAssetId(puzzleRewardAssetStr)
43+
44+let pPools = split(getStringOrThrow(this, "p-pools"), ",")
45+
46+func assetIdToString (assetId) = match assetId {
47+    case asset: ByteVector => 
48+        toBase58String(asset)
49+    case waves: Unit => 
50+        "WAVES"
51+    case _ => 
52+        throw("Match error")
53+}
54+
55+
56+func getBalance (assetId) = match assetId {
57+    case asset: ByteVector => 
58+        assetBalance(this, asset)
59+    case waves: Unit => 
60+        wavesBalance(this).available
61+    case _ => 
62+        throw("Match error")
63+}
64+
65+
66+func getBalanceByAddress (address,assetId) = match assetId {
67+    case asset: ByteVector => 
68+        assetBalance(address, asset)
69+    case waves: Unit => 
70+        wavesBalance(address).available
71+    case _ => 
72+        throw("Match error")
73+}
74+
75+
76+func deductFee (amount) = {
77+    let fee = fraction(amount, 1, feeRate)
78+    $Tuple2((amount - fee), fee)
79+    }
80+
81+
82+func getReferrerDataOrThrow (referrerName) = if ((size(referrerName) == 0))
83+    then $Tuple2(collector, 0)
84+    else {
85+        let refAddress = parseAddressOrThrow(valueOrErrorMessage(getString(this, (("referrer-" + referrerName) + "-address")), (("referrer with name " + referrerName) + " not found")))
86+        let refPercent = valueOrElse(getInteger(this, (("referrer-" + referrerName) + "-percent")), percentRate)
87+        if (if ((0 > refPercent))
88+            then true
89+            else (refPercent > 100))
90+            then throw("Incorrect percent rate")
91+            else $Tuple2(refAddress, refPercent)
92+        }
93+
94+
95+func getSwapOptions (options) = {
96+    func foldArguments (acc,index) =     if ((index >= size(options)))
97+        then (acc :+ "")
98+        else (acc :+ options[index])
99+
100+    let indices = [0, 1]
101+    let arguments = {
102+        let $l = indices
103+        let $s = size($l)
104+        let $acc0 = nil
105+        func $f0_1 ($a,$i) =         if (($i >= $s))
106+            then $a
107+            else foldArguments($a, $l[$i])
108+
109+        func $f0_2 ($a,$i) =         if (($i >= $s))
110+            then $a
111+            else throw("List size exceeds 2")
112+
113+        $f0_2($f0_1($f0_1($acc0, 0), 1), 2)
114+        }
115+    let deadline = parseIntOrDefault(arguments[0], 0)
116+    let referrerName = arguments[1]
117+    $Tuple2(deadline, referrerName)
118+    }
119+
120+
121+func validateBlockTimestamp (deadline) = if (if ((deadline > 0))
122+    then (lastBlock.timestamp > deadline)
123+    else false)
124+    then throw(((("This swap expired at timestamp " + toString(deadline)) + ". Current: ") + toString(lastBlock.timestamp)))
125+    else true
126+
127+
128+func doSwap (pool,payment,assetReceived,estAmountToReceive,slippageTolerance) = {
129+    let poolAddress = parseAddressOrThrow(pool)
130+    let versionMajor = parseIntOrThrow(split(getStringOrThrow(poolAddress, "version"), ".")[0])
131+    let assetReceivedId = getAssetId(assetReceived)
132+    if ((0 > estAmountToReceive))
133+        then throw("estAmountToReceive must be positive")
134+        else if (containsElement(pools, pool))
135+            then {
136+                let poolAssetA = getStringOrThrow(poolAddress, "A_asset_id")
137+                let poolAssetB = getStringOrThrow(poolAddress, "B_asset_id")
138+                let poolAssetIdA = getAssetId(poolAssetA)
139+                let poolAssetIdB = getAssetId(poolAssetB)
140+                let $t042974641 = if (if ((payment.assetId == poolAssetIdA))
141+                    then (assetReceivedId == poolAssetIdB)
142+                    else false)
143+                    then $Tuple2(poolAssetIdA, poolAssetIdB)
144+                    else if (if ((assetReceivedId == poolAssetIdA))
145+                        then (payment.assetId == poolAssetIdB)
146+                        else false)
147+                        then $Tuple2(poolAssetIdB, poolAssetIdA)
148+                        else throw("Unsupported assets pair")
149+                let assetIn = $t042974641._1
150+                let assetOut = $t042974641._2
151+                let args = if ((versionMajor == 1))
152+                    then [1]
153+                    else if ((versionMajor == 2))
154+                        then if ((0 >= estAmountToReceive))
155+                            then throw("estAmountToReceive must be positive")
156+                            else {
157+                                let minAmount = (estAmountToReceive - fraction(estAmountToReceive, slippageTolerance, 1000))
158+[estAmountToReceive, if ((minAmount > 0))
159+                                    then minAmount
160+                                    else 1]
161+                                }
162+                        else throw((("Unknown pool version '" + toString(versionMajor)) + "', but 1 or 2 expected"))
163+                let balanceBefore = getBalance(assetReceivedId)
164+                if ((balanceBefore == balanceBefore))
165+                    then {
166+                        let result = invoke(poolAddress, "exchange", args, [payment])
167+                        if ((result == result))
168+                            then {
169+                                let received = (getBalance(assetReceivedId) - balanceBefore)
170+                                if ((received == received))
171+                                    then if ((0 >= received))
172+                                        then throw("Received amount from pool must be positive")
173+                                        else received
174+                                    else throw("Strict value is not equal to itself.")
175+                                }
176+                            else throw("Strict value is not equal to itself.")
177+                        }
178+                    else throw("Strict value is not equal to itself.")
179+                }
180+            else if (containsElement(pPools, pool))
181+                then {
182+                    let balanceBefore = getBalance(assetReceivedId)
183+                    if ((balanceBefore == balanceBefore))
184+                        then {
185+                            let result = invoke(poolAddress, "swap", [assetReceived, 0], [payment])
186+                            if ((result == result))
187+                                then {
188+                                    let received = (getBalance(assetReceivedId) - balanceBefore)
189+                                    if ((received == received))
190+                                        then if ((0 >= received))
191+                                            then throw("Received amount from pool must be positive")
192+                                            else received
193+                                        else throw("Strict value is not equal to itself.")
194+                                    }
195+                                else throw("Strict value is not equal to itself.")
196+                            }
197+                        else throw("Strict value is not equal to itself.")
198+                    }
199+                else throw((("There is no pool at address '" + pool) + "'"))
200+    }
201+
202+
203+func swapSingleRoute (inv,addresses,assetsToReceive,estReceived,slippageTolerance,minReceived) = {
204+    let pmt = if ((size(inv.payments) > 0))
205+        then inv.payments[0]
206+        else throw("Payment required")
207+    func foldSwap (previousReceived,index) =     if ((index >= size(addresses)))
208+        then previousReceived
209+        else {
210+            let assetReceived = assetsToReceive[index]
211+            let assetReceivedId = getAssetId(assetReceived)
212+            match doSwap(addresses[index], previousReceived, assetReceived, estReceived[index], slippageTolerance) {
213+                case income: Int => 
214+                    AttachedPayment(assetReceivedId, income)
215+                case _ => 
216+                    throw("Can't handle swap result")
217+            }
218+            }
219+
220+    let received = if ((size(addresses) > 0))
221+        then {
222+            let $l = [0, 1, 2, 3, 4]
223+            let $s = size($l)
224+            let $acc0 = pmt
225+            func $f0_1 ($a,$i) =             if (($i >= $s))
226+                then $a
227+                else foldSwap($a, $l[$i])
228+
229+            func $f0_2 ($a,$i) =             if (($i >= $s))
230+                then $a
231+                else throw("List size exceeds 5")
232+
233+            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
234+            }
235+        else throw("Path cannot be empty")
236+    if ((0 >= received.amount))
237+        then throw((("Swap result " + toString(received.amount)) + " must be positive"))
238+        else received
239+    }
240+
241+
242+func swapMultipleRoutes (inv,amountsIn,addresses,assetsToReceive,estReceived,slippageTolerance,minReceived) = {
243+    let pmt = if ((size(inv.payments) > 0))
244+        then inv.payments[0]
245+        else throw("Payment required")
246+    func foldSplit (splitResults,index) =     if ((index >= size(addresses)))
247+        then splitResults
248+        else {
249+            let splitInv = Invocation([AttachedPayment(pmt.assetId, amountsIn[index])], inv.caller, inv.callerPublicKey, inv.transactionId, inv.fee, inv.feeAssetId, inv.originCaller, inv.originCallerPublicKey)
250+            let splitAddresses = split(addresses[index], "_")
251+            let splitAssets = split(assetsToReceive[index], "_")
252+            func mapIntOrThrow (result,maybeInt) =             (result :+ parseIntOrThrow(maybeInt))
253+
254+            let splitEstReceived = {
255+                let $l = split(estReceived[index], "_")
256+                let $s = size($l)
257+                let $acc0 = nil
258+                func $f0_1 ($a,$i) =                 if (($i >= $s))
259+                    then $a
260+                    else mapIntOrThrow($a, $l[$i])
261+
262+                func $f0_2 ($a,$i) =                 if (($i >= $s))
263+                    then $a
264+                    else throw("List size exceeds 5")
265+
266+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5)
267+                }
268+            let result = swapSingleRoute(splitInv, splitAddresses, splitAssets, splitEstReceived, slippageTolerance, minReceived)
269+            if ((result == result))
270+                then (splitResults :+ result)
271+                else throw("Strict value is not equal to itself.")
272+            }
273+
274+    let $l = [0, 1, 2]
275+    let $s = size($l)
276+    let $acc0 = nil
277+    func $f0_1 ($a,$i) =     if (($i >= $s))
278+        then $a
279+        else foldSplit($a, $l[$i])
280+
281+    func $f0_2 ($a,$i) =     if (($i >= $s))
282+        then $a
283+        else throw("List size exceeds 3")
284+
285+    $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
286+    }
287+
288+
289+func wrapSwopfiSwap (inv,exchangers,exchangersType,args1,args2,routingAssetsKeys,minAmountToReceive) = {
290+    let pmt = if ((size(inv.payments) > 0))
291+        then inv.payments[0]
292+        else throw("Payment required")
293+    let lastExchanger = valueOrErrorMessage(addressFromString(exchangers[(size(exchangers) - 1)]), "Can't parse last exchanger swopfi address")
294+    let lastAssetIdKey = (split(routingAssetsKeys[(size(routingAssetsKeys) - 1)], "_")[0] + "_asset_id")
295+    let assetFinal = valueOrErrorMessage(getString(lastExchanger, lastAssetIdKey), ((("Can't read parameter '" + lastAssetIdKey) + "' for exchanger ") + toString(lastExchanger)))
296+    let assetFinalId = getAssetId(assetFinal)
297+    let balanceBefore = getBalance(assetFinalId)
298+    if ((balanceBefore == balanceBefore))
299+        then {
300+            let result = invoke(swopfiRouting, "routingTrade", [exchangers, exchangersType, args1, args2, routingAssetsKeys, minAmountToReceive], [pmt])
301+            if ((result == result))
302+                then {
303+                    let balanceAfter = getBalance(assetFinalId)
304+                    if ((balanceAfter == balanceAfter))
305+                        then {
306+                            let delta = (balanceAfter - balanceBefore)
307+                            let $t01020310248 = deductFee(delta)
308+                            let resultAfterFee = $t01020310248._1
309+                            let fee = $t01020310248._2
310+                            if ((0 >= delta))
311+                                then throw((("Swap result " + toString(delta)) + " must be positive"))
312+                                else if ((minAmountToReceive > resultAfterFee))
313+                                    then throw(((("Swap result " + toString(resultAfterFee)) + " is less then expected ") + toString(minAmountToReceive)))
314+                                    else [ScriptTransfer(inv.caller, resultAfterFee, assetFinalId), ScriptTransfer(collector, fee, assetFinalId)]
315+                            }
316+                        else throw("Strict value is not equal to itself.")
317+                    }
318+                else throw("Strict value is not equal to itself.")
319+            }
320+        else throw("Strict value is not equal to itself.")
321+    }
322+
323+
324+func wrapPuzzleSwap (inv,routesStr,minToReceive) = {
325+    let pmt = if ((size(inv.payments) > 0))
326+        then inv.payments[0]
327+        else throw("Payment required")
328+    let assetIdFinal = split(routesStr, ",")[(size(split(routesStr, ",")) - 1)]
329+    let assetId = getAssetId(assetIdFinal)
330+    let balanceBefore = getBalance(assetId)
331+    if ((balanceBefore == balanceBefore))
332+        then {
333+            let result = invoke(puzzleRouting, "swapWithReferral", [routesStr, minToReceive, refKey], [pmt])
334+            if ((result == result))
335+                then {
336+                    let balanceAfter = getBalance(assetId)
337+                    if ((balanceAfter == balanceAfter))
338+                        then {
339+                            let deltaProxy = (balanceAfter - balanceBefore)
340+                            if ((deltaProxy == deltaProxy))
341+                                then [ScriptTransfer(inv.caller, deltaProxy, assetId)]
342+                                else throw("Strict value is not equal to itself.")
343+                            }
344+                        else throw("Strict value is not equal to itself.")
345+                    }
346+                else throw("Strict value is not equal to itself.")
347+            }
348+        else throw("Strict value is not equal to itself.")
349+    }
350+
351+
352+@Callable(inv)
353+func swap (amountsIn,addresses,assetsToReceive,estReceived,slippageTolerance,minReceived,options) = {
354+    let pmt = if ((size(inv.payments) > 0))
355+        then inv.payments[0]
356+        else throw("Payment required")
357+    let $t01160311657 = getSwapOptions(options)
358+    let deadline = $t01160311657._1
359+    let referrerName = $t01160311657._2
360+    let isValidTimestamp = validateBlockTimestamp(deadline)
361+    if ((isValidTimestamp == isValidTimestamp))
362+        then {
363+            let $t01172511805 = getReferrerDataOrThrow(referrerName)
364+            if (($t01172511805 == $t01172511805))
365+                then {
366+                    let referrerPercent = $t01172511805._2
367+                    let referrerAddress = $t01172511805._1
368+                    let validAddresses = if (if ((0 > size(addresses)))
369+                        then true
370+                        else (size(addresses) > 3))
371+                        then throw("Supported swap of 1 to 3 splits")
372+                        else addresses
373+                    let validSlippageTolerance = if (if ((0 > slippageTolerance))
374+                        then true
375+                        else (slippageTolerance > 1000))
376+                        then throw("Slippage tolerance must be non-negative and less than or equal to 1000")
377+                        else slippageTolerance
378+                    func sumIn (accum,next) =                     (accum + next)
379+
380+                    let totalAmountIn = {
381+                        let $l = amountsIn
382+                        let $s = size($l)
383+                        let $acc0 = 0
384+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
385+                            then $a
386+                            else sumIn($a, $l[$i])
387+
388+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
389+                            then $a
390+                            else throw("List size exceeds 3")
391+
392+                        $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
393+                        }
394+                    let amountsOut = if ((pmt.amount != totalAmountIn))
395+                        then throw(((("Total amount after split " + toString(totalAmountIn)) + " is not equal original payment amount ") + toString(pmt.amount)))
396+                        else swapMultipleRoutes(inv, amountsIn, validAddresses, assetsToReceive, estReceived, validSlippageTolerance, minReceived)
397+                    if ((amountsOut == amountsOut))
398+                        then {
399+                            func sumOut (total,next) =                             (total + next.amount)
400+
401+                            let totalAmountOut = {
402+                                let $l = amountsOut
403+                                let $s = size($l)
404+                                let $acc0 = 0
405+                                func $f1_1 ($a,$i) =                                 if (($i >= $s))
406+                                    then $a
407+                                    else sumOut($a, $l[$i])
408+
409+                                func $f1_2 ($a,$i) =                                 if (($i >= $s))
410+                                    then $a
411+                                    else throw("List size exceeds 3")
412+
413+                                $f1_2($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3)
414+                                }
415+                            let assetId = amountsOut[0].assetId
416+                            let $t01303213086 = deductFee(totalAmountOut)
417+                            let amountMinusFee = $t01303213086._1
418+                            let fee = $t01303213086._2
419+                            let referrerReward = fraction(fee, referrerPercent, 100)
420+                            let collectorReward = (fee - referrerReward)
421+                            let transfers = [ScriptTransfer(inv.caller, amountMinusFee, assetId), ScriptTransfer(collector, collectorReward, assetId)]
422+                            if ((referrerReward == 0))
423+                                then transfers
424+                                else (transfers :+ ScriptTransfer(referrerAddress, referrerReward, assetId))
425+                            }
426+                        else throw("Strict value is not equal to itself.")
427+                    }
428+                else throw("Strict value is not equal to itself.")
429+            }
430+        else throw("Strict value is not equal to itself.")
431+    }
432+
433+
434+
435+@Callable(inv)
436+func swopfiSwap (exchangers,exchangersType,args1,args2,routingAssetsKeys,minAmountToReceive,options) = {
437+    let $t01372813782 = getSwapOptions(options)
438+    let deadline = $t01372813782._1
439+    let referrerName = $t01372813782._2
440+    let isValidTimestamp = validateBlockTimestamp(deadline)
441+    if ((isValidTimestamp == isValidTimestamp))
442+        then {
443+            let $t01385013930 = getReferrerDataOrThrow(referrerName)
444+            if (($t01385013930 == $t01385013930))
445+                then {
446+                    let referrerPercent = $t01385013930._2
447+                    let referrerAddress = $t01385013930._1
448+                    let result = wrapSwopfiSwap(inv, exchangers, exchangersType, args1, args2, routingAssetsKeys, minAmountToReceive)
449+                    if ((result == result))
450+                        then if ((referrerPercent > 0))
451+                            then {
452+                                let lastExchanger = valueOrErrorMessage(addressFromString(exchangers[(size(exchangers) - 1)]), "Can't parse last exchanger swopfi address")
453+                                let lastAssetIdKey = (split(routingAssetsKeys[(size(routingAssetsKeys) - 1)], "_")[0] + "_asset_id")
454+                                let assetFinal = valueOrErrorMessage(getString(lastExchanger, lastAssetIdKey), ((("Can't read parameter '" + lastAssetIdKey) + "' for exchanger ") + toString(lastExchanger)))
455+                                let assetId = getAssetId(assetFinal)
456+                                let collectorFee = result[1].amount
457+                                let referrerReward = fraction(collectorFee, referrerPercent, 100)
458+[result[0], ScriptTransfer(collector, (collectorFee - referrerReward), assetId), ScriptTransfer(referrerAddress, referrerReward, assetId)]
459+                                }
460+                            else result
461+                        else throw("Strict value is not equal to itself.")
462+                    }
463+                else throw("Strict value is not equal to itself.")
464+            }
465+        else throw("Strict value is not equal to itself.")
466+    }
467+
468+
469+
470+@Callable(inv)
471+func puzzleSwap (routesStr,minToReceive,options) = {
472+    let $t01500015054 = getSwapOptions(options)
473+    let deadline = $t01500015054._1
474+    let referrerName = $t01500015054._2
475+    let isValidTimestamp = validateBlockTimestamp(deadline)
476+    if ((isValidTimestamp == isValidTimestamp))
477+        then {
478+            let $t01512215202 = getReferrerDataOrThrow(referrerName)
479+            if (($t01512215202 == $t01512215202))
480+                then {
481+                    let referrerPercent = $t01512215202._2
482+                    let referrerAddress = $t01512215202._1
483+                    if ((size(routesStr) == 0))
484+                        then throw("Invalid routing")
485+                        else if ((0 >= minToReceive))
486+                            then throw("Sum to receive is to low")
487+                            else {
488+                                let balanceBefore = getBalanceByAddress(collector, puzzleRewardAssetId)
489+                                if ((balanceBefore == balanceBefore))
490+                                    then {
491+                                        let result = wrapPuzzleSwap(inv, routesStr, minToReceive)
492+                                        if ((result == result))
493+                                            then if ((referrerPercent > 0))
494+                                                then {
495+                                                    let assetIdFinal = split(routesStr, ",")[(size(split(routesStr, ",")) - 1)]
496+                                                    let assetId = getAssetId(assetIdFinal)
497+                                                    let balanceAfter = getBalanceByAddress(collector, puzzleRewardAssetId)
498+                                                    if ((balanceAfter == balanceAfter))
499+                                                        then {
500+                                                            let delta = (balanceAfter - balanceBefore)
501+                                                            if ((delta == delta))
502+                                                                then {
503+                                                                    let reward = fraction(delta, referrerPercent, 100)
504+                                                                    let res = invoke(collector, "claimReferrerReward", [reward, puzzleRewardAssetStr], nil)
505+                                                                    if ((res == res))
506+                                                                        then (result :+ ScriptTransfer(referrerAddress, reward, puzzleRewardAssetId))
507+                                                                        else throw("Strict value is not equal to itself.")
508+                                                                    }
509+                                                                else throw("Strict value is not equal to itself.")
510+                                                            }
511+                                                        else throw("Strict value is not equal to itself.")
512+                                                    }
513+                                                else result
514+                                            else throw("Strict value is not equal to itself.")
515+                                        }
516+                                    else throw("Strict value is not equal to itself.")
517+                                }
518+                    }
519+                else throw("Strict value is not equal to itself.")
520+            }
521+        else throw("Strict value is not equal to itself.")
522+    }
523+
524+
525+
526+@Callable(inv)
527+func addPools (poolAddresses) = {
528+    func addIfDoesNotExist (pools,pool) =     if (containsElement(pools, pool))
529+        then throw((("Pool '" + pool) + "' is already added"))
530+        else (pools :+ toString(parseAddressOrThrow(pool)))
531+
532+    if (!(containsElement([this, collector], inv.caller)))
533+        then throw("only self calls or by collector are allowed")
534+        else [StringEntry("p-pools", makeString({
535+            let $l = poolAddresses
536+            let $s = size($l)
537+            let $acc0 = pPools
538+            func $f0_1 ($a,$i) =             if (($i >= $s))
539+                then $a
540+                else addIfDoesNotExist($a, $l[$i])
541+
542+            func $f0_2 ($a,$i) =             if (($i >= $s))
543+                then $a
544+                else throw("List size exceeds 10")
545+
546+            $f0_2($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)
547+            }, ","))]
548+    }
549+
550+
551+
552+@Callable(inv)
553+func addReferrer (referrerName,refererAddress,percent) = {
554+    let address = parseAddressOrThrow(refererAddress)
555+    if (if ((0 > percent))
556+        then true
557+        else (percent > 100))
558+        then throw("Incorrect percent rate")
559+        else if ((size(referrerName) == 0))
560+            then throw("Referrer name invalid")
561+            else if (!(containsElement([this, collector], inv.caller)))
562+                then throw("only self calls or by collector are allowed")
563+                else [StringEntry((("referrer-" + referrerName) + "-address"), refererAddress), IntegerEntry((("referrer-" + referrerName) + "-percent"), percent)]
564+    }
565+
566+
github/deemru/w8io/3ef1775 
52.40 ms ◑