tx · 58WAMj2f6x9KH3G2YpFkzmBBSzkRX3ciBz66VBz5eiJU

3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F:  -0.01400000 Waves

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

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

View: original | compacted
Prev: 3WumQczKo5CDMk4ysHafZzPMo3hiRhhfCteKFe9XS1xr
Next: 7pz4Zto5oFkVMu55VJizdhvUkBeES52L4uweQcsfmPo8

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

github/deemru/w8io/873ac7e 
91.52 ms ◑