2021.09.05 23:26 [2755156] smart account 3PC9BfRwJWWiw9AREE2B3eWzCks3CYtg4yo > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AsY92vFx2MsaRDFqNt14pT2Cn7rcmARse8fJNrJqSYjB",
    "fee": 14000000,
    "feeAssetId": null,
    "timestamp": 1630875556490,
    "version": 1,
    "sender": "3PC9BfRwJWWiw9AREE2B3eWzCks3CYtg4yo",
    "senderPublicKey": "BRnVwSVctnV8pge5vRpsJdWnkjWEJspFb6QvrmZvu3Ht",
    "proofs": [
        "3ECkZ6qeYnbuTJDjdGtpPAfEhwcE83TwAFZgM9LhBVkBAPWEFYj9jUiR1XqiwT4ELk4A7eh55MkFG9jFGSdjzmTm",
        "aDHsQ4JCmbPU1z5VKgYeTMitx7dJiBMSAdaozTnRhn3bFwj6mFn9VwWYDoze9V39f7A7iKsKTAAcBs99XRYZ87y",
        "3d125qr5YSY66NqshxpqZTpugo4HSVevA7EujnmFzqnmrJJ3eZmvD8G3wMEyxDjREtgG5kb96cHfNjARjDnJAhyS",
        "2c6ARMaQx4wJtHQ63g4556eET2ccY8bBnp9FSHzLiPeHgGPjm9XHFJKuKZc8metqBcSF1UTEHNHm2YaT2NK4ZD8P"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2755156,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6oobFxdMxQno2NcJ5GpmwxLHKfnLtnSDV3wnVKBVAkFG
Next: Ki7KTH1odqimEZQ44A6oqmhKsWqxWm9QDEUfnDEK9KR

Diff: 
Old
New
Differences
79
79
 
func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
80
80
 
81
81
 
82
-
func getStakingNodeByIndex (idx) = addressFromStringValue(getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP)))
82
+
func getStakingNodeByIndex (idx) = getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP))
83
+
84
+
85
+
func getStakingNodeAddressByIndex (idx) = addressFromStringValue(getStakingNodeByIndex(idx))
83
86
 
84
87
 
85
88
 
func getReservedAmountForSponsorship () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], SEP)), (1000 * WAVELET))
109
112
 
func minBalanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval_minimum")
110
113
 
111
114
 
115
+
func nodeBalanceLockIntervalKEY () = "balance_node_lock_interval"
116
+
117
+
112
118
 
func outFeePartKEY (swapType) = (swapType + "Out_swap_feePart")
113
119
 
114
120
 
125
131
 
126
132
 
127
133
 
func minBalanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, minBalanceLockIntervalKEY(swapType)), 60)
134
+
135
+
136
+
func nodeBalanceLockIntervalREAD () = valueOrElse(getInteger(this, nodeBalanceLockIntervalKEY()), 1)
128
137
 
129
138
 
130
139
 
func feeManagerAddressREAD () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, FeesManagerAddressKey), (FeesManagerAddressKey + " is not specified"))), (FeesManagerAddressKey + " invalid address format"))
238
247
 
239
248
 
let sIdxWithdrawTxId = 14
240
249
 
250
+
let sIdxMinRand = 15
251
+
252
+
let sIdxMaxRand = 16
253
+
241
254
 
func swapKEY (userAddress,txId) = makeString(["%s%s", userAddress, txId], SEP)
242
255
 
243
256
 
244
-
func strSwapDATA (swapType,status,inAmount,price,outNetAmount,outFeeAmount,startHeight,startTimestamp,endHeight,endTimestamp,selfUnlockHeight,randUnlockHeight,index,withdrawTxId) = 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], SEP)
257
+
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)
245
258
 
246
259
 
247
-
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")
260
+
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", toString(minBalanceLockIntervalREAD(swapType)), toString(balanceLockIntervalREAD(swapType)))
248
261
 
249
262
 
250
-
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)
263
+
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])
251
264
 
252
265
 
253
266
 
func swapDataFailOrREAD (userAddress,swapTxId) = {
262
275
 
    }
263
276
 
264
277
 
265
-
func randUnlockHeightOrFail (txId,rsaSig,swapType,startHeight) = {
278
+
func randUnlockHeightOrFail (txId,rsaSig,swapType,startHeight,minMaxRandsTuple) = {
266
279
 
    let isRsaValid = rsaVerify_16Kb(SHA256, toBytes(txId), rsaSig, rsaPub)
267
280
 
    if (!(isRsaValid))
268
281
 
        then throw("invalid RSA signature")
269
282
 
        else {
270
-
            let maxBalanceLockInterval = balanceLockIntervalREAD(swapType)
271
-
            let minBalanceLockInterval = minBalanceLockIntervalREAD(swapType)
283
+
            let minBalanceLockInterval = minMaxRandsTuple._1
284
+
            let maxBalanceLockInterval = minMaxRandsTuple._2
272
285
 
            let rand = (toInt(sha256_16Kb(rsaSig)) % (maxBalanceLockInterval - minBalanceLockInterval))
273
286
 
            let randLockInterval = (minBalanceLockInterval + (if ((0 > rand))
274
287
 
                then -(rand)
315
328
 
                then [LeaseCancel(value(oldLease))]
316
329
 
                else nil
317
330
 
            let leaseAmountKey = getLeaseAmountKey(nodeIndex)
318
-
            let lease = Lease(getStakingNodeByIndex(nodeIndex), newLeaseAmount)
331
+
            let lease = Lease(getStakingNodeAddressByIndex(nodeIndex), newLeaseAmount)
319
332
 
            (unleaseOrEmpty ++ [lease, BinaryEntry(leaseIdKey, calculateLeaseId(lease)), IntegerEntry(getLeaseAmountKey(nodeIndex), newLeaseAmount)])
320
333
 
            }
321
334
 
        else nil
329
342
 
    let minSwapAmount = minSwapAmountREAD(swapType)
330
343
 
    let totalLocked = totalLockedREAD(swapType)
331
344
 
    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
332
-
    let balanceLockMaxInterval = balanceLockIntervalREAD(swapType)
345
+
    let nodeAddress = getStakingNodeByIndex(0)
346
+
    let balanceLockMaxInterval = if ((nodeAddress == account))
347
+
        then nodeBalanceLockIntervalREAD()
348
+
        else balanceLockIntervalREAD(swapType)
333
349
 
    let selfUnlockHeight = (height + balanceLockMaxInterval)
334
350
 
    if ((minSwapAmount > pmt.amount))
335
351
 
        then minSwapAmountFAIL(swapType, minSwapAmount)
339
355
 
                let leasePart = if ((swapType == "waves"))
340
356
 
                    then prepareUnleaseAndLease(0)
341
357
 
                    else nil
342
-
                $Tuple2(([IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser + pmt.amount)), IntegerEntry(getBalanceUnlockBlockKey(account), (height + balanceLockMaxInterval)), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmt.amount)), StringEntry(swapKEY(account, txId58), pendingSwapDATA(swapType, pmt.amount, selfUnlockHeight))] ++ leasePart), unit)
358
+
                $Tuple2(([IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser + pmt.amount)), IntegerEntry(getBalanceUnlockBlockKey(account), selfUnlockHeight), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmt.amount)), StringEntry(swapKEY(account, txId58), pendingSwapDATA(swapType, pmt.amount, selfUnlockHeight))] ++ leasePart), unit)
343
359
 
                }
344
360
 
    }
345
361
 
356
372
 
    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
357
373
 
    let totalLocked = totalLockedREAD(swapType)
358
374
 
    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
375
+
    let minMaxRandsTuple = if ((15 >= size(dataArray)))
376
+
        then $Tuple2(60, 1440)
377
+
        else $Tuple2(parseIntValue(dataArray[sIdxMinRand]), parseIntValue(dataArray[sIdxMaxRand]))
359
378
 
    let unlockHeight =     match rsaSigOrUnit {
360
379
 
        case rsaSig: ByteVector => 
361
-
            randUnlockHeightOrFail(swapTxId, rsaSig, swapType, startHeight)
380
+
            randUnlockHeightOrFail(swapTxId, rsaSig, swapType, startHeight, minMaxRandsTuple)
362
381
 
        case _: Unit => 
363
382
 
            selfUnlockHeight
364
383
 
        case _ => 
457
476
 
    else $Tuple2(prepareUnleaseAndLease(0), "success")
458
477
 
459
478
 
460
-
461
-
@Callable(i)
462
-
func migrateActiveLeasings (leaseChunkTxId,chunkAmount,nodeIndex) = if ((i.callerPublicKey != nodeOracleProviderPubKey))
463
-
    then throw("not authorized")
464
-
    else {
465
-
        let leaseAmountKEY = getLeaseAmountKey(nodeIndex)
466
-
        let amountToAdd = ((wavesBalance(neutrinoContract).available + chunkAmount) - getReservedAmountForSponsorship())
467
-
        let oldLeasedAmount = getNumberByKey(leaseAmountKEY)
468
-
        let newLeaseAmount = (oldLeasedAmount + amountToAdd)
469
-
        let leaseIdKEY = getLeaseIdKey(nodeIndex)
470
-
        let oldLeaseId = getBinary(this, leaseIdKEY)
471
-
        let oldUnleaseOrEmpty = if (isDefined(oldLeaseId))
472
-
            then [LeaseCancel(value(oldLeaseId))]
473
-
            else nil
474
-
        let lease = Lease(getStakingNodeByIndex(nodeIndex), newLeaseAmount)
475
-
        (oldUnleaseOrEmpty ++ [LeaseCancel(fromBase58String(leaseChunkTxId)), lease, BinaryEntry(leaseIdKEY, calculateLeaseId(lease)), IntegerEntry(leaseAmountKEY, newLeaseAmount)])
476
-
        }
477
-
478
-
479
479
 
@Verifier(tx)
480
480
 
func verify () = {
481
481
 
    let id = toBase58String(tx.id)
Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 5 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
5
5
 
6
6
 
7
7
 
func getStringByKey (key) = valueOrElse(getString(this, key), "")
8
8
 
9
9
 
10
10
 
func getBoolByKey (key) = valueOrElse(getBoolean(this, key), false)
11
11
 
12
12
 
13
13
 
func getNumberByAddressAndKey (address,key) = valueOrElse(getInteger(addressFromStringValue(address), key), 0)
14
14
 
15
15
 
16
16
 
func getStringByAddressAndKey (address,key) = valueOrElse(getString(addressFromStringValue(address), key), "")
17
17
 
18
18
 
19
19
 
func getBoolByAddressAndKey (address,key) = valueOrElse(getBoolean(addressFromStringValue(address), key), false)
20
20
 
21
21
 
22
22
 
let pubKeyAdminsList = ["GJdLSaLiv5K7xuejac8mcRcHoyo3dPrESrvktG3a6MAR", "FWVffYr2ALmHMejZm3WqeLz6Sdym3gLFGtJn4KTwyU5x", "3Wh2LaWcb5gg7K2pPcW3Ep6EAuRBzYkAgrdpt43jTDFa", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
23
23
 
24
24
 
let SEP = "__"
25
25
 
26
26
 
let WAVELET = 100000000
27
27
 
28
28
 
let PAULI = 1000000
29
29
 
30
30
 
let PRICELET = 1000000
31
31
 
32
32
 
let DEFAULTSWAPFEE = 20000
33
33
 
34
34
 
let IdxNetAmount = 0
35
35
 
36
36
 
let IdxFeeAmount = 1
37
37
 
38
38
 
let IdxGrossAmount = 2
39
39
 
40
40
 
let NeutrinoAssetIdKey = "neutrino_asset_id"
41
41
 
42
42
 
let BondAssetIdKey = "bond_asset_id"
43
43
 
44
44
 
let AuctionContractKey = "auction_contract"
45
45
 
46
46
 
let LiquidationContractKey = "liquidation_contract"
47
47
 
48
48
 
let RPDContractKey = "rpd_contract"
49
49
 
50
50
 
let ContolContractKey = "control_contract"
51
51
 
52
52
 
let BalanceWavesLockIntervalKey = "balance_waves_lock_interval"
53
53
 
54
54
 
let BalanceNeutrinoLockIntervalKey = "balance_neutrino_lock_interval"
55
55
 
56
56
 
let MinWavesSwapAmountKey = "min_waves_swap_amount"
57
57
 
58
58
 
let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
59
59
 
60
60
 
let NodeOracleProviderPubKeyKey = "node_oracle_provider"
61
61
 
62
62
 
let NeutrinoOutFeePartKey = "neutrinoOut_swap_feePart"
63
63
 
64
64
 
let WavesOutFeePartKey = "wavesOut_swap_feePart"
65
65
 
66
66
 
let FeesManagerAddressKey = "fees_manager_address"
67
67
 
68
68
 
let RsaRandPublic58Key = "rand_rsa_public"
69
69
 
70
70
 
let PriceKey = "price"
71
71
 
72
72
 
let PriceIndexKey = "price_index"
73
73
 
74
74
 
let IsBlockedKey = "is_blocked"
75
75
 
76
76
 
func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
77
77
 
78
78
 
79
79
 
func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
80
80
 
81
81
 
82
-
func getStakingNodeByIndex (idx) = addressFromStringValue(getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP)))
82
+
func getStakingNodeByIndex (idx) = getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP))
83
+
84
+
85
+
func getStakingNodeAddressByIndex (idx) = addressFromStringValue(getStakingNodeByIndex(idx))
83
86
 
84
87
 
85
88
 
func getReservedAmountForSponsorship () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], SEP)), (1000 * WAVELET))
86
89
 
87
90
 
88
91
 
func getBalanceUnlockBlockKey (owner) = ("balance_unlock_block_" + owner)
89
92
 
90
93
 
91
94
 
func getLeaseIdKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "id"], SEP)
92
95
 
93
96
 
94
97
 
func getLeaseAmountKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "amount"], SEP)
95
98
 
96
99
 
97
100
 
func minSwapAmountKEY (swapType) = (("min_" + swapType) + "_swap_amount")
98
101
 
99
102
 
100
103
 
func totalLockedKEY (swapType) = ("balance_lock_" + swapType)
101
104
 
102
105
 
103
106
 
func totalLockedByUserKEY (swapType,owner) = makeString(["balance_lock", swapType, owner], "_")
104
107
 
105
108
 
106
109
 
func balanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval")
107
110
 
108
111
 
109
112
 
func minBalanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval_minimum")
110
113
 
111
114
 
115
+
func nodeBalanceLockIntervalKEY () = "balance_node_lock_interval"
116
+
117
+
112
118
 
func outFeePartKEY (swapType) = (swapType + "Out_swap_feePart")
113
119
 
114
120
 
115
121
 
func minSwapAmountREAD (swapType) = valueOrElse(getInteger(this, minSwapAmountKEY(swapType)), 0)
116
122
 
117
123
 
118
124
 
func totalLockedREAD (swapType) = valueOrElse(getInteger(this, totalLockedKEY(swapType)), 0)
119
125
 
120
126
 
121
127
 
func totalLockedByUserREAD (swapType,owner) = valueOrElse(getInteger(this, totalLockedByUserKEY(swapType, owner)), 0)
122
128
 
123
129
 
124
130
 
func balanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, balanceLockIntervalKEY(swapType)), 1440)
125
131
 
126
132
 
127
133
 
func minBalanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, minBalanceLockIntervalKEY(swapType)), 60)
134
+
135
+
136
+
func nodeBalanceLockIntervalREAD () = valueOrElse(getInteger(this, nodeBalanceLockIntervalKEY()), 1)
128
137
 
129
138
 
130
139
 
func feeManagerAddressREAD () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, FeesManagerAddressKey), (FeesManagerAddressKey + " is not specified"))), (FeesManagerAddressKey + " invalid address format"))
131
140
 
132
141
 
133
142
 
func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
134
143
 
135
144
 
136
145
 
func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
137
146
 
138
147
 
139
148
 
func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
140
149
 
141
150
 
142
151
 
func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
143
152
 
144
153
 
145
154
 
func minSwapAmountFAIL (swapType,minSwapAmount) = throw(((("The specified amount in " + swapType) + " swap is less than the required minimum of ") + toString(minSwapAmount)))
146
155
 
147
156
 
148
157
 
func emergencyShutdownFAIL () = throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
149
158
 
150
159
 
151
160
 
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)))
152
161
 
153
162
 
154
163
 
let liquidationContract = getStringByKey(LiquidationContractKey)
155
164
 
156
165
 
let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
157
166
 
158
167
 
let auctionContract = getStringByKey(AuctionContractKey)
159
168
 
160
169
 
let rpdContract = getStringByKey(RPDContractKey)
161
170
 
162
171
 
let controlContract = getStringByKey(ContolContractKey)
163
172
 
164
173
 
let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
165
174
 
166
175
 
let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
167
176
 
168
177
 
let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
169
178
 
170
179
 
let bondAssetId = fromBase58String("6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g")
171
180
 
172
181
 
let deprecatedBondAssetId = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
173
182
 
174
183
 
let rsaPub = fromBase64String(valueOrErrorMessage(getString(this, RsaRandPublic58Key), "RSA public key has not been specified"))
175
184
 
176
185
 
let neutrinoContract = this
177
186
 
178
187
 
let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
179
188
 
180
189
 
let neutrinoLockedBalance = totalLockedREAD("neutrino")
181
190
 
182
191
 
let wavesLockedBalance = totalLockedREAD("waves")
183
192
 
184
193
 
let reserve = (wavesBalance(neutrinoContract).regular - wavesLockedBalance)
185
194
 
186
195
 
let neutrinoSupply = (((neutrinoLockedBalance + value(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
187
196
 
188
197
 
let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
189
198
 
190
199
 
let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
191
200
 
192
201
 
func checkIsValidMinSponsoredFee (tx) = {
193
202
 
    let MINTRANSFERFEE = 100000
194
203
 
    let SponsoredFeeUpperBound = 1000
195
204
 
    let realNeutrinoFee = convertWavesToNeutrino(MINTRANSFERFEE, currentPrice)
196
205
 
    let minNeutrinoFee = (realNeutrinoFee * 2)
197
206
 
    let maxNeutrinoFee = fraction(realNeutrinoFee, SponsoredFeeUpperBound, 100)
198
207
 
    let inputFee = value(tx.minSponsoredAssetFee)
199
208
 
    if (if ((inputFee >= minNeutrinoFee))
200
209
 
        then (maxNeutrinoFee >= inputFee)
201
210
 
        else false)
202
211
 
        then (tx.assetId == neutrinoAssetId)
203
212
 
        else false
204
213
 
    }
205
214
 
206
215
 
207
216
 
func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
208
217
 
209
218
 
210
219
 
func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
211
220
 
212
221
 
213
222
 
let sIdxSwapType = 1
214
223
 
215
224
 
let sIdxStatus = 2
216
225
 
217
226
 
let sIdxInAmount = 3
218
227
 
219
228
 
let sIdxPrice = 4
220
229
 
221
230
 
let sIdxOutNetAmount = 5
222
231
 
223
232
 
let sIdxOutFeeAmount = 6
224
233
 
225
234
 
let sIdxStartHeight = 7
226
235
 
227
236
 
let sIdxStartTimestamp = 8
228
237
 
229
238
 
let sIdxEndHeight = 9
230
239
 
231
240
 
let sIdxEndTimestamp = 10
232
241
 
233
242
 
let sIdxSelfUnlockHeight = 11
234
243
 
235
244
 
let sIdxRandUnlockHeight = 12
236
245
 
237
246
 
let sIdxIndex = 13
238
247
 
239
248
 
let sIdxWithdrawTxId = 14
240
249
 
250
+
let sIdxMinRand = 15
251
+
252
+
let sIdxMaxRand = 16
253
+
241
254
 
func swapKEY (userAddress,txId) = makeString(["%s%s", userAddress, txId], SEP)
242
255
 
243
256
 
244
-
func strSwapDATA (swapType,status,inAmount,price,outNetAmount,outFeeAmount,startHeight,startTimestamp,endHeight,endTimestamp,selfUnlockHeight,randUnlockHeight,index,withdrawTxId) = 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], SEP)
257
+
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)
245
258
 
246
259
 
247
-
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")
260
+
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", toString(minBalanceLockIntervalREAD(swapType)), toString(balanceLockIntervalREAD(swapType)))
248
261
 
249
262
 
250
-
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)
263
+
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])
251
264
 
252
265
 
253
266
 
func swapDataFailOrREAD (userAddress,swapTxId) = {
254
267
 
    let swapKey = swapKEY(userAddress, swapTxId)
255
268
 
    split(valueOrErrorMessage(getString(this, swapKey), ("no swap data for " + swapKey)), SEP)
256
269
 
    }
257
270
 
258
271
 
259
272
 
func applyFees (amountGross,feePart) = {
260
273
 
    let feeAmount = fraction(amountGross, feePart, PAULI)
261
274
 
[(amountGross - feeAmount), feeAmount, amountGross]
262
275
 
    }
263
276
 
264
277
 
265
-
func randUnlockHeightOrFail (txId,rsaSig,swapType,startHeight) = {
278
+
func randUnlockHeightOrFail (txId,rsaSig,swapType,startHeight,minMaxRandsTuple) = {
266
279
 
    let isRsaValid = rsaVerify_16Kb(SHA256, toBytes(txId), rsaSig, rsaPub)
267
280
 
    if (!(isRsaValid))
268
281
 
        then throw("invalid RSA signature")
269
282
 
        else {
270
-
            let maxBalanceLockInterval = balanceLockIntervalREAD(swapType)
271
-
            let minBalanceLockInterval = minBalanceLockIntervalREAD(swapType)
283
+
            let minBalanceLockInterval = minMaxRandsTuple._1
284
+
            let maxBalanceLockInterval = minMaxRandsTuple._2
272
285
 
            let rand = (toInt(sha256_16Kb(rsaSig)) % (maxBalanceLockInterval - minBalanceLockInterval))
273
286
 
            let randLockInterval = (minBalanceLockInterval + (if ((0 > rand))
274
287
 
                then -(rand)
275
288
 
                else rand))
276
289
 
            (startHeight + randLockInterval)
277
290
 
            }
278
291
 
    }
279
292
 
280
293
 
281
294
 
func abs (x) = if ((0 > x))
282
295
 
    then -(x)
283
296
 
    else x
284
297
 
285
298
 
286
299
 
func selectNode (unleaseAmount) = {
287
300
 
    let amountToLease = ((wavesBalance(neutrinoContract).available - unleaseAmount) - getReservedAmountForSponsorship())
288
301
 
    let oldLeased0 = getNumberByKey(getLeaseAmountKey(0))
289
302
 
    let oldLeased1 = getNumberByKey(getLeaseAmountKey(1))
290
303
 
    let newLeased0 = (amountToLease + oldLeased0)
291
304
 
    let newLeased1 = (amountToLease + oldLeased1)
292
305
 
    if (if ((newLeased0 > 0))
293
306
 
        then true
294
307
 
        else (newLeased1 > 0))
295
308
 
        then {
296
309
 
            let delta0 = abs((newLeased0 - oldLeased1))
297
310
 
            let delta1 = abs((newLeased1 - oldLeased0))
298
311
 
            if ((delta1 >= delta0))
299
312
 
                then $Tuple2(0, newLeased0)
300
313
 
                else $Tuple2(1, newLeased1)
301
314
 
            }
302
315
 
        else $Tuple2(-1, 0)
303
316
 
    }
304
317
 
305
318
 
306
319
 
func prepareUnleaseAndLease (unleaseAmount) = {
307
320
 
    let nodeTuple = selectNode(unleaseAmount)
308
321
 
    let nodeIndex = nodeTuple._1
309
322
 
    let newLeaseAmount = nodeTuple._2
310
323
 
    if ((newLeaseAmount > 0))
311
324
 
        then {
312
325
 
            let leaseIdKey = getLeaseIdKey(nodeIndex)
313
326
 
            let oldLease = getBinary(this, leaseIdKey)
314
327
 
            let unleaseOrEmpty = if (isDefined(oldLease))
315
328
 
                then [LeaseCancel(value(oldLease))]
316
329
 
                else nil
317
330
 
            let leaseAmountKey = getLeaseAmountKey(nodeIndex)
318
-
            let lease = Lease(getStakingNodeByIndex(nodeIndex), newLeaseAmount)
331
+
            let lease = Lease(getStakingNodeAddressByIndex(nodeIndex), newLeaseAmount)
319
332
 
            (unleaseOrEmpty ++ [lease, BinaryEntry(leaseIdKey, calculateLeaseId(lease)), IntegerEntry(getLeaseAmountKey(nodeIndex), newLeaseAmount)])
320
333
 
            }
321
334
 
        else nil
322
335
 
    }
323
336
 
324
337
 
325
338
 
func commonSwap (swapType,i) = {
326
339
 
    let pmt = value(i.payments[0])
327
340
 
    let account = toString(i.caller)
328
341
 
    let txId58 = toBase58String(i.transactionId)
329
342
 
    let minSwapAmount = minSwapAmountREAD(swapType)
330
343
 
    let totalLocked = totalLockedREAD(swapType)
331
344
 
    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
332
-
    let balanceLockMaxInterval = balanceLockIntervalREAD(swapType)
345
+
    let nodeAddress = getStakingNodeByIndex(0)
346
+
    let balanceLockMaxInterval = if ((nodeAddress == account))
347
+
        then nodeBalanceLockIntervalREAD()
348
+
        else balanceLockIntervalREAD(swapType)
333
349
 
    let selfUnlockHeight = (height + balanceLockMaxInterval)
334
350
 
    if ((minSwapAmount > pmt.amount))
335
351
 
        then minSwapAmountFAIL(swapType, minSwapAmount)
336
352
 
        else if (isBlocked)
337
353
 
            then emergencyShutdownFAIL()
338
354
 
            else {
339
355
 
                let leasePart = if ((swapType == "waves"))
340
356
 
                    then prepareUnleaseAndLease(0)
341
357
 
                    else nil
342
-
                $Tuple2(([IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser + pmt.amount)), IntegerEntry(getBalanceUnlockBlockKey(account), (height + balanceLockMaxInterval)), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmt.amount)), StringEntry(swapKEY(account, txId58), pendingSwapDATA(swapType, pmt.amount, selfUnlockHeight))] ++ leasePart), unit)
358
+
                $Tuple2(([IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser + pmt.amount)), IntegerEntry(getBalanceUnlockBlockKey(account), selfUnlockHeight), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmt.amount)), StringEntry(swapKEY(account, txId58), pendingSwapDATA(swapType, pmt.amount, selfUnlockHeight))] ++ leasePart), unit)
343
359
 
                }
344
360
 
    }
345
361
 
346
362
 
347
363
 
func commonWithdraw (account,index,swapTxId,rsaSigOrUnit,i) = {
348
364
 
    let userAddress = addressFromStringValue(account)
349
365
 
    let feeManagerAddress = feeManagerAddressREAD()
350
366
 
    let dataArray = swapDataFailOrREAD(account, swapTxId)
351
367
 
    let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
352
368
 
    let swapType = dataArray[sIdxSwapType]
353
369
 
    let inAmount = parseIntValue(dataArray[sIdxInAmount])
354
370
 
    let swapStatus = dataArray[sIdxStatus]
355
371
 
    let startHeight = parseIntValue(dataArray[sIdxStartHeight])
356
372
 
    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
357
373
 
    let totalLocked = totalLockedREAD(swapType)
358
374
 
    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
375
+
    let minMaxRandsTuple = if ((15 >= size(dataArray)))
376
+
        then $Tuple2(60, 1440)
377
+
        else $Tuple2(parseIntValue(dataArray[sIdxMinRand]), parseIntValue(dataArray[sIdxMaxRand]))
359
378
 
    let unlockHeight =     match rsaSigOrUnit {
360
379
 
        case rsaSig: ByteVector => 
361
-
            randUnlockHeightOrFail(swapTxId, rsaSig, swapType, startHeight)
380
+
            randUnlockHeightOrFail(swapTxId, rsaSig, swapType, startHeight, minMaxRandsTuple)
362
381
 
        case _: Unit => 
363
382
 
            selfUnlockHeight
364
383
 
        case _ => 
365
384
 
            throw("Match error")
366
385
 
    }
367
386
 
    let indexHeight = getHeightPriceByIndex(index)
368
387
 
    let prevIndexHeight = getHeightPriceByIndex((index - 1))
369
388
 
    let priceByIndex = getPriceHistory(indexHeight)
370
389
 
    let outAmountGrossTuple = if ((swapType == "waves"))
371
390
 
        then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
372
391
 
        else if ((swapType == "neutrino"))
373
392
 
            then $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
374
393
 
            else throw(("Unsupported swap type " + swapType))
375
394
 
    let payoutsArray = applyFees(outAmountGrossTuple._1, outFeePart)
376
395
 
    let outNetAmount = payoutsArray[IdxNetAmount]
377
396
 
    let outFeeAmount = payoutsArray[IdxFeeAmount]
378
397
 
    if (isBlocked)
379
398
 
        then emergencyShutdownFAIL()
380
399
 
        else if ((swapStatus != "PENDING"))
381
400
 
            then throw("swap has been already processed")
382
401
 
            else if ((unlockHeight > height))
383
402
 
                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
384
403
 
                else if (if (if ((index > priceIndex))
385
404
 
                    then true
386
405
 
                    else (unlockHeight > indexHeight))
387
406
 
                    then true
388
407
 
                    else if ((prevIndexHeight != 0))
389
408
 
                        then (prevIndexHeight >= unlockHeight)
390
409
 
                        else false)
391
410
 
                    then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
392
411
 
                    else if ((0 >= payoutsArray[IdxGrossAmount]))
393
412
 
                        then throw("balance equals zero")
394
413
 
                        else if (if ((0 > outFeePart))
395
414
 
                            then true
396
415
 
                            else (outFeePart >= PAULI))
397
416
 
                            then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
398
417
 
                            else {
399
418
 
                                let leasePart = if (if ((swapType == "neutrino"))
400
419
 
                                    then (outAmountGrossTuple._1 > 0)
401
420
 
                                    else false)
402
421
 
                                    then prepareUnleaseAndLease(outAmountGrossTuple._1)
403
422
 
                                    else nil
404
423
 
                                $Tuple2((leasePart ++ [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAmountGrossTuple._2), ScriptTransfer(feeManagerAddress, outFeeAmount, outAmountGrossTuple._2), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, toBase58String(i.transactionId)))]), unit)
405
424
 
                                }
406
425
 
    }
407
426
 
408
427
 
409
428
 
@Callable(i)
410
429
 
func swapWavesToNeutrino () = {
411
430
 
    let pmt = value(i.payments[0])
412
431
 
    if (isDefined(pmt.assetId))
413
432
 
        then throw("Only Waves token is allowed for swapping.")
414
433
 
        else commonSwap("waves", i)
415
434
 
    }
416
435
 
417
436
 
418
437
 
419
438
 
@Callable(i)
420
439
 
func swapNeutrinoToWaves () = {
421
440
 
    let pmt = value(i.payments[0])
422
441
 
    if ((pmt.assetId != neutrinoAssetId))
423
442
 
        then throw("Only appropriate Neutrino tokens are allowed for swapping.")
424
443
 
        else commonSwap("neutrino", i)
425
444
 
    }
426
445
 
427
446
 
428
447
 
429
448
 
@Callable(i)
430
449
 
func withdraw (account,index,swapTxId) = commonWithdraw(account, index, swapTxId, unit, i)
431
450
 
432
451
 
433
452
 
434
453
 
@Callable(i)
435
454
 
func withdrawRand (account,index,swapTxId,rsaSig) = commonWithdraw(account, index, swapTxId, rsaSig, i)
436
455
 
437
456
 
438
457
 
439
458
 
@Callable(i)
440
459
 
func transferToAuction () = {
441
460
 
    let auctionNBAmount = (neutrinoSupply - assetBalance(addressFromStringValue(auctionContract), bondAssetId))
442
461
 
    let surplusWithLiquidation = (surplus - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
443
462
 
    if (isBlocked)
444
463
 
        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
445
464
 
        else if ((auctionNBAmount > (1 * PAULI)))
446
465
 
            then [ScriptTransfer(addressFromStringValue(auctionContract), auctionNBAmount, bondAssetId)]
447
466
 
            else if ((surplusWithLiquidation >= (1 * PAULI)))
448
467
 
                then [ScriptTransfer(addressFromStringValue(liquidationContract), surplusWithLiquidation, neutrinoAssetId)]
449
468
 
                else throw(((((((("bond were generated or do not need it. Deficit:" + toString(auctionNBAmount)) + "|") + toString(0)) + ". Surplus:") + toString(surplusWithLiquidation)) + "|") + toString(surplus)))
450
469
 
    }
451
470
 
452
471
 
453
472
 
454
473
 
@Callable(i)
455
474
 
func acceptWaves () = if ((i.caller != addressFromStringValue(auctionContract)))
456
475
 
    then throw("Currently only auction contract is allowed to call")
457
476
 
    else $Tuple2(prepareUnleaseAndLease(0), "success")
458
477
 
459
478
 
460
-
461
-
@Callable(i)
462
-
func migrateActiveLeasings (leaseChunkTxId,chunkAmount,nodeIndex) = if ((i.callerPublicKey != nodeOracleProviderPubKey))
463
-
    then throw("not authorized")
464
-
    else {
465
-
        let leaseAmountKEY = getLeaseAmountKey(nodeIndex)
466
-
        let amountToAdd = ((wavesBalance(neutrinoContract).available + chunkAmount) - getReservedAmountForSponsorship())
467
-
        let oldLeasedAmount = getNumberByKey(leaseAmountKEY)
468
-
        let newLeaseAmount = (oldLeasedAmount + amountToAdd)
469
-
        let leaseIdKEY = getLeaseIdKey(nodeIndex)
470
-
        let oldLeaseId = getBinary(this, leaseIdKEY)
471
-
        let oldUnleaseOrEmpty = if (isDefined(oldLeaseId))
472
-
            then [LeaseCancel(value(oldLeaseId))]
473
-
            else nil
474
-
        let lease = Lease(getStakingNodeByIndex(nodeIndex), newLeaseAmount)
475
-
        (oldUnleaseOrEmpty ++ [LeaseCancel(fromBase58String(leaseChunkTxId)), lease, BinaryEntry(leaseIdKEY, calculateLeaseId(lease)), IntegerEntry(leaseAmountKEY, newLeaseAmount)])
476
-
        }
477
-
478
-
479
479
 
@Verifier(tx)
480
480
 
func verify () = {
481
481
 
    let id = toBase58String(tx.id)
482
482
 
    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
483
483
 
        then 1
484
484
 
        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
485
485
 
        then 1
486
486
 
        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
487
487
 
        then 1
488
488
 
        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
489
489
 
        then 2
490
490
 
        else 0))
491
491
 
    match tx {
492
492
 
        case sponsorTx: SponsorFeeTransaction => 
493
493
 
            if (checkIsValidMinSponsoredFee(sponsorTx))
494
494
 
                then (count >= 3)
495
495
 
                else false
496
496
 
        case _ => 
497
497
 
            (count >= 3)
498
498
 
    }
499
499
 
    }
500
500
 

github/deemru/w8io/786bc32 
88.28 ms ◑