2022.07.18 20:20 [3211028] smart account 3PC9BfRwJWWiw9AREE2B3eWzCks3CYtg4yo > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8EY7MiBXHtf48w9NuhS79LMLTo8GCdWME4Sm2d2EzJJW",
    "fee": 2800000,
    "feeAssetId": null,
    "timestamp": 1658164188455,
    "version": 1,
    "sender": "3PC9BfRwJWWiw9AREE2B3eWzCks3CYtg4yo",
    "senderPublicKey": "BRnVwSVctnV8pge5vRpsJdWnkjWEJspFb6QvrmZvu3Ht",
    "proofs": [
        "U9NiVbChhpLKB7Q8bMWeCwa3JfZjoBnX4kKm6uWRkUaCbFtQmPDionZGh8YcQY9LnfAtixuVBTmMh8p2ZFU6Jbz",
        "22sFofRSMuxBjkwwMWmFEZi2CL5241GF2HGhH4wpFJwgMPhiggrF5jum4ZG5wunar19UzXeCd6HRnWqprfcTH9gR",
        "3FpQ1FnERsFGU31RpmMA9twMTyzau2GBncvRRrogqSYYap5jtaW6j1Kr9N5s3oSeBeiMYaYeouvgoFtvgstQ9RCZ",
        "4LxPfqjxm8ChbbhZdTqVJmFCPehh8K8sQKHpzuytZjdbApTfLC9JJqEqcsinvAuMR1qAT7TrKnh7VRNWfTnXK8Q8"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3211028,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: AvnqrQgPLcsmPcT4hjLCQSqSnekFU2nrwXSpdgCCosir
Next: Du2VrsbvTsWEzdbHYUBMiLPntXjvoFtbZzbegENZmTrb

Diff: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
-
let revisionNum = "1a259d3c5e70666edebb759fe05d68e018bfa446"
4
+
let revisionNum = "20aa3c344022fc06f0a910f598551fa67e5a6d1b"
5
5
 
6
6
 
func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("Mandatory this." + key) + " is not defined"))
7
7
 
618
618
 
                    let lAmt0 = $t02686026922._3
619
619
 
                    let lIdKEY0 = $t02686026922._4
620
620
 
                    let lId0 = $t02686026922._5
621
-
                    let $t02692526987 = readNodeInfo(1)
622
-
                    let nAddr1 = $t02692526987._1
623
-
                    let lAmtKEY1 = $t02692526987._2
624
-
                    let lAmt1 = $t02692526987._3
625
-
                    let lIdKEY1 = $t02692526987._4
626
-
                    let lId1 = $t02692526987._5
627
-
                    let newL0 = Lease(nAddr0, (lAmt0 - ((lAmt * expCount) / 2)))
628
-
                    let newL1 = Lease(nAddr1, (lAmt1 - ((lAmt * expCount) / 2)))
621
+
                    let newL0 = Lease(nAddr0, (lAmt0 - (lAmt * expCount)))
629
622
 
                    let validation = invoke(nodeRegAddr, "validateAndApproveLeasings", [nListS], nil)
630
623
 
                    if ((validation == validation))
631
624
 
                        then {
635
628
 
                                (a ++ [la, BinaryEntry(getLeaseIdByAddressKey(node), lcalc(la)), IntegerEntry(getLeaseAmountByAddressKey(node), lAmt)])
636
629
 
                                }
637
630
 
638
-
                            ([StringEntry(lGroupNodeListKEY, nListS), BinaryEntry(lIdKEY0, lcalc(newL0)), BinaryEntry(lIdKEY1, lcalc(newL1)), IntegerEntry(lAmtKEY0, newL0.amount), IntegerEntry(lAmtKEY1, newL1.amount), LeaseCancel(lId0), LeaseCancel(lId1), newL0, newL1] ++ {
631
+
                            ([StringEntry(lGroupNodeListKEY, nListS), BinaryEntry(lIdKEY0, lcalc(newL0)), IntegerEntry(lAmtKEY0, newL0.amount), LeaseCancel(lId0), newL0] ++ {
639
632
 
                                let $l = nIdxs
640
633
 
                                let $s = size($l)
641
634
 
                                let $acc0 = nil
669
662
 
        then throw("rebalanceLeasings not authorized")
670
663
 
        else {
671
664
 
            let unleaseAmt = ((amount / size(nList)) + 1)
672
-
            let $t02840428466 = readNodeInfo(0)
673
-
            let nAddr0 = $t02840428466._1
674
-
            let lAmtKEY0 = $t02840428466._2
675
-
            let lAmt0 = $t02840428466._3
676
-
            let lIdKEY0 = $t02840428466._4
677
-
            let lId0 = $t02840428466._5
665
+
            let $t02816228224 = readNodeInfo(0)
666
+
            let nAddr0 = $t02816228224._1
667
+
            let lAmtKEY0 = $t02816228224._2
668
+
            let lAmt0 = $t02816228224._3
669
+
            let lIdKEY0 = $t02816228224._4
670
+
            let lId0 = $t02816228224._5
678
671
 
            let newL0 = Lease(nAddr0, (lAmt0 + (unleaseAmt * size(nList))))
679
672
 
            func forEachNodeDoUnlease (a,i) =             {
680
673
 
                let node = nList[i]
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
-
let revisionNum = "1a259d3c5e70666edebb759fe05d68e018bfa446"
4
+
let revisionNum = "20aa3c344022fc06f0a910f598551fa67e5a6d1b"
5
5
 
6
6
 
func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("Mandatory this." + key) + " is not defined"))
7
7
 
8
8
 
9
9
 
func lcalc (l) = calculateLeaseId(l)
10
10
 
11
11
 
12
12
 
func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
13
13
 
14
14
 
15
15
 
func getStringByKey (key) = valueOrElse(getString(this, key), "")
16
16
 
17
17
 
18
18
 
func getBoolByKey (key) = valueOrElse(getBoolean(this, key), false)
19
19
 
20
20
 
21
21
 
func getNumberByAddressAndKey (address,key) = valueOrElse(getInteger(addressFromStringValue(address), key), 0)
22
22
 
23
23
 
24
24
 
func getStringByAddressAndKey (address,key) = valueOrElse(getString(addressFromStringValue(address), key), "")
25
25
 
26
26
 
27
27
 
func getBoolByAddressAndKey (address,key) = valueOrElse(getBoolean(addressFromStringValue(address), key), false)
28
28
 
29
29
 
30
30
 
func asAnyList (v) = match v {
31
31
 
    case l: List[Any] => 
32
32
 
        l
33
33
 
    case _ => 
34
34
 
        throw("fail to cast into List[Any]")
35
35
 
}
36
36
 
37
37
 
38
38
 
func asString (v) = match v {
39
39
 
    case s: String => 
40
40
 
        s
41
41
 
    case _ => 
42
42
 
        throw("fail to cast into String")
43
43
 
}
44
44
 
45
45
 
46
46
 
func asInt (v) = match v {
47
47
 
    case i: Int => 
48
48
 
        i
49
49
 
    case _ => 
50
50
 
        throw("fail to cast into Int")
51
51
 
}
52
52
 
53
53
 
54
54
 
func asPayment (v) = match v {
55
55
 
    case p: AttachedPayment => 
56
56
 
        p
57
57
 
    case _ => 
58
58
 
        throw("fail to cast into AttachedPayment")
59
59
 
}
60
60
 
61
61
 
62
62
 
func asSwapParamsSTRUCT (v) = match v {
63
63
 
    case struct: (Int, Int, Int, Int, Int) => 
64
64
 
        struct
65
65
 
    case _ => 
66
66
 
        throw("fail to cast into Int")
67
67
 
}
68
68
 
69
69
 
70
70
 
let SEP = "__"
71
71
 
72
72
 
let WAVELET = 100000000
73
73
 
74
74
 
let PAULI = 1000000
75
75
 
76
76
 
let PRICELET = 1000000
77
77
 
78
78
 
let DEFAULTSWAPFEE = 20000
79
79
 
80
80
 
let IdxNetAmount = 0
81
81
 
82
82
 
let IdxFeeAmount = 1
83
83
 
84
84
 
let IdxGrossAmount = 2
85
85
 
86
86
 
let NeutrinoAssetIdKey = "neutrino_asset_id"
87
87
 
88
88
 
let BondAssetIdKey = "bond_asset_id"
89
89
 
90
90
 
let AuctionContractKey = "auction_contract"
91
91
 
92
92
 
let NsbtStakingContractKey = "nsbtStakingContract"
93
93
 
94
94
 
let LiquidationContractKey = "liquidation_contract"
95
95
 
96
96
 
let RPDContractKey = "rpd_contract"
97
97
 
98
98
 
let ContolContractKey = "control_contract"
99
99
 
100
100
 
let MathContractKey = "math_contract"
101
101
 
102
102
 
let BalanceWavesLockIntervalKey = "balance_waves_lock_interval"
103
103
 
104
104
 
let BalanceNeutrinoLockIntervalKey = "balance_neutrino_lock_interval"
105
105
 
106
106
 
let MinWavesSwapAmountKey = "min_waves_swap_amount"
107
107
 
108
108
 
let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
109
109
 
110
110
 
let NodeOracleProviderPubKeyKey = "node_oracle_provider"
111
111
 
112
112
 
let NeutrinoOutFeePartKey = "neutrinoOut_swap_feePart"
113
113
 
114
114
 
let WavesOutFeePartKey = "wavesOut_swap_feePart"
115
115
 
116
116
 
func keyNodeRegistry (address) = ("%s__" + address)
117
117
 
118
118
 
119
119
 
let PriceKey = "price"
120
120
 
121
121
 
let PriceIndexKey = "price_index"
122
122
 
123
123
 
let IsBlockedKey = "is_blocked"
124
124
 
125
125
 
func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
126
126
 
127
127
 
128
128
 
func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
129
129
 
130
130
 
131
131
 
func getStakingNodeByIndex (idx) = getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP))
132
132
 
133
133
 
134
134
 
func getStakingNodeAddressByIndex (idx) = addressFromStringValue(getStakingNodeByIndex(idx))
135
135
 
136
136
 
137
137
 
func getReservedAmountForSponsorship () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], SEP)), (1000 * WAVELET))
138
138
 
139
139
 
140
140
 
func getBalanceUnlockBlockKey (owner) = ("balance_unlock_block_" + owner)
141
141
 
142
142
 
143
143
 
func getLeaseIdKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "id"], SEP)
144
144
 
145
145
 
146
146
 
func getLeaseIdByAddressKey (nodeAddress) = makeString(["%s%s%s", "leaseByAddress", nodeAddress, "id"], SEP)
147
147
 
148
148
 
149
149
 
func getLeaseAmountKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "amount"], SEP)
150
150
 
151
151
 
152
152
 
func getLeaseAmountByAddressKey (nodeAddress) = makeString(["%s%s%s", "leaseByAddress", nodeAddress, "amount"], SEP)
153
153
 
154
154
 
155
155
 
func getLeaseGroupNodeListKey (groupNum) = makeString(["%s%d%s", "leaseGroup", toString(groupNum), "nodeList"], SEP)
156
156
 
157
157
 
158
158
 
func minSwapAmountKEY (swapType) = (("min_" + swapType) + "_swap_amount")
159
159
 
160
160
 
161
161
 
func totalLockedKEY (swapType) = ("balance_lock_" + swapType)
162
162
 
163
163
 
164
164
 
func totalLockedByUserKEY (swapType,owner) = makeString(["balance_lock", swapType, owner], "_")
165
165
 
166
166
 
167
167
 
func balanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval")
168
168
 
169
169
 
170
170
 
func nodeBalanceLockIntervalKEY () = "balance_node_lock_interval"
171
171
 
172
172
 
173
173
 
func outFeePartKEY (swapType) = (swapType + "Out_swap_feePart")
174
174
 
175
175
 
176
176
 
func swapsTimeframeKEY () = "swaps_timeframe"
177
177
 
178
178
 
179
179
 
func minSwapAmountREAD (swapType) = valueOrElse(getInteger(this, minSwapAmountKEY(swapType)), 0)
180
180
 
181
181
 
182
182
 
func swapsTimeframeREAD () = valueOrElse(getInteger(this, swapsTimeframeKEY()), 1440)
183
183
 
184
184
 
185
185
 
func totalLockedREAD (swapType) = valueOrElse(getInteger(this, totalLockedKEY(swapType)), 0)
186
186
 
187
187
 
188
188
 
func totalLockedByUserREAD (swapType,owner) = valueOrElse(getInteger(this, totalLockedByUserKEY(swapType, owner)), 0)
189
189
 
190
190
 
191
191
 
func balanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, balanceLockIntervalKEY(swapType)), 1440)
192
192
 
193
193
 
194
194
 
func nodeBalanceLockIntervalREAD () = valueOrElse(getInteger(this, nodeBalanceLockIntervalKEY()), 1)
195
195
 
196
196
 
197
197
 
func keySwapUserSpentInPeriod (userAddress) = makeString(["%s%s", "swapUserSpentInPeriod", userAddress], SEP)
198
198
 
199
199
 
200
200
 
func keyUserLastSwapHeight (userAddress) = makeString(["%s%s", "userLastSwapHeight", userAddress], SEP)
201
201
 
202
202
 
203
203
 
func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
204
204
 
205
205
 
206
206
 
func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
207
207
 
208
208
 
209
209
 
func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
210
210
 
211
211
 
212
212
 
func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
213
213
 
214
214
 
215
215
 
func minSwapAmountFAIL (swapType,minSwapAmount) = throw(((("The specified amount in " + swapType) + " swap is less than the required minimum of ") + toString(minSwapAmount)))
216
216
 
217
217
 
218
218
 
func emergencyShutdownFAIL () = throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
219
219
 
220
220
 
221
221
 
func priceIndexFAIL (index,priceIndex,indexHeight,unlockHeight,prevIndexHeight) = throw(((((((((("invalid price history index: index=" + toString(index)) + " priceIndex=") + toString(priceIndex)) + " indexHeight=") + toString(indexHeight)) + " unlockHeight=") + toString(unlockHeight)) + " prevIndexHeight=") + toString(prevIndexHeight)))
222
222
 
223
223
 
224
224
 
let liquidationContract = getStringByKey(LiquidationContractKey)
225
225
 
226
226
 
let nsbtStakingContractStr = getStringByKey(NsbtStakingContractKey)
227
227
 
228
228
 
let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
229
229
 
230
230
 
let auctionContract = getStringByKey(AuctionContractKey)
231
231
 
232
232
 
let rpdContract = getStringByKey(RPDContractKey)
233
233
 
234
234
 
let controlContractStr = getStringByKey(ContolContractKey)
235
235
 
236
236
 
let controlContract = addressFromStringValue(controlContractStr)
237
237
 
238
238
 
let mathContractAddress = getStringByKey(MathContractKey)
239
239
 
240
240
 
let priceIndex = getNumberByAddressAndKey(controlContractStr, PriceIndexKey)
241
241
 
242
242
 
let isBlocked = getBoolByAddressAndKey(controlContractStr, IsBlockedKey)
243
243
 
244
244
 
let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
245
245
 
246
246
 
let bondAssetId = fromBase58String("6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g")
247
247
 
248
248
 
let deprecatedBondAssetId = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
249
249
 
250
250
 
let neutrinoContract = this
251
251
 
252
252
 
let mathContract = addressFromStringValue(mathContractAddress)
253
253
 
254
254
 
let nsbtStakingContract = addressFromStringValue(nsbtStakingContractStr)
255
255
 
256
256
 
let currentPrice = getNumberByAddressAndKey(controlContractStr, PriceKey)
257
257
 
258
258
 
func checkIsValidMinSponsoredFee (tx) = {
259
259
 
    let MINTRANSFERFEE = 100000
260
260
 
    let SponsoredFeeUpperBound = 1000
261
261
 
    let realNeutrinoFee = convertWavesToNeutrino(MINTRANSFERFEE, currentPrice)
262
262
 
    let minNeutrinoFee = (realNeutrinoFee * 2)
263
263
 
    let maxNeutrinoFee = fraction(realNeutrinoFee, SponsoredFeeUpperBound, 100)
264
264
 
    let inputFee = value(tx.minSponsoredAssetFee)
265
265
 
    if (if ((inputFee >= minNeutrinoFee))
266
266
 
        then (maxNeutrinoFee >= inputFee)
267
267
 
        else false)
268
268
 
        then (tx.assetId == neutrinoAssetId)
269
269
 
        else false
270
270
 
    }
271
271
 
272
272
 
273
273
 
func getPriceHistory (block) = getNumberByAddressAndKey(controlContractStr, getPriceHistoryKey(block))
274
274
 
275
275
 
276
276
 
func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContractStr, getHeightPriceByIndexKey(index))
277
277
 
278
278
 
279
279
 
func keyLockParamUserAmount (userAddress) = makeString(["%s%s%s", "paramByUser", userAddress, "amount"], SEP)
280
280
 
281
281
 
282
282
 
let sIdxSwapType = 1
283
283
 
284
284
 
let sIdxStatus = 2
285
285
 
286
286
 
let sIdxInAmount = 3
287
287
 
288
288
 
let sIdxPrice = 4
289
289
 
290
290
 
let sIdxOutNetAmount = 5
291
291
 
292
292
 
let sIdxOutFeeAmount = 6
293
293
 
294
294
 
let sIdxStartHeight = 7
295
295
 
296
296
 
let sIdxStartTimestamp = 8
297
297
 
298
298
 
let sIdxEndHeight = 9
299
299
 
300
300
 
let sIdxEndTimestamp = 10
301
301
 
302
302
 
let sIdxSelfUnlockHeight = 11
303
303
 
304
304
 
let sIdxRandUnlockHeight = 12
305
305
 
306
306
 
let sIdxIndex = 13
307
307
 
308
308
 
let sIdxWithdrawTxId = 14
309
309
 
310
310
 
let sIdxMinRand = 15
311
311
 
312
312
 
let sIdxMaxRand = 16
313
313
 
314
314
 
func swapKEY (userAddress,txId) = makeString(["%s%s", userAddress, txId], SEP)
315
315
 
316
316
 
317
317
 
func strSwapDATA (swapType,status,inAmount,price,outNetAmount,outFeeAmount,startHeight,startTimestamp,endHeight,endTimestamp,selfUnlockHeight,randUnlockHeight,index,withdrawTxId,randMin,randMax) = makeString(["%s%s%d%d%d%d%d%d%d%d%d%d%d%s", swapType, status, inAmount, price, outNetAmount, outFeeAmount, startHeight, startTimestamp, endHeight, endTimestamp, selfUnlockHeight, randUnlockHeight, index, withdrawTxId, randMin, randMax], SEP)
318
318
 
319
319
 
320
320
 
func pendingSwapDATA (swapType,inAssetAmount,selfUnlockHeight) = strSwapDATA(swapType, "PENDING", toString(inAssetAmount), "0", "0", "0", toString(height), toString(lastBlock.timestamp), "0", "0", toString(selfUnlockHeight), "0", "0", "NULL", "0", "0")
321
321
 
322
322
 
323
323
 
func finishSwapDATA (dataArray,price,outNetAmount,outFeeAmount,randUnlockHeight,index,withdrawTxId) = strSwapDATA(dataArray[sIdxSwapType], "FINISHED", dataArray[sIdxInAmount], toString(price), toString(outNetAmount), toString(outFeeAmount), dataArray[sIdxStartHeight], dataArray[sIdxStartTimestamp], toString(height), toString(lastBlock.timestamp), dataArray[sIdxSelfUnlockHeight], toString(randUnlockHeight), toString(index), withdrawTxId, dataArray[sIdxMinRand], dataArray[sIdxMaxRand])
324
324
 
325
325
 
326
326
 
func swapDataFailOrREAD (userAddress,swapTxId) = {
327
327
 
    let swapKey = swapKEY(userAddress, swapTxId)
328
328
 
    split(valueOrErrorMessage(getString(this, swapKey), ("no swap data for " + swapKey)), SEP)
329
329
 
    }
330
330
 
331
331
 
332
332
 
func applyFees (amountGross,feePart) = {
333
333
 
    let feeAmount = fraction(amountGross, feePart, PAULI)
334
334
 
[(amountGross - feeAmount), feeAmount, amountGross]
335
335
 
    }
336
336
 
337
337
 
338
338
 
func abs (x) = if ((0 > x))
339
339
 
    then -(x)
340
340
 
    else x
341
341
 
342
342
 
343
343
 
func selectNode (unleaseAmount) = {
344
344
 
    let amountToLease = ((wavesBalance(neutrinoContract).available - unleaseAmount) - getReservedAmountForSponsorship())
345
345
 
    let oldLeased0 = getNumberByKey(getLeaseAmountKey(0))
346
346
 
    let oldLeased1 = getNumberByKey(getLeaseAmountKey(1))
347
347
 
    let newLeased0 = (amountToLease + oldLeased0)
348
348
 
    let newLeased1 = (amountToLease + oldLeased1)
349
349
 
    if (if ((newLeased0 > 0))
350
350
 
        then true
351
351
 
        else (newLeased1 > 0))
352
352
 
        then {
353
353
 
            let delta0 = abs((newLeased0 - oldLeased1))
354
354
 
            let delta1 = abs((newLeased1 - oldLeased0))
355
355
 
            if ((delta1 >= delta0))
356
356
 
                then $Tuple2(0, newLeased0)
357
357
 
                else $Tuple2(1, newLeased1)
358
358
 
            }
359
359
 
        else $Tuple2(-1, 0)
360
360
 
    }
361
361
 
362
362
 
363
363
 
func thisOnly (i) = if ((i.caller != this))
364
364
 
    then throw("Permission denied: this contract only allowed")
365
365
 
    else true
366
366
 
367
367
 
368
368
 
func prepareUnleaseAndLease (unleaseAmount) = {
369
369
 
    let nodeTuple = selectNode(unleaseAmount)
370
370
 
    let nodeIndex = nodeTuple._1
371
371
 
    let newLeaseAmount = nodeTuple._2
372
372
 
    if ((newLeaseAmount > 0))
373
373
 
        then {
374
374
 
            let leaseIdKey = getLeaseIdKey(nodeIndex)
375
375
 
            let oldLease = getBinary(this, leaseIdKey)
376
376
 
            let unleaseOrEmpty = if (isDefined(oldLease))
377
377
 
                then [LeaseCancel(value(oldLease))]
378
378
 
                else nil
379
379
 
            let leaseAmountKey = getLeaseAmountKey(nodeIndex)
380
380
 
            let lease = Lease(getStakingNodeAddressByIndex(nodeIndex), newLeaseAmount)
381
381
 
            (unleaseOrEmpty ++ [lease, BinaryEntry(leaseIdKey, lcalc(lease)), IntegerEntry(getLeaseAmountKey(nodeIndex), newLeaseAmount)])
382
382
 
            }
383
383
 
        else nil
384
384
 
    }
385
385
 
386
386
 
387
387
 
func readNodeInfo (nodeIdx) = {
388
388
 
    let nodeAddress = getStakingNodeAddressByIndex(nodeIdx)
389
389
 
    let leasedAmtKEY = getLeaseAmountKey(nodeIdx)
390
390
 
    let leasedAmt = getNumberByKey(leasedAmtKEY)
391
391
 
    let leaseIdKEY = getLeaseIdKey(nodeIdx)
392
392
 
    let leaseId = value(getBinary(this, leaseIdKEY))
393
393
 
    $Tuple5(nodeAddress, leasedAmtKEY, leasedAmt, leaseIdKEY, leaseId)
394
394
 
    }
395
395
 
396
396
 
397
397
 
func commonSwap (swapType,pmtAmount,userAddressStr,txId58,swapParamsByUserSYSREADONLY) = {
398
398
 
    let $t01633916419 = swapParamsByUserSYSREADONLY
399
399
 
    let swapLimitMax = $t01633916419._1
400
400
 
    let swapLimitSpent = $t01633916419._2
401
401
 
    let blcks2LmtReset = $t01633916419._3
402
402
 
    let minSwapAmount = minSwapAmountREAD(swapType)
403
403
 
    let totalLocked = totalLockedREAD(swapType)
404
404
 
    let totalLockedByUser = totalLockedByUserREAD(swapType, userAddressStr)
405
405
 
    let nodeAddress = getStakingNodeByIndex(0)
406
406
 
    let priceByIndex = getPriceHistory(getHeightPriceByIndex(priceIndex))
407
407
 
    let isSwapByNode = (nodeAddress == userAddressStr)
408
408
 
    let balanceLockMaxInterval = if (isSwapByNode)
409
409
 
        then nodeBalanceLockIntervalREAD()
410
410
 
        else balanceLockIntervalREAD(swapType)
411
411
 
    let selfUnlockHeight = (height + balanceLockMaxInterval)
412
412
 
    let swapUsdnVolume = if ((swapType == "neutrino"))
413
413
 
        then pmtAmount
414
414
 
        else convertWavesToNeutrino(pmtAmount, priceByIndex)
415
415
 
    if ((minSwapAmount > pmtAmount))
416
416
 
        then minSwapAmountFAIL(swapType, minSwapAmount)
417
417
 
        else if (if (!(isSwapByNode))
418
418
 
            then (swapLimitSpent > 0)
419
419
 
            else false)
420
420
 
            then throw(("You have exceeded swap limit! Next allowed swap height is " + toString((height + blcks2LmtReset))))
421
421
 
            else if (if (!(isSwapByNode))
422
422
 
                then (swapUsdnVolume > swapLimitMax)
423
423
 
                else false)
424
424
 
                then throw(((("You have exceeded your swap limit! Requested: " + toString(swapUsdnVolume)) + ", available: ") + toString(swapLimitMax)))
425
425
 
                else if (isBlocked)
426
426
 
                    then emergencyShutdownFAIL()
427
427
 
                    else {
428
428
 
                        let leasePart = if ((swapType == "waves"))
429
429
 
                            then prepareUnleaseAndLease(0)
430
430
 
                            else nil
431
431
 
                        $Tuple2(([IntegerEntry(keySwapUserSpentInPeriod(userAddressStr), swapUsdnVolume), IntegerEntry(keyUserLastSwapHeight(userAddressStr), height), IntegerEntry(totalLockedByUserKEY(swapType, userAddressStr), (totalLockedByUser + pmtAmount)), IntegerEntry(getBalanceUnlockBlockKey(userAddressStr), selfUnlockHeight), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmtAmount)), StringEntry(swapKEY(userAddressStr, txId58), pendingSwapDATA(swapType, pmtAmount, selfUnlockHeight))] ++ leasePart), unit)
432
432
 
                        }
433
433
 
    }
434
434
 
435
435
 
436
436
 
func commonWithdraw (account,index,swapTxId,withdrawTxId) = {
437
437
 
    let userAddress = addressFromStringValue(account)
438
438
 
    let dataArray = swapDataFailOrREAD(account, swapTxId)
439
439
 
    let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
440
440
 
    let swapType = dataArray[sIdxSwapType]
441
441
 
    let inAmount = parseIntValue(dataArray[sIdxInAmount])
442
442
 
    let swapStatus = dataArray[sIdxStatus]
443
443
 
    let startHeight = parseIntValue(dataArray[sIdxStartHeight])
444
444
 
    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
445
445
 
    let totalLocked = totalLockedREAD(swapType)
446
446
 
    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
447
447
 
    let unlockHeight = selfUnlockHeight
448
448
 
    let indexHeight = getHeightPriceByIndex(index)
449
449
 
    let prevIndexHeight = getHeightPriceByIndex((index - 1))
450
450
 
    let priceByIndex = getPriceHistory(indexHeight)
451
451
 
    let outAmountGrossTuple = if ((swapType == "waves"))
452
452
 
        then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
453
453
 
        else if ((swapType == "neutrino"))
454
454
 
            then $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
455
455
 
            else throw(("Unsupported swap type " + swapType))
456
456
 
    let payoutsArray = applyFees(outAmountGrossTuple._1, outFeePart)
457
457
 
    let outNetAmount = payoutsArray[IdxNetAmount]
458
458
 
    let outFeeAmount = payoutsArray[IdxFeeAmount]
459
459
 
    if (isBlocked)
460
460
 
        then emergencyShutdownFAIL()
461
461
 
        else if ((swapStatus != "PENDING"))
462
462
 
            then throw("swap has been already processed")
463
463
 
            else if ((unlockHeight > height))
464
464
 
                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
465
465
 
                else if (if (if ((index > priceIndex))
466
466
 
                    then true
467
467
 
                    else (unlockHeight > indexHeight))
468
468
 
                    then true
469
469
 
                    else if ((prevIndexHeight != 0))
470
470
 
                        then (prevIndexHeight >= unlockHeight)
471
471
 
                        else false)
472
472
 
                    then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
473
473
 
                    else if ((0 >= payoutsArray[IdxGrossAmount]))
474
474
 
                        then throw("balance equals zero")
475
475
 
                        else if (if ((0 > outFeePart))
476
476
 
                            then true
477
477
 
                            else (outFeePart >= PAULI))
478
478
 
                            then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
479
479
 
                            else {
480
480
 
                                let unleaseAmount = if (if ((swapType == "neutrino"))
481
481
 
                                    then (outAmountGrossTuple._1 > 0)
482
482
 
                                    else false)
483
483
 
                                    then outAmountGrossTuple._1
484
484
 
                                    else 0
485
485
 
                                let state = [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAmountGrossTuple._2), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, withdrawTxId))]
486
486
 
                                $Tuple3(state, AttachedPayment(outAmountGrossTuple._2, outFeeAmount), unleaseAmount)
487
487
 
                                }
488
488
 
    }
489
489
 
490
490
 
491
491
 
@Callable(i)
492
492
 
func constructor (neutrinoAssetIdPrm,bondAssetIdPrm,auctionContractPrm,liquidationContractPrm,rpdContractPrm,nodeOracleProviderPubKeyPrm,balanceWavesLockIntervalPrm,balanceNeutrinoLockIntervalPrm,minWavesSwapAmountPrm,minNeutrinoSwapAmountPrm,neutrinoOutFeePartPrm,wavesOutFeePartPrm) = {
493
493
 
    let checkCaller = thisOnly(i)
494
494
 
    if ((checkCaller == checkCaller))
495
495
 
        then if ((size(i.payments) != 0))
496
496
 
            then throw("no payments allowed")
497
497
 
            else [StringEntry(NeutrinoAssetIdKey, neutrinoAssetIdPrm), StringEntry(BondAssetIdKey, bondAssetIdPrm), StringEntry(AuctionContractKey, auctionContractPrm), StringEntry(LiquidationContractKey, liquidationContractPrm), StringEntry(RPDContractKey, rpdContractPrm), StringEntry(NodeOracleProviderPubKeyKey, nodeOracleProviderPubKeyPrm), IntegerEntry(BalanceWavesLockIntervalKey, balanceWavesLockIntervalPrm), IntegerEntry(BalanceNeutrinoLockIntervalKey, balanceNeutrinoLockIntervalPrm), IntegerEntry(MinWavesSwapAmountKey, minWavesSwapAmountPrm), IntegerEntry(MinNeutrinoSwapAmountKey, minNeutrinoSwapAmountPrm), IntegerEntry(NeutrinoOutFeePartKey, neutrinoOutFeePartPrm), IntegerEntry(WavesOutFeePartKey, wavesOutFeePartPrm)]
498
498
 
        else throw("Strict value is not equal to itself.")
499
499
 
    }
500
500
 
501
501
 
502
502
 
503
503
 
@Callable(i)
504
504
 
func constructorV2 (mathContract,nsbtStakingContract,swapsTimeframeBlocks) = {
505
505
 
    let checkCaller = thisOnly(i)
506
506
 
    if ((checkCaller == checkCaller))
507
507
 
        then if ((size(i.payments) != 0))
508
508
 
            then throw("no payments allowed")
509
509
 
            else [StringEntry(MathContractKey, mathContract), StringEntry(NsbtStakingContractKey, nsbtStakingContract), IntegerEntry(swapsTimeframeKEY(), swapsTimeframeBlocks)]
510
510
 
        else throw("Strict value is not equal to itself.")
511
511
 
    }
512
512
 
513
513
 
514
514
 
515
515
 
@Callable(i)
516
516
 
func swapWavesToNeutrino () = if ((size(i.payments) != 1))
517
517
 
    then throw("swapWavesToNeutrino require only one payment")
518
518
 
    else {
519
519
 
        let pmt = value(i.payments[0])
520
520
 
        if (isDefined(pmt.assetId))
521
521
 
            then throw("Only Waves token is allowed for swapping.")
522
522
 
            else {
523
523
 
                let userAddress = toString(i.caller)
524
524
 
                let txId58 = toBase58String(i.transactionId)
525
525
 
                let swapParamsSTRUCT = asSwapParamsSTRUCT(invoke(this, "swapParamsByUserSYSREADONLY", [userAddress, 0], nil))
526
526
 
                let commonSwapResult = commonSwap("waves", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
527
527
 
                commonSwapResult
528
528
 
                }
529
529
 
        }
530
530
 
531
531
 
532
532
 
533
533
 
@Callable(i)
534
534
 
func swapNeutrinoToWaves () = if ((size(i.payments) != 1))
535
535
 
    then throw("swapNeutrinoToWaves require only one payment")
536
536
 
    else {
537
537
 
        let pmt = value(i.payments[0])
538
538
 
        if ((pmt.assetId != neutrinoAssetId))
539
539
 
            then throw("Only appropriate Neutrino tokens are allowed for swapping.")
540
540
 
            else {
541
541
 
                let userAddress = toString(i.caller)
542
542
 
                let txId58 = toBase58String(i.transactionId)
543
543
 
                let swapParamsSTRUCT = asSwapParamsSTRUCT(invoke(this, "swapParamsByUserSYSREADONLY", [userAddress, 0], nil))
544
544
 
                let commonSwapResult = commonSwap("neutrino", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
545
545
 
                commonSwapResult
546
546
 
                }
547
547
 
        }
548
548
 
549
549
 
550
550
 
551
551
 
@Callable(i)
552
552
 
func withdraw (account,index,swapTxId) = {
553
553
 
    let txId = toBase58String(i.transactionId)
554
554
 
    if ((size(i.payments) != 0))
555
555
 
        then throw("no payments allowed")
556
556
 
        else {
557
557
 
            let commonTuple = commonWithdraw(account, index, swapTxId, txId)
558
558
 
            let state = commonTuple._1
559
559
 
            let fee = commonTuple._2
560
560
 
            let unleaseAmt = commonTuple._3
561
561
 
            let unleaseInvOrEmpty = invoke(this, "internalUnleaseAndLease", [unleaseAmt], nil)
562
562
 
            if ((unleaseInvOrEmpty == unleaseInvOrEmpty))
563
563
 
                then if ((0 >= fee.amount))
564
564
 
                    then state
565
565
 
                    else {
566
566
 
                        let nsbtStakingReward = invoke(nsbtStakingContract, "deposit", nil, [fee])
567
567
 
                        if ((nsbtStakingReward == nsbtStakingReward))
568
568
 
                            then state
569
569
 
                            else throw("Strict value is not equal to itself.")
570
570
 
                        }
571
571
 
                else throw("Strict value is not equal to itself.")
572
572
 
            }
573
573
 
    }
574
574
 
575
575
 
576
576
 
577
577
 
@Callable(i)
578
578
 
func internalUnleaseAndLease (unleaseAmount) = if ((i.caller != this))
579
579
 
    then throw("internalUnleaseAndLease is not public method")
580
580
 
    else prepareUnleaseAndLease(unleaseAmount)
581
581
 
582
582
 
583
583
 
584
584
 
@Callable(i)
585
585
 
func transferUsdnToUser (amount,addr) = if ((i.caller != addressFromStringValue(auctionContract)))
586
586
 
    then throw("Only auction contract is authorized")
587
587
 
    else [ScriptTransfer(addressFromStringValue(addr), amount, neutrinoAssetId)]
588
588
 
589
589
 
590
590
 
591
591
 
@Callable(i)
592
592
 
func acceptWaves () = if ((i.caller != addressFromStringValue(auctionContract)))
593
593
 
    then throw("Currently only auction contract is allowed to call")
594
594
 
    else $Tuple2(prepareUnleaseAndLease(0), "success")
595
595
 
596
596
 
597
597
 
598
598
 
@Callable(i)
599
599
 
func approveLeasings (nListS,groupNum,lAmt) = {
600
600
 
    let nIdxs = [0, 1, 2, 3, 4, 5, 6, 7]
601
601
 
    let mngPubS = valueOrElse(getString("%s%s__cfg__leasingManagerPub"), "7AUMX54ukYMYvPmma7yoFf5NjZhs4Bu5nz3Ez9EV8sur")
602
602
 
    let mngPub = fromBase58String(mngPubS)
603
603
 
    let nodeRegAddrStr = valueOrElse(getString("%s%s__cfg__nodesRegistryAddress"), "3P9vKqQKjUdmpXAfiWau8krREYAY1Xr69pE")
604
604
 
    let nodeRegAddr = addressFromStringValue(nodeRegAddrStr)
605
605
 
    let lGroupNodeListKEY = getLeaseGroupNodeListKey(groupNum)
606
606
 
    let lGrNodeOpt = getString(this, lGroupNodeListKEY)
607
607
 
    if (isDefined(lGrNodeOpt))
608
608
 
        then throw((("group " + toString(groupNum)) + " already initialized"))
609
609
 
        else {
610
610
 
            let nList = split(nListS, SEP)
611
611
 
            let expCount = size(nIdxs)
612
612
 
            if ((i.callerPublicKey != mngPub))
613
613
 
                then throw("approveLeasings not authorized")
614
614
 
                else {
615
615
 
                    let $t02686026922 = readNodeInfo(0)
616
616
 
                    let nAddr0 = $t02686026922._1
617
617
 
                    let lAmtKEY0 = $t02686026922._2
618
618
 
                    let lAmt0 = $t02686026922._3
619
619
 
                    let lIdKEY0 = $t02686026922._4
620
620
 
                    let lId0 = $t02686026922._5
621
-
                    let $t02692526987 = readNodeInfo(1)
622
-
                    let nAddr1 = $t02692526987._1
623
-
                    let lAmtKEY1 = $t02692526987._2
624
-
                    let lAmt1 = $t02692526987._3
625
-
                    let lIdKEY1 = $t02692526987._4
626
-
                    let lId1 = $t02692526987._5
627
-
                    let newL0 = Lease(nAddr0, (lAmt0 - ((lAmt * expCount) / 2)))
628
-
                    let newL1 = Lease(nAddr1, (lAmt1 - ((lAmt * expCount) / 2)))
621
+
                    let newL0 = Lease(nAddr0, (lAmt0 - (lAmt * expCount)))
629
622
 
                    let validation = invoke(nodeRegAddr, "validateAndApproveLeasings", [nListS], nil)
630
623
 
                    if ((validation == validation))
631
624
 
                        then {
632
625
 
                            func forEachNodeValidateAndGenerateLease (a,i) =                             {
633
626
 
                                let node = nList[i]
634
627
 
                                let la = Lease(addressFromStringValue(node), lAmt)
635
628
 
                                (a ++ [la, BinaryEntry(getLeaseIdByAddressKey(node), lcalc(la)), IntegerEntry(getLeaseAmountByAddressKey(node), lAmt)])
636
629
 
                                }
637
630
 
638
-
                            ([StringEntry(lGroupNodeListKEY, nListS), BinaryEntry(lIdKEY0, lcalc(newL0)), BinaryEntry(lIdKEY1, lcalc(newL1)), IntegerEntry(lAmtKEY0, newL0.amount), IntegerEntry(lAmtKEY1, newL1.amount), LeaseCancel(lId0), LeaseCancel(lId1), newL0, newL1] ++ {
631
+
                            ([StringEntry(lGroupNodeListKEY, nListS), BinaryEntry(lIdKEY0, lcalc(newL0)), IntegerEntry(lAmtKEY0, newL0.amount), LeaseCancel(lId0), newL0] ++ {
639
632
 
                                let $l = nIdxs
640
633
 
                                let $s = size($l)
641
634
 
                                let $acc0 = nil
642
635
 
                                func $f0_1 ($a,$i) =                                 if (($i >= $s))
643
636
 
                                    then $a
644
637
 
                                    else forEachNodeValidateAndGenerateLease($a, $l[$i])
645
638
 
646
639
 
                                func $f0_2 ($a,$i) =                                 if (($i >= $s))
647
640
 
                                    then $a
648
641
 
                                    else throw("List size exceeds 8")
649
642
 
650
643
 
                                $f0_2($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)
651
644
 
                                })
652
645
 
                            }
653
646
 
                        else throw("Strict value is not equal to itself.")
654
647
 
                    }
655
648
 
            }
656
649
 
    }
657
650
 
658
651
 
659
652
 
660
653
 
@Callable(i)
661
654
 
func rebalanceLeasings (amount,groupNum) = {
662
655
 
    let nIdxs = [0, 1, 2, 3, 4, 5, 6, 7]
663
656
 
    let mngPubS = valueOrElse(getString("%s%s__cfg__leasingManagerPub"), "7AUMX54ukYMYvPmma7yoFf5NjZhs4Bu5nz3Ez9EV8sur")
664
657
 
    let mngPub = fromBase58String(mngPubS)
665
658
 
    let lGroupNodeListKEY = getLeaseGroupNodeListKey(groupNum)
666
659
 
    let nListS = getStringOrFail(this, lGroupNodeListKEY)
667
660
 
    let nList = split(nListS, SEP)
668
661
 
    if ((i.callerPublicKey != mngPub))
669
662
 
        then throw("rebalanceLeasings not authorized")
670
663
 
        else {
671
664
 
            let unleaseAmt = ((amount / size(nList)) + 1)
672
-
            let $t02840428466 = readNodeInfo(0)
673
-
            let nAddr0 = $t02840428466._1
674
-
            let lAmtKEY0 = $t02840428466._2
675
-
            let lAmt0 = $t02840428466._3
676
-
            let lIdKEY0 = $t02840428466._4
677
-
            let lId0 = $t02840428466._5
665
+
            let $t02816228224 = readNodeInfo(0)
666
+
            let nAddr0 = $t02816228224._1
667
+
            let lAmtKEY0 = $t02816228224._2
668
+
            let lAmt0 = $t02816228224._3
669
+
            let lIdKEY0 = $t02816228224._4
670
+
            let lId0 = $t02816228224._5
678
671
 
            let newL0 = Lease(nAddr0, (lAmt0 + (unleaseAmt * size(nList))))
679
672
 
            func forEachNodeDoUnlease (a,i) =             {
680
673
 
                let node = nList[i]
681
674
 
                let lIdKEY = getLeaseIdByAddressKey(node)
682
675
 
                let lId = getBinaryValue(this, lIdKEY)
683
676
 
                let lAmtKEY = getLeaseAmountByAddressKey(node)
684
677
 
                let lAmt = getIntegerValue(this, lAmtKEY)
685
678
 
                let ula = LeaseCancel(value(lId))
686
679
 
                let la = Lease(addressFromStringValue(node), (lAmt - unleaseAmt))
687
680
 
                (a ++ [LeaseCancel(value(lId)), la, BinaryEntry(lIdKEY, lcalc(la)), IntegerEntry(lAmtKEY, la.amount)])
688
681
 
                }
689
682
 
690
683
 
            ({
691
684
 
                let $l = nIdxs
692
685
 
                let $s = size($l)
693
686
 
                let $acc0 = nil
694
687
 
                func $f0_1 ($a,$i) =                 if (($i >= $s))
695
688
 
                    then $a
696
689
 
                    else forEachNodeDoUnlease($a, $l[$i])
697
690
 
698
691
 
                func $f0_2 ($a,$i) =                 if (($i >= $s))
699
692
 
                    then $a
700
693
 
                    else throw("List size exceeds 8")
701
694
 
702
695
 
                $f0_2($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)
703
696
 
                } ++ [BinaryEntry(lIdKEY0, lcalc(newL0)), IntegerEntry(lAmtKEY0, newL0.amount), LeaseCancel(lId0), newL0])
704
697
 
            }
705
698
 
    }
706
699
 
707
700
 
708
701
 
709
702
 
@Callable(i)
710
703
 
func swapParamsByUserSYSREADONLY (userAddressStr,nsbtDiff) = {
711
704
 
    let nsbtData = asAnyList(invoke(nsbtStakingContract, "nsbtStakingSYSREADONLY", [userAddressStr], nil))
712
705
 
    if ((nsbtData == nsbtData))
713
706
 
        then {
714
707
 
            let gnsbtAmt = (asInt(nsbtData[0]) + nsbtDiff)
715
708
 
            let gnsbtAmtTotal = (asInt(nsbtData[1]) + nsbtDiff)
716
709
 
            let swapLimitMax = asInt(invoke(mathContract, "calcSwapLimitREADONLY", [gnsbtAmt], nil))
717
710
 
            let lastSwapHeight = valueOrElse(getInteger(this, keyUserLastSwapHeight(userAddressStr)), 0)
718
711
 
            let swapLimitTimelifeBlocks = swapsTimeframeREAD()
719
712
 
            let passedBlocksAfterLastSwap = (height - lastSwapHeight)
720
713
 
            let isSwapTimelifeNew = (passedBlocksAfterLastSwap >= swapLimitTimelifeBlocks)
721
714
 
            let swapLimitSpent = if (isSwapTimelifeNew)
722
715
 
                then 0
723
716
 
                else valueOrElse(getInteger(this, keySwapUserSpentInPeriod(userAddressStr)), 0)
724
717
 
            let blcks2LmtReset = if (isSwapTimelifeNew)
725
718
 
                then 0
726
719
 
                else (swapLimitTimelifeBlocks - passedBlocksAfterLastSwap)
727
720
 
            $Tuple2(nil, $Tuple5(swapLimitMax, swapLimitSpent, blcks2LmtReset, gnsbtAmt, gnsbtAmtTotal))
728
721
 
            }
729
722
 
        else throw("Strict value is not equal to itself.")
730
723
 
    }
731
724
 
732
725
 
733
726
 
@Verifier(tx)
734
727
 
func verify () = {
735
728
 
    let id = toBase58String(tx.id)
736
729
 
    let pubKeyAdminsListStr = makeString(["GJdLSaLiv5K7xuejac8mcRcHoyo3dPrESrvktG3a6MAR", "EYwZmURd5KKaQRBjsVa6g8DPisFoS6SovRJtFiL5gMHU", "DtmAfuDdCrHK8spdAeAYzq6MsZegeD9gnsrpuTRkCbVA", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"], SEP)
737
730
 
    let pubKeyAdminsList = split(valueOrElse(getString(controlContract, "%s__multisig"), pubKeyAdminsListStr), SEP)
738
731
 
    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
739
732
 
        then 1
740
733
 
        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
741
734
 
        then 1
742
735
 
        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
743
736
 
        then 1
744
737
 
        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
745
738
 
        then 2
746
739
 
        else 0))
747
740
 
    match tx {
748
741
 
        case sponsorTx: SponsorFeeTransaction => 
749
742
 
            if (checkIsValidMinSponsoredFee(sponsorTx))
750
743
 
                then (count >= 3)
751
744
 
                else false
752
745
 
        case _ => 
753
746
 
            (count >= 3)
754
747
 
    }
755
748
 
    }
756
749
 

github/deemru/w8io/786bc32 
83.20 ms ◑