tx · 5m5N4E235jqDmiN5ViZSa2oyWyiLDEgcHCZQnD5t69QR

3P5UKXpQbom7GB2WGdPG5yGQPeQQuM3hFmw:  -0.02100000 Waves

2023.03.30 10:35 [3577980] smart account 3P5UKXpQbom7GB2WGdPG5yGQPeQQuM3hFmw > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5m5N4E235jqDmiN5ViZSa2oyWyiLDEgcHCZQnD5t69QR",
    "fee": 2100000,
    "feeAssetId": null,
    "timestamp": 1680161621336,
    "version": 2,
    "chainId": 87,
    "sender": "3P5UKXpQbom7GB2WGdPG5yGQPeQQuM3hFmw",
    "senderPublicKey": "4MfTwwE7yP4BFGaifQrcc9Nwb5BA9t92WKhVb6Ton65k",
    "proofs": [
        "4Kj3axM8JLMAsyksNiFbXceVbANWeUhioH85yEF6gRfD36SJUqgwxBnyNkfRGJT2RtvGWFtbNrDafPhgyF4dYzxU",
        "46fS8cEBKi2BXkee2nu3Tzxq2rT2i4xStZrQCh9yKCcfHGiFLYz2xisgfLzXmBWo9siAzi5GDARH87ufCvNi1xba"
    ],
    "script": "base64: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",
    "height": 3577980,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6PkNEyMhwoXcGVyLZ2s5QRX4LXSj3h7rVY3W6WZBtxvd
Next: D68n4uT8fKVVzxhcM7pBUVeotsUkuw4oXTPBXQeyTnyD

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

github/deemru/w8io/3ef1775 
91.98 ms ◑