tx · 7pz4Zto5oFkVMu55VJizdhvUkBeES52L4uweQcsfmPo8

3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F:  -0.01400000 Waves

2019.11.18 17:58 [770716] smart account 3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7pz4Zto5oFkVMu55VJizdhvUkBeES52L4uweQcsfmPo8",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1574089136325,
    "version": 1,
    "sender": "3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F",
    "senderPublicKey": "3z5txV1G5GKezwMRCHZDkLThqb1Yggepxvi2wq6iP6oz",
    "proofs": [
        "2db2iDDpVMm24HUAYhb2cd46nhLWLeo43bbckGHCMYD2VhrzkzFDc4p4nmm4KMRfzGmACWKRD3v91qNqyxXTRtP2"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 770716,
    "spentComplexity": 0
}

View: original | compacted
Prev: 58WAMj2f6x9KH3G2YpFkzmBBSzkRX3ciBz66VBz5eiJU
Next: Ak6Sw71rxMuS9tCgNnvEvpTEsAgwyvfvk99iYHHgFP1q

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 3 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
func getNumberByKey (key) = match getInteger(this, key) {
5
5
 
    case a: Int => 
6
6
 
        a
7
7
 
    case _ => 
8
8
 
        0
9
9
 
}
10
10
 
11
11
 
12
12
 
func getStringByKey (key) = match getString(this, key) {
13
13
 
    case a: String => 
14
14
 
        a
15
15
 
    case _ => 
16
16
 
        ""
17
17
 
}
18
18
 
19
19
 
20
20
 
func getBoolByKey (key) = match getBoolean(this, key) {
21
21
 
    case a: Boolean => 
22
22
 
        a
23
23
 
    case _ => 
24
24
 
        false
25
25
 
}
26
26
 
27
27
 
28
28
 
func getNumberByAddressAndKey (address,key) = match getInteger(addressFromStringValue(address), key) {
29
29
 
    case a: Int => 
30
30
 
        a
31
31
 
    case _ => 
32
32
 
        0
33
33
 
}
34
34
 
35
35
 
36
36
 
func getStringByAddressAndKey (address,key) = match getString(addressFromStringValue(address), key) {
37
37
 
    case a: String => 
38
38
 
        a
39
39
 
    case _ => 
40
40
 
        ""
41
41
 
}
42
42
 
43
43
 
44
44
 
func getBoolByAddressAndKey (address,key) = match getBoolean(addressFromStringValue(address), key) {
45
45
 
    case a: Boolean => 
46
46
 
        a
47
47
 
    case _ => 
48
48
 
        false
49
49
 
}
50
50
 
51
51
 
52
52
 
let SENDTXEXPIRE = 30
53
53
 
54
54
 
let LISTSPLITSYMBOL = "_"
55
55
 
56
56
 
let LISTDATASYMBOL = "+"
57
57
 
58
58
 
let WAVELET = 100000000
59
59
 
60
60
 
let PAULI = 100
61
61
 
62
62
 
let CRYTICALSHARE = 20
63
63
 
64
64
 
let LEASINGSHARE = 90
65
65
 
66
66
 
let LEASINTXCOUNT = 10
67
67
 
68
68
 
let DEFICITOFFSET = 10
69
69
 
70
70
 
let WAVESASSETID = "waves"
71
71
 
72
72
 
let CANCELED = "canceled"
73
73
 
74
74
 
let NEW = "new"
75
75
 
76
76
 
let NeutrinoAssetIdKey = "neutrino_asset_id"
77
77
 
78
78
 
let BondAssetIdKey = "bond_asset_id"
79
79
 
80
80
 
let ReserveContractKey = "reserve_contract"
81
81
 
82
82
 
let AuctionContractKey = "auction_contract"
83
83
 
84
84
 
let LiquidationContractKey = "liquidation_contract"
85
85
 
86
86
 
let RPDContractKey = "rpd_contract"
87
87
 
88
88
 
let ContolContractKey = "control_contract"
89
89
 
90
90
 
let BalanceLockIntervalKey = "balance_lock_interval"
91
91
 
92
92
 
let MinWavesSwapAmountKey = "min_waves_swap_amount"
93
93
 
94
94
 
let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
95
95
 
96
96
 
let NodeAddressKey = "node_address"
97
97
 
98
98
 
let NodeOracleProviderKey = "oracle_node_provider"
99
99
 
100
100
 
let LeasingIntervalKey = "leasing_interval"
101
101
 
102
102
 
let RPDBalanceKey = "rpd_balance"
103
103
 
104
104
 
func getRPDContractBalanceKey (assetId) = ((RPDBalanceKey + "_") + toBase58String(assetId))
105
105
 
106
106
 
107
107
 
let PriceKey = "price"
108
108
 
109
109
 
let PriceIndexKey = "price_index"
110
110
 
111
111
 
let IsBlockedKey = "is_blocked"
112
112
 
113
113
 
let LeasingExpireBlockKey = "leasing_expire_block"
114
114
 
115
115
 
let IsRebalanceKey = "is_rebalance"
116
116
 
117
117
 
let LeasingTxCountKey = "leasing_index"
118
118
 
119
119
 
let LeasingAmountKey = "leasing_amount"
120
120
 
121
121
 
func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
122
122
 
123
123
 
124
124
 
func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
125
125
 
126
126
 
127
127
 
let RPDSyncIndexKey = "rpd_sync_index"
128
128
 
129
129
 
func getRPDSnapshotContractBalanceKey (count,assetId) = ((((RPDBalanceKey + "_") + toBase58String(assetId)) + "_") + toString(count))
130
130
 
131
131
 
132
132
 
func getCancelLeaseTxReserveFeeKey (hash) = (("cancel_lease_tx_reserve_fee" + "_") + hash)
133
133
 
134
134
 
135
135
 
func getAccountLockedBalanceKey (owner,assetId) = ((("balance_" + assetId) + "_") + owner)
136
136
 
137
137
 
138
138
 
func getBalanceUnlockBlockKey (owner) = ("balance_block_" + owner)
139
139
 
140
140
 
141
141
 
func getRPDProfitKey (count) = (("rpd_profit" + "_") + toString(count))
142
142
 
143
143
 
144
144
 
func getLockedBalanceKey (assetId) = ("balance_" + assetId)
145
145
 
146
146
 
147
147
 
func getLeaseTxStatusKey (hash) = (("lease_tx_status" + "_") + hash)
148
148
 
149
149
 
150
150
 
func getLeaseTxAmountByHashKey (hash) = ((LeasingAmountKey + "_") + hash)
151
151
 
152
152
 
153
153
 
func getLeaseTxBytesByHashKey (hash) = (("lease_tx" + "_") + hash)
154
154
 
155
155
 
156
156
 
func getLeaseTxExpireSendBlockKey (hash) = (("leasing_expire_send" + "_") + hash)
157
157
 
158
158
 
159
159
 
func convertNeutrinoToWaves (amount,price) = ((((amount * 100) / price) * WAVELET) / PAULI)
160
160
 
161
161
 
162
162
 
func convertWavesToNeutrino (amount,price) = ((((amount * price) / 100) * PAULI) / WAVELET)
163
163
 
164
164
 
165
165
 
func convertNeutrinoToBond (amount) = (amount / PAULI)
166
166
 
167
167
 
168
168
 
func convertBondToNeutrino (amount) = (amount * PAULI)
169
169
 
170
170
 
171
171
 
func convertWavesToBond (amount,price) = convertNeutrinoToBond(convertWavesToNeutrino(amount, price))
172
172
 
173
173
 
174
174
 
func getLockedBalance (assetId) = getNumberByKey(getLockedBalanceKey(assetId))
175
175
 
176
176
 
177
177
 
let liquidationContract = getStringByKey(LiquidationContractKey)
178
178
 
179
179
 
let neutrinoAssetIdString = getStringByKey(NeutrinoAssetIdKey)
180
180
 
181
181
 
let neutrinoAssetId = fromBase58String(neutrinoAssetIdString)
182
182
 
183
183
 
let reserveContract = getStringByKey(ReserveContractKey)
184
184
 
185
185
 
let auctionContract = getStringByKey(AuctionContractKey)
186
186
 
187
187
 
let rpdContract = getStringByKey(RPDContractKey)
188
188
 
189
189
 
let controlContract = getStringByKey(ContolContractKey)
190
190
 
191
191
 
let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
192
192
 
193
193
 
let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
194
194
 
195
195
 
let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
196
196
 
197
197
 
let leasingTxCount = getNumberByKey(LeasingTxCountKey)
198
198
 
199
199
 
let isRebalance = getBoolByKey(IsRebalanceKey)
200
200
 
201
201
 
let leasingInterval = getNumberByKey(LeasingIntervalKey)
202
202
 
203
203
 
let leasingExpireBlock = getNumberByKey(LeasingExpireBlockKey)
204
204
 
205
205
 
let leasingAmount = getNumberByKey(LeasingAmountKey)
206
206
 
207
207
 
let nodeAddress = getStringByKey(NodeAddressKey)
208
208
 
209
209
 
let nodeOracleProviderKey = getStringByKey(NodeOracleProviderKey)
210
210
 
211
211
 
let rpdSyncIndex = getNumberByKey(RPDSyncIndexKey)
212
212
 
213
213
 
let balanceLockInterval = getNumberByKey(BalanceLockIntervalKey)
214
214
 
215
215
 
let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
216
216
 
217
217
 
let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
218
218
 
219
219
 
let reserve = (wavesBalance(this) - getLockedBalance(WAVESASSETID))
220
220
 
221
221
 
let reserveWithoutLeasing = (reserve - leasingAmount)
222
222
 
223
223
 
let bondAssetId = fromBase58String(getStringByKey(BondAssetIdKey))
224
224
 
225
225
 
let bondSupply = (extract(assetInfo(bondAssetId)).quantity - assetBalance(this, bondAssetId))
226
226
 
227
227
 
let neutrinoSupply = ((extract(assetInfo(neutrinoAssetId)).quantity - assetBalance(this, neutrinoAssetId)) + getLockedBalance(neutrinoAssetIdString))
228
228
 
229
229
 
let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
230
230
 
231
231
 
let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
232
232
 
233
233
 
func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
234
234
 
235
235
 
236
236
 
func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
237
237
 
238
238
 
239
239
 
func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
240
240
 
241
241
 
242
242
 
func getCancelLeaseTxReserveFee (hash) = getNumberByKey(getCancelLeaseTxReserveFeeKey(hash))
243
243
 
244
244
 
245
245
 
func getAccountLockedBalance (owner,assetId) = getNumberByKey(getAccountLockedBalanceKey(owner, assetId))
246
246
 
247
247
 
248
248
 
func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
249
249
 
250
250
 
251
251
 
func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
252
252
 
253
253
 
254
254
 
func getLeaseTxStatus (hash) = getStringByKey(getLeaseTxStatusKey(hash))
255
255
 
256
256
 
257
257
 
func getLeaseTxAmountByHash (hash) = getNumberByKey(getLeaseTxAmountByHashKey(hash))
258
258
 
259
259
 
260
260
 
func getLeaseTxBytesByHash (hash) = getStringByKey(getLeaseTxBytesByHashKey(hash))
261
261
 
262
262
 
263
263
 
func getLeaseTxExpireSendBlock (hash) = getNumberByKey(getLeaseTxExpireSendBlockKey(hash))
264
264
 
265
265
 
266
266
 
@Callable(i)
267
267
 
func swapWavesToNeutrino () = {
268
268
 
    let pmt = extract(i.payment)
269
269
 
    let account = toString(i.caller)
270
270
 
    if ((minWavesSwapAmount > pmt.amount))
271
271
 
        then throw((("an amount is less than min available amount: " + toString(minWavesSwapAmount)) + " wavelets"))
272
272
 
        else if (isDefined(pmt.assetId))
273
273
 
            then throw("can use waves only")
274
274
 
            else if (isBlocked)
275
275
 
                then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
276
276
 
                else if ((getUnlockBalanceBlock(account) > height))
277
277
 
                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
278
278
 
                    else if ((getAccountLockedBalance(account, WAVESASSETID) != 0))
279
279
 
                        then throw("please withdraw locked funds first")
280
280
 
                        else WriteSet([DataEntry(getAccountLockedBalanceKey(account, WAVESASSETID), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(getLockedBalanceKey(WAVESASSETID), (getLockedBalance(WAVESASSETID) + pmt.amount))])
281
281
 
    }
282
282
 
283
283
 
284
284
 
285
285
 
@Callable(i)
286
286
 
func swapNeutrinoToWaves () = {
287
287
 
    let pmt = extract(i.payment)
288
288
 
    let account = toString(i.caller)
289
289
 
    if ((minNeutrinoSwapAmount > pmt.amount))
290
290
 
        then throw((("an amount is less than min available amount: " + toString(minNeutrinoSwapAmount)) + " neutrino cents"))
291
291
 
        else if (isBlocked)
292
292
 
            then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
293
293
 
            else if ((pmt.assetId != neutrinoAssetId))
294
294
 
                then throw("can use appropriate neutrino tokens only")
295
295
 
                else if ((getUnlockBalanceBlock(account) > height))
296
296
 
                    then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
297
297
 
                    else if ((getAccountLockedBalance(account, neutrinoAssetIdString) != 0))
298
298
 
                        then throw("please withdraw locked funds first")
299
299
 
                        else {
300
300
 
                            let newLockedBalance = (getLockedBalance(neutrinoAssetIdString) + pmt.amount)
301
301
 
                            WriteSet([DataEntry(getAccountLockedBalanceKey(account, neutrinoAssetIdString), pmt.amount), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(getLockedBalanceKey(neutrinoAssetIdString), newLockedBalance), DataEntry(IsRebalanceKey, if ((reserveWithoutLeasing >= convertNeutrinoToWaves(newLockedBalance, currentPrice)))
302
302
 
                                then false
303
303
 
                                else true)])
304
304
 
                            }
305
305
 
    }
306
306
 
307
307
 
308
308
 
309
309
 
@Callable(i)
310
310
 
func withdraw (account,index,lockedAssetId) = {
311
311
 
    let unlockHeight = getUnlockBalanceBlock(account)
312
312
 
    let lockedBalance = getAccountLockedBalance(account, lockedAssetId)
313
313
 
    let indexHeight = getHeightPriceByIndex(index)
314
314
 
    let nextIndexHeight = getHeightPriceByIndex((index + 1))
315
315
 
    let priceByIndex = getPriceHistory(indexHeight)
316
316
 
    let amount = if ((lockedAssetId == neutrinoAssetIdString))
317
317
 
        then convertNeutrinoToWaves(lockedBalance, priceByIndex)
318
318
 
        else convertWavesToNeutrino(lockedBalance, priceByIndex)
319
319
 
    if (isBlocked)
320
320
 
        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
321
321
 
        else if ((0 >= amount))
322
322
 
            then throw((("balance equals zero (" + lockedAssetId) + ")"))
323
323
 
            else if ((unlockHeight > height))
324
324
 
                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw WAVES funds"))
325
325
 
                else if (if (if ((index > priceIndex))
326
326
 
                    then true
327
327
 
                    else (indexHeight > unlockHeight))
328
328
 
                    then true
329
329
 
                    else if ((nextIndexHeight != 0))
330
330
 
                        then (unlockHeight >= nextIndexHeight)
331
331
 
                        else false)
332
332
 
                    then throw("invalid price history index")
333
333
 
                    else ScriptResult(WriteSet([DataEntry(getAccountLockedBalanceKey(account, lockedAssetId), 0), DataEntry(getLockedBalanceKey(lockedAssetId), (getLockedBalance(lockedAssetId) - lockedBalance))]), TransferSet([ScriptTransfer(addressFromStringValue(account), amount, if ((lockedAssetId == neutrinoAssetIdString))
334
334
 
                        then unit
335
335
 
                        else neutrinoAssetId)]))
336
336
 
    }
337
337
 
338
338
 
339
339
 
340
340
 
@Callable(i)
341
341
 
func transferToAuction () = {
342
342
 
    let deficitBondAmount = (convertNeutrinoToBond(deficit) - assetBalance(addressFromStringValue(auctionContract), bondAssetId))
343
343
 
    let surplusBond = (convertNeutrinoToBond(surplus) - assetBalance(addressFromStringValue(auctionContract), neutrinoAssetId))
344
344
 
    if (isBlocked)
345
345
 
        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
346
346
 
        else if ((deficitBondAmount >= ((convertNeutrinoToBond(neutrinoSupply) * DEFICITOFFSET) / 100)))
347
347
 
            then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), deficitBondAmount, bondAssetId)])
348
348
 
            else if ((surplusBond > 0))
349
349
 
                then TransferSet([ScriptTransfer(addressFromStringValue(liquidationContract), convertBondToNeutrino(surplusBond), neutrinoAssetId)])
350
350
 
                else throw("bond were generated or do not need it")
351
351
 
    }
352
352
 
353
353
 
354
354
 
355
355
 
@Callable(i)
356
356
 
func transfer (account) = {
357
357
 
    let pmt = extract(i.payment)
358
358
 
    TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, pmt.assetId)])
359
359
 
    }
360
360
 
361
361
 
362
362
 
363
363
 
@Callable(i)
364
364
 
func nodeReward () = {
365
365
 
    let pmt = value(i.payment)
366
366
 
    if ((i.caller != addressFromStringValue(nodeAddress)))
367
367
 
        then throw("only node account is able to transfer staking rewards from main account")
368
368
 
        else if (isDefined(pmt.assetId))
369
369
 
            then throw("waves tokens only allowed")
370
370
 
            else {
371
371
 
                let amount = convertWavesToNeutrino(pmt.amount, currentPrice)
372
372
 
                let newRpdSyncIndex = (rpdSyncIndex + 1)
373
373
 
                ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), amount), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), amount, neutrinoAssetId)]))
374
374
 
                }
375
375
 
    }
376
376
 
377
377
 
378
378
 
379
379
 
@Callable(i)
380
380
 
func registrationLeaseTx (senderPublicKey,fee,timestamp,leaseTxHash) = {
381
381
 
    let totalFreeReserve = (((reserve * LEASINGSHARE) / 100) - convertNeutrinoToWaves(getLockedBalance(neutrinoAssetIdString), currentPrice))
382
382
 
    let amount = (totalFreeReserve / LEASINTXCOUNT)
383
383
 
    let txBytes = (((((base58'3h1H' + fromBase58String(senderPublicKey)) + fromBase58String(nodeAddress)) + toBytes(amount)) + toBytes(fee)) + toBytes(timestamp))
384
384
 
    let txHashBytes = blake2b256(txBytes)
385
385
 
    let txHash = toBase58String(txHashBytes)
386
386
 
    let pmt = extract(i.payment)
387
387
 
    if ((toString(i.caller) == nodeOracleProviderKey))
388
388
 
        then throw("invalid caller")
389
389
 
        else if (isDefined(pmt.assetId))
390
390
 
            then throw("invalid paymtn asset")
391
391
 
            else if ((leaseTxHash != txHash))
392
392
 
                then throw((("invalid tx hash(amount:" + toString(amount)) + ")"))
393
393
 
                else if ((leasingTxCount >= LEASINTXCOUNT))
394
394
 
                    then throw("the number of leasing transactions is equal to the maximum")
395
395
 
                    else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
396
396
 
                        then throw("invalid pubKey")
397
397
 
                        else if (if ((lastBlock.timestamp > timestamp))
398
398
 
                            then true
399
399
 
                            else (timestamp > (lastBlock.timestamp + 5400000)))
400
400
 
                            then throw((("invalid timestamp(lastBlock: " + toString(lastBlock.timestamp)) + ")"))
401
401
 
                            else if ((getLeaseTxStatus(txHash) != ""))
402
402
 
                                then throw("tx is exist")
403
403
 
                                else if ((pmt.amount != (fee * 2)))
404
404
 
                                    then throw("invalid payment amount")
405
405
 
                                    else if (if ((fee > 1000000))
406
406
 
                                        then true
407
407
 
                                        else (500000 > fee))
408
408
 
                                        then throw("invalid fee")
409
409
 
                                        else if (((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))
410
410
 
                                            then throw((("invalid amount(result:" + toString(((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))) + ")"))
411
411
 
                                            else WriteSet([DataEntry(getCancelLeaseTxReserveFeeKey(txHash), fee), DataEntry(LeasingTxCountKey, if ((getLeaseTxStatus(txHash) == ""))
412
412
 
                                                then (leasingTxCount + 1)
413
413
 
                                                else leasingTxCount), DataEntry(LeasingAmountKey, (leasingAmount + amount)), DataEntry(LeasingExpireBlockKey, if ((height > leasingExpireBlock))
414
414
 
                                                then (height + leasingInterval)
415
415
 
                                                else leasingExpireBlock), DataEntry(getLeaseTxStatusKey(txHash), NEW), DataEntry(getLeaseTxExpireSendBlockKey(txHash), (height + SENDTXEXPIRE)), DataEntry(getLeaseTxAmountByHashKey(txHash), amount), DataEntry(getLeaseTxBytesByHashKey(txHash), toBase64String(txBytes))])
416
416
 
    }
417
417
 
418
418
 
419
419
 
420
420
 
@Callable(i)
421
421
 
func cancelStuckLeaseTx (txHash) = if (if (if ((getLeaseTxStatus(txHash) == NEW))
422
422
 
    then !(isDefined(transactionHeightById(fromBase58String(txHash))))
423
423
 
    else false)
424
424
 
    then (height > getLeaseTxExpireSendBlock(txHash))
425
425
 
    else false)
426
426
 
    then {
427
427
 
        let amount = getLeaseTxAmountByHash(txHash)
428
428
 
        WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(txHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(getLockedBalance(neutrinoAssetIdString), currentPrice)))
429
429
 
            then false
430
430
 
            else true)])
431
431
 
        }
432
432
 
    else throw("invalid tx hash")
433
433
 
434
434
 
435
435
 
436
436
 
@Callable(i)
437
437
 
func registrationUnleaseTx (chainIdString,senderPublicKey,fee,timestamp,leaseTxHash) = {
438
438
 
    let txBytes = (((((base58'gm' + toBytes(chainIdString)) + fromBase58String(senderPublicKey)) + toBytes(fee)) + toBytes(timestamp)) + fromBase58String(leaseTxHash))
439
439
 
    let txHash = blake2b256(txBytes)
440
440
 
    if ((getLeaseTxStatus(leaseTxHash) != NEW))
441
441
 
        then throw("invalid tx status")
442
442
 
        else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
443
443
 
            then throw("invalid pubKey")
444
444
 
            else if (!(isDefined(transactionHeightById(txHash))))
445
445
 
                then throw("blockchain does not contain this transaction")
446
446
 
                else {
447
447
 
                    let amount = getLeaseTxAmountByHash(leaseTxHash)
448
448
 
                    WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(leaseTxHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(getLockedBalance(neutrinoAssetIdString), currentPrice)))
449
449
 
                        then false
450
450
 
                        else true)])
451
451
 
                    }
452
452
 
    }
453
453
 
454
454
 
455
455
 
@Verifier(tx)
456
456
 
func verify () = {
457
457
 
    let id = toBase58String(tx.id)
458
458
 
    match tx {
459
459
 
        case leaseTx: LeaseTransaction => 
460
460
 
            if (if ((leasingExpireBlock >= height))
461
461
 
                then (getLeaseTxExpireSendBlock(id) >= height)
462
462
 
                else false)
463
463
 
                then (getLeaseTxStatus(id) == NEW)
464
464
 
                else false
465
465
 
        case unleaseTx: LeaseCancelTransaction => 
466
466
 
            let leaseId = toBase58String(unleaseTx.leaseId)
467
467
 
            if (if (if ((height > leasingExpireBlock))
468
468
 
                then true
469
469
 
                else isRebalance)
470
470
 
                then (unleaseTx.fee == getCancelLeaseTxReserveFee(leaseId))
471
471
 
                else false)
472
472
 
                then (getLeaseTxStatus(leaseId) == NEW)
473
473
 
                else false
474
474
 
        case _ => 
475
475
 
            sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
476
476
 
    }
477
477
 
    }
478
478
 

github/deemru/w8io/873ac7e 
60.93 ms ◑