w8 · tx · FL2···Rv7

tx · FL2vJe5e3WkAS7kZsk4SVohpvsLPvBriWWY7dRrc2Rv7

3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F:  -0.01400000 Waves

2019.11.01 22:39 [746228] smart account 3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F > SELF 0.00000000 Waves

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

View: original | compacted
Prev: F2YAvX4T8eVU49N2upZfDBQBHfAg5TxAtJD3aoqAeNoD
Next: DvWKBSGRxUCpy1wx9tViiYeAdSqEL54QcWrbTv9VU3vV

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 CANCELED = "canceled"
69 69  
70 70  let NEW = "new"
71 71  
72 72  let FILLED = "filled"
73 73  
74 74  let NeutrinoAssetIdKey = "neutrino_asset_id"
75 75  
76 76  let BondAssetIdKey = "bond_asset_id"
77 77  
78 78  let ReserveContractKey = "reserve_contract"
79 79  
80 80  let AuctionContractKey = "auction_contract"
81 81  
82 82  let RPDContractKey = "rpd_contract"
83 83  
84 84  let ContolContractKey = "control_contract"
85 85  
86 86  let BalanceLockIntervalKey = "balance_lock_interval"
87 87  
88 88  let MinWavesSwapAmountKey = "min_waves_swap_amount"
89 89  
90 90  let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
91 91  
92 92  let NodeAddressKey = "node_address"
93 93  
94 94  let LeasingIntervalKey = "leasing_interval"
95 95  
96 96  let PriceKey = "price"
97 97  
98 98  let PriceIndexKey = "price_index"
99 99  
100 100  let ScriptUpdateIntervalKey = "script_update_interval"
101 101  
102 102  let NeutrinoBalanceKey = "neutrino_"
103 103  
104 104  let WavesBalanceKey = "waves_"
105 105  
106 106  let BalanceUnlockBlockKey = "balance_block_"
107 107  
108 108  let OrderbookKey = "orderbook"
109 109  
110 110  let OrderTotalKey = "order_total_"
111 111  
112 112  let OrderOwnerKey = "order_owner_"
113 113  
114 114  let OrderHeightKey = "order_height_"
115 115  
116 116  let OrderFilledTotalKey = "order_filled_total_"
117 117  
118 118  let OrderStatusKey = "order_status_"
119 119  
120 120  let RPDSyncIndexKey = "rpd_sync_index"
121 121  
122 122  let RPDProfitKey = "rpd_profit"
123 123  
124 124  let RPDBalanceKey = "rpd_balance"
125 125  
126 126  let IsBlockedKey = "is_blocked"
127 127  
128 128  let IsLeasingProfitTxExistKey = "is_leasing_profit"
129 129  
130 130  let ScriptUpdateBlockKey = "script_update_block"
131 131  
132 132  let LeaseTxKey = "lease_tx"
133 133  
134 134  let LeaseTxStatusKey = "lease_tx_status"
135 135  
136 136  let LeasingAmountKey = "leasing_amount"
137 137  
138 138  let LeaseTxExpireSendBlockKey = "leasing_expire_send"
139 139  
140 140  let LeasingExpireBlockKey = "leasing_expire_block"
141 141  
142 142  let IsRebalanceKey = "is_rebalance"
143 143  
144 144  let SwapLockedBalanceKey = "swap_locked_balance"
145 145  
146 146  let SwapNeutrinoLockedBalanceKey = "swap_neutrino_locked_balance"
147 147  
148 148  let LeasingTxCountKey = "leasing_index"
149 149  
150 150  func getRPDSnapshotContractBalanceKey (count,assetId) = ((((RPDBalanceKey + "_") + toBase58String(assetId)) + "_") + toString(count))
151 151  
152 152  
153 153  func getRPDContractBalanceKey (assetId) = ((RPDBalanceKey + "_") + toBase58String(assetId))
154 154  
155 155  
156 156  func getRPDProfitKey (count) = ((RPDProfitKey + "_") + toString(count))
157 157  
158 158  
159 159  func getNeutrinoBalanceKey (owner) = (NeutrinoBalanceKey + owner)
160 160  
161 161  
162 162  func getWavesBalanceKey (owner) = (WavesBalanceKey + owner)
163 163  
164 164  
165 165  func getBalanceUnlockBlockKey (owner) = (BalanceUnlockBlockKey + owner)
166 166  
167 167  
168 168  func getOrderTotalKey (orderId) = (OrderTotalKey + orderId)
169 169  
170 170  
171 171  func getOrderOwnerKey (orderId) = (OrderOwnerKey + orderId)
172 172  
173 173  
174 174  func getOrderHeightKey (orderId) = (OrderHeightKey + orderId)
175 175  
176 176  
177 177  func getOrderStatusKey (orderId) = (OrderStatusKey + orderId)
178 178  
179 179  
180 180  func getOrderFilledTotalKey (orderId) = (OrderFilledTotalKey + orderId)
181 181  
182 182  
183 183  func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
184 184  
185 185  
186 186  func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
187 187  
188 188  
189 189  func getLeaseTxStatusKey (hash) = ((LeaseTxStatusKey + "_") + hash)
190 190  
191 191  
192 192  func getLeaseTxAmountByHashKey (hash) = ((LeasingAmountKey + "_") + hash)
193 193  
194 194  
195 195  func getLeaseTxBytesByHashKey (hash) = ((LeaseTxKey + "_") + hash)
196 196  
197 197  
198 198  func getLeaseTxExpireSendBlockKey (hash) = ((LeaseTxExpireSendBlockKey + "_") + hash)
199 199  
200 200  
201 201  func getIsRebalanceByAddressKey (address) = ((IsRebalanceKey + "_") + address)
202 202  
203 203  
204 204  let controlContract = getStringByKey(ContolContractKey)
205 205  
206 206  let price = getNumberByAddressAndKey(controlContract, PriceKey)
207 207  
208 208  let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
209 209  
210 210  func convertNeutrinoToWavesByPrice (amount,convertPrice) = ((((amount * 100) / convertPrice) * WAVELET) / PAULI)
211 211  
212 212  
213 213  func convertNeutrinoToWaves (amount) = ((((amount * 100) / price) * WAVELET) / PAULI)
214 214  
215 215  
216 216  func convertWavesToNeutrino (amount) = ((((amount * price) / 100) * PAULI) / WAVELET)
217 217  
218 218  
219 219  func convertNeutrinoToBond (amount) = (amount / PAULI)
220 220  
221 221  
222 222  func convertBondToNeutrino (amount) = (amount * PAULI)
223 223  
224 224  
225 225  func convertWavesToBond (amount) = convertNeutrinoToBond(convertWavesToNeutrino(amount))
226 226  
227 227  
228 228  let leasingTxCount = getNumberByKey(LeasingTxCountKey)
229 229  
230 230  let isRebalance = getBoolByKey(IsRebalanceKey)
231 231  
232 232  let leasingInterval = getNumberByKey(LeasingIntervalKey)
233 233  
234 234  let leasingExpireBlock = getNumberByKey(LeasingExpireBlockKey)
235 235  
236 236  let leasingAmount = getNumberByKey(LeasingAmountKey)
237 237  
238 238  let swapNeutrinoLockedBalance = getNumberByKey(SwapNeutrinoLockedBalanceKey)
239 239  
240 240  let swapWavesLockedBalance = getNumberByKey(SwapLockedBalanceKey)
241 241  
242 242  let nodeAddress = getStringByKey(NodeAddressKey)
243 243  
244 244  let scriptUpdateInterval = getNumberByAddressAndKey(ContolContractKey, ScriptUpdateIntervalKey)
245 245  
246 246  let scriptUpdateBlock = getNumberByAddressAndKey(controlContract, ScriptUpdateBlockKey)
247 247  
248 248  let rpdSyncIndex = getNumberByKey(RPDSyncIndexKey)
249 249  
250 250  let balanceLockInterval = getNumberByKey(BalanceLockIntervalKey)
251 251  
252 252  let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
253 253  
254 254  let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
255 255  
256 256  let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
257 257  
258 258  let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
259 259  
260 260  let reserveContract = getStringByKey(ReserveContractKey)
261 261  
262 262  let auctionContract = getStringByKey(AuctionContractKey)
263 263  
264 264  let rpdContract = getStringByKey(RPDContractKey)
265 265  
266 266  let reserve = (wavesBalance(this) - swapWavesLockedBalance)
267 267  
268 268  let reserveWithoutLeasing = (reserve - leasingAmount)
269 269  
270 270  let orderbook = getStringByKey(OrderbookKey)
271 271  
272 272  let bondAssetId = fromBase58String(getStringByKey(BondAssetIdKey))
273 273  
274 274  let bondSupply = {
275 275      let info = extract(assetInfo(bondAssetId))
276 276      (info.quantity - assetBalance(this, bondAssetId))
277 277      }
278 278  
279 279  let neutrinoSupply = {
280 280      let info = extract(assetInfo(neutrinoAssetId))
281 281      ((info.quantity - assetBalance(this, neutrinoAssetId)) + swapNeutrinoLockedBalance)
282 282      }
283 283  
284 284  let surplus = (convertWavesToNeutrino(reserve) - neutrinoSupply)
285 285  
286 286  let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve))
287 287  
288 288  func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
289 289  
290 290  
291 291  func getWavesBalance (owner) = getNumberByKey(getWavesBalanceKey(owner))
292 292  
293 293  
294 294  func getNeutrinoBalance (owner) = getNumberByKey(getNeutrinoBalanceKey(owner))
295 295  
296 296  
297 297  func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
298 298  
299 299  
300 300  func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
301 301  
302 302  
303 303  func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
304 304  
305 305  
306 306  func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
307 307  
308 308  
309 309  func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
310 310  
311 311  
312 312  func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
313 313  
314 314  
315 315  func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
316 316  
317 317  
318 318  func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
319 319  
320 320  
321 321  func getLeaseTxStatus (hash) = getStringByKey(getLeaseTxStatusKey(hash))
322 322  
323 323  
324 324  func getLeaseTxAmountByHash (hash) = getNumberByKey(getLeaseTxAmountByHashKey(hash))
325 325  
326 326  
327 327  func getLeaseTxBytesByHash (hash) = getStringByKey(getLeaseTxBytesByHashKey(hash))
328 328  
329 329  
330 330  func getLeaseTxExpireSendBlock (hash) = getNumberByKey(getLeaseTxExpireSendBlockKey(hash))
331 331  
332 332  
333 333  func getOrderElementById (id) = (id + LISTSPLITSYMBOL)
334 334  
335 335  
336 336  func addOrder (orderId) = (orderbook + getOrderElementById(orderId))
337 337  
338 338  
339 339  func dropOrder (orderId) = {
340 340      let parts = split(orderbook, getOrderElementById(orderId))
341 341      (parts[0] + parts[1])
342 342      }
343 343  
344 344  
345 345  @Callable(i)
346 346  func swapWavesToNeutrino () = {
347 347      let pmt = extract(i.payment)
348 348      if ((minWavesSwapAmount > pmt.amount))
349 349          then throw("amount less min")
350 350          else if (isDefined(pmt.assetId))
351 351              then throw("can use waves only")
352 352              else if (isBlocked)
353 353                  then throw("contract is blocked")
354 354                  else {
355 355                      let amount = convertWavesToNeutrino(pmt.amount)
356 356                      TransferSet([ScriptTransfer(i.caller, amount, neutrinoAssetId)])
357 357                      }
358 358      }
359 359  
360 360  
361 361  
362 362  @Callable(i)
363 363  func swapNeutrinoToWaves () = {
364 364      let pmt = extract(i.payment)
365 365      let account = toString(i.caller)
366 366      if ((minNeutrinoSwapAmount > pmt.amount))
367 367          then throw("amount less min")
368 368          else if (isBlocked)
369 369              then throw("contract is blocked")
370 370              else if ((pmt.assetId != neutrinoAssetId))
371 371                  then throw("can use neutrino only")
372 372                  else if ((getUnlockBalanceBlock(account) > height))
373 373                      then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
374 374                      else if ((getNeutrinoBalance(account) != 0))
375 375                          then throw("use withdraw")
376 376                          else {
377 377                              let neutrinoAmount = pmt.amount
378 378                              let newSwapNeutrinoLockedBalance = (swapNeutrinoLockedBalance + neutrinoAmount)
379 379                              WriteSet([DataEntry(getNeutrinoBalanceKey(account), (getNeutrinoBalance(account) + neutrinoAmount)), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(SwapNeutrinoLockedBalanceKey, newSwapNeutrinoLockedBalance), DataEntry(IsRebalanceKey, if ((reserveWithoutLeasing >= convertNeutrinoToWaves(newSwapNeutrinoLockedBalance)))
380 380                                  then false
381 381                                  else true)])
382 382                              }
383 383      }
384 384  
385 385  
386 386  
387 387  @Callable(i)
388 388  func withdraw (account,index) = {
389 389      let indexHeight = getHeightPriceByIndex(index)
390 390      let nextIndexHeight = getHeightPriceByIndex((index + 1))
391 391      let unlockHeight = getUnlockBalanceBlock(account)
392 392      let neutrinoAmount = getNeutrinoBalance(account)
393 393      let indexPrice = getPriceHistory(indexHeight)
394 394      let amount = convertNeutrinoToWavesByPrice(neutrinoAmount, indexPrice)
395 395      let totalWavesWithdraw = (getWavesBalance(account) + amount)
396 396      if (isBlocked)
397 397          then throw("contract is blocked")
398 398          else if ((unlockHeight > height))
399 399              then throw("wait a couple of blocks for withdraw")
400 400              else if (if (if ((index > priceIndex))
401 401                  then true
402 402                  else (indexHeight > unlockHeight))
403 403                  then true
404 404                  else if ((nextIndexHeight != 0))
405 405                      then (unlockHeight >= nextIndexHeight)
406 406                      else false)
407 407                  then throw("invalid index")
408 408                  else ScriptResult(WriteSet([DataEntry(getWavesBalanceKey(account), 0), DataEntry(getNeutrinoBalanceKey(account), 0), DataEntry(SwapLockedBalanceKey, (swapWavesLockedBalance - getWavesBalance(account))), DataEntry(SwapNeutrinoLockedBalanceKey, (swapNeutrinoLockedBalance - neutrinoAmount))]), TransferSet([ScriptTransfer(addressFromStringValue(account), totalWavesWithdraw, unit)]))
409 409      }
410 410  
411 411  
412 412  
413 413  @Callable(i)
414 414  func generateBond () = {
415 415      let balanceAuction = assetBalance(addressFromStringValue(auctionContract), bondAssetId)
416 416      let amount = (convertNeutrinoToBond(deficit) - balanceAuction)
417 417      if (isBlocked)
418 418          then throw("contract is blocked")
419 419          else if ((amount >= 10))
420 420              then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), amount, bondAssetId)])
421 421              else throw("bond were generated or do not need it")
422 422      }
423 423  
424 424  
425 425  
426 426  @Callable(i)
427 427  func setOrder () = {
428 428      let pmt = extract(i.payment)
429 429      let newOrderId = toBase58String(keccak256(((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height))))
430 430      if ((pmt.assetId != bondAssetId))
431 431          then throw("can use bond only")
432 432          else if ((getOrderOwner(newOrderId) != ""))
433 433              then throw("order exists")
434 434              else WriteSet([DataEntry(OrderbookKey, addOrder(newOrderId)), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
435 435      }
436 436  
437 437  
438 438  
439 439  @Callable(i)
440 440  func cancelOrder (orderId) = {
441 441      let owner = getOrderOwner(orderId)
442 442      let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
443 443      if ((owner != toString(i.caller)))
444 444          then throw("permission denied")
445 445          else if ((getOrderStatus(orderId) != NEW))
446 446              then throw("invalid order status")
447 447              else ScriptResult(WriteSet([DataEntry(OrderbookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
448 448      }
449 449  
450 450  
451 451  
452 452  @Callable(i)
453 453  func executeOrder () = {
454 454      let orderId = split(orderbook, LISTSPLITSYMBOL)[0]
455 455      let orderTotal = getOrderTotal(orderId)
456 456      let orderOwner = getOrderOwner(orderId)
457 457      let filledTotal = getOrderFilledTotal(orderId)
458 458      let surplusBond = convertNeutrinoToBond(surplus)
459 459      if (isBlocked)
460 460          then throw("contract is blocked")
461 461          else if ((0 >= surplusBond))
462 462              then throw("surplus is less than zero")
463 463              else if (if ((orderOwner == ""))
464 464                  then (surplusBond >= 10)
465 465                  else false)
466 466                  then {
467 467                      let newRpdSyncIndex = (rpdSyncIndex + 1)
468 468                      ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), surplus), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), surplus, neutrinoAssetId)]))
469 469                      }
470 470                  else {
471 471                      let amount = (orderTotal - filledTotal)
472 472                      let status = if ((surplusBond >= amount))
473 473                          then FILLED
474 474                          else NEW
475 475                      let newFilledTotal = if ((surplusBond >= amount))
476 476                          then amount
477 477                          else surplusBond
478 478                      ScriptResult(WriteSet([DataEntry(OrderbookKey, if ((surplusBond >= amount))
479 479                          then dropOrder(orderId)
480 480                          else orderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + newFilledTotal)), DataEntry(getOrderStatusKey(orderId), status)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(newFilledTotal), neutrinoAssetId)]))
481 481                      }
482 482      }
483 483  
484 484  
485 485  
486 486  @Callable(i)
487 487  func transfer (account) = {
488 488      let pmt = extract(i.payment)
489 489      TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, pmt.assetId)])
490 490      }
491 491  
492 492  
493 493  
494 494  @Callable(i)
495 495  func nodeReward () = {
496 496      let pmt = value(i.payment)
497 497      if ((i.caller != addressFromStringValue(nodeAddress)))
498 498          then throw("permission denied")
499 499          else if (isDefined(pmt.assetId))
500 500              then throw("waves only")
501 501              else {
502 502                  let amount = convertWavesToNeutrino(pmt.amount)
503 503                  let newRpdSyncIndex = (rpdSyncIndex + 1)
504 504                  ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), amount), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), amount, neutrinoAssetId)]))
505 505                  }
506 506      }
507 507  
508 508  
509 509  
510 510  @Callable(i)
511 511  func registrationLeaseTx (senderPublicKey,fee,timestamp,leaseTxHash) = {
512 512      let totalFreeReserve = (((reserve * LEASINGSHARE) / 100) - convertNeutrinoToWaves(swapNeutrinoLockedBalance))
513 513      let amount = (totalFreeReserve / LEASINTXCOUNT)
514 514      let txBytes = (((((base58'3h1H' + fromBase58String(senderPublicKey)) + fromBase58String(nodeAddress)) + toBytes(amount)) + toBytes(fee)) + toBytes(timestamp))
515 515      let txHashBytes = blake2b256(txBytes)
516 516      let txHash = toBase58String(txHashBytes)
517 517      if ((leaseTxHash != txHash))
518 518          then throw("invalid tx hash")
519 519          else if ((leasingTxCount >= LEASINTXCOUNT))
520 520              then throw("the number of leasing transactions is equal to the maximum")
521 521              else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
522 522                  then throw("invalid pubKey")
523 523                  else if (if ((lastBlock.timestamp > timestamp))
524 524                      then true
525 525                      else (timestamp > (lastBlock.timestamp + 5400000)))
526 526                      then throw((("invalid timestamp(lastBlock: " + toString(lastBlock.timestamp)) + ")"))
527 527                      else if ((getLeaseTxStatus(txHash) == ""))
528 528                          then throw("tx is exist")
529 529                          else if (if ((fee > 1000000))
530 530                              then true
531 531                              else (500000 > fee))
532 532                              then throw("invalid fee")
533 533                              else if (((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))
534 534                                  then throw((("invalid amount(result:" + toString(((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))) + ")"))
535 535                                  else WriteSet([DataEntry(LeasingTxCountKey, if ((getLeaseTxStatus(txHash) == ""))
536 536                                      then (leasingTxCount + 1)
537 537                                      else leasingTxCount), DataEntry(LeasingAmountKey, (leasingAmount + amount)), DataEntry(LeasingExpireBlockKey, if ((height > leasingExpireBlock))
538 538                                      then (height + leasingInterval)
539 539                                      else leasingExpireBlock), DataEntry(getLeaseTxStatusKey(txHash), NEW), DataEntry(getLeaseTxExpireSendBlockKey(txHash), (height + SENDTXEXPIRE)), DataEntry(getLeaseTxAmountByHashKey(txHash), amount), DataEntry(getLeaseTxBytesByHashKey(txHash), toBase64String(txBytes))])
540 540      }
541 541  
542 542  
543 543  
544 544  @Callable(i)
545 545  func cancelStuckLeaseTx (txHash) = if (if (if ((getLeaseTxStatus(txHash) == NEW))
546 546      then !(isDefined(transactionHeightById(fromBase58String(txHash))))
547 547      else false)
548 548      then (height > getLeaseTxExpireSendBlock(txHash))
549 549      else false)
550 550      then {
551 551          let amount = getLeaseTxAmountByHash(txHash)
552 552          WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(txHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(swapNeutrinoLockedBalance)))
553 553              then false
554 554              else true)])
555 555          }
556 556      else throw("invalid tx hash")
557 557  
558 558  
559 559  
560 560  @Callable(i)
561 561  func registrationUnleaseTx (chainIdString,senderPublicKey,fee,timestamp,leaseTxHash) = {
562 562      let txBytes = (((((base58'gm' + toBytes(chainIdString)) + fromBase58String(senderPublicKey)) + toBytes(fee)) + toBytes(timestamp)) + fromBase58String(leaseTxHash))
563 563      let txHash = blake2b256(txBytes)
564 564      if ((getLeaseTxStatus(leaseTxHash) != NEW))
565 565          then throw("invalid tx status")
566 566          else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
567 567              then throw("invalid pubKey")
568 568              else if (!(isDefined(transactionHeightById(txHash))))
569 569                  then throw("blockchain does not contain this transaction")
570 570                  else {
571 571                      let amount = getLeaseTxAmountByHash(leaseTxHash)
572 572                      WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(leaseTxHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(swapNeutrinoLockedBalance)))
573 573                          then false
574 574                          else true)])
575 575                      }
576 576      }
577 577  
578 578  
579 579  @Verifier(tx)
580 580  func verify () = {
581 581      let id = toBase58String(tx.id)
582 582      match tx {
583 583          case leaseTx: LeaseTransaction => 
584 584              if (if ((leasingExpireBlock >= height))
585 585                  then (getLeaseTxExpireSendBlock(id) >= height)
586 586                  else false)
587 587                  then (getLeaseTxStatusKey(id) == NEW)
588 588                  else false
589 589          case unleaseTx: LeaseCancelTransaction => 
590 590              if (if (if ((height > leasingExpireBlock))
591 591                  then true
592 592                  else isRebalance)
593 593                  then if ((unleaseTx.fee >= 500000))
594 594                      then (1000000 >= unleaseTx.fee)
595 595                      else false
596 596                  else false)
597 597                  then (getLeaseTxStatusKey(toBase58String(unleaseTx.leaseId)) == NEW)
598 598                  else false
599 599          case _ => 
600 600              sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
601 601      }
602 602      }
603 603

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 CANCELED = "canceled"
69	69
70	70	let NEW = "new"
71	71
72	72	let FILLED = "filled"
73	73
74	74	let NeutrinoAssetIdKey = "neutrino_asset_id"
75	75
76	76	let BondAssetIdKey = "bond_asset_id"
77	77
78	78	let ReserveContractKey = "reserve_contract"
79	79
80	80	let AuctionContractKey = "auction_contract"
81	81
82	82	let RPDContractKey = "rpd_contract"
83	83
84	84	let ContolContractKey = "control_contract"
85	85
86	86	let BalanceLockIntervalKey = "balance_lock_interval"
87	87
88	88	let MinWavesSwapAmountKey = "min_waves_swap_amount"
89	89
90	90	let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
91	91
92	92	let NodeAddressKey = "node_address"
93	93
94	94	let LeasingIntervalKey = "leasing_interval"
95	95
96	96	let PriceKey = "price"
97	97
98	98	let PriceIndexKey = "price_index"
99	99
100	100	let ScriptUpdateIntervalKey = "script_update_interval"
101	101
102	102	let NeutrinoBalanceKey = "neutrino_"
103	103
104	104	let WavesBalanceKey = "waves_"
105	105
106	106	let BalanceUnlockBlockKey = "balance_block_"
107	107
108	108	let OrderbookKey = "orderbook"
109	109
110	110	let OrderTotalKey = "order_total_"
111	111
112	112	let OrderOwnerKey = "order_owner_"
113	113
114	114	let OrderHeightKey = "order_height_"
115	115
116	116	let OrderFilledTotalKey = "order_filled_total_"
117	117
118	118	let OrderStatusKey = "order_status_"
119	119
120	120	let RPDSyncIndexKey = "rpd_sync_index"
121	121
122	122	let RPDProfitKey = "rpd_profit"
123	123
124	124	let RPDBalanceKey = "rpd_balance"
125	125
126	126	let IsBlockedKey = "is_blocked"
127	127
128	128	let IsLeasingProfitTxExistKey = "is_leasing_profit"
129	129
130	130	let ScriptUpdateBlockKey = "script_update_block"
131	131
132	132	let LeaseTxKey = "lease_tx"
133	133
134	134	let LeaseTxStatusKey = "lease_tx_status"
135	135
136	136	let LeasingAmountKey = "leasing_amount"
137	137
138	138	let LeaseTxExpireSendBlockKey = "leasing_expire_send"
139	139
140	140	let LeasingExpireBlockKey = "leasing_expire_block"
141	141
142	142	let IsRebalanceKey = "is_rebalance"
143	143
144	144	let SwapLockedBalanceKey = "swap_locked_balance"
145	145
146	146	let SwapNeutrinoLockedBalanceKey = "swap_neutrino_locked_balance"
147	147
148	148	let LeasingTxCountKey = "leasing_index"
149	149
150	150	func getRPDSnapshotContractBalanceKey (count,assetId) = ((((RPDBalanceKey + "_") + toBase58String(assetId)) + "_") + toString(count))
151	151
152	152
153	153	func getRPDContractBalanceKey (assetId) = ((RPDBalanceKey + "_") + toBase58String(assetId))
154	154
155	155
156	156	func getRPDProfitKey (count) = ((RPDProfitKey + "_") + toString(count))
157	157
158	158
159	159	func getNeutrinoBalanceKey (owner) = (NeutrinoBalanceKey + owner)
160	160
161	161
162	162	func getWavesBalanceKey (owner) = (WavesBalanceKey + owner)
163	163
164	164
165	165	func getBalanceUnlockBlockKey (owner) = (BalanceUnlockBlockKey + owner)
166	166
167	167
168	168	func getOrderTotalKey (orderId) = (OrderTotalKey + orderId)
169	169
170	170
171	171	func getOrderOwnerKey (orderId) = (OrderOwnerKey + orderId)
172	172
173	173
174	174	func getOrderHeightKey (orderId) = (OrderHeightKey + orderId)
175	175
176	176
177	177	func getOrderStatusKey (orderId) = (OrderStatusKey + orderId)
178	178
179	179
180	180	func getOrderFilledTotalKey (orderId) = (OrderFilledTotalKey + orderId)
181	181
182	182
183	183	func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
184	184
185	185
186	186	func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
187	187
188	188
189	189	func getLeaseTxStatusKey (hash) = ((LeaseTxStatusKey + "_") + hash)
190	190
191	191
192	192	func getLeaseTxAmountByHashKey (hash) = ((LeasingAmountKey + "_") + hash)
193	193
194	194
195	195	func getLeaseTxBytesByHashKey (hash) = ((LeaseTxKey + "_") + hash)
196	196
197	197
198	198	func getLeaseTxExpireSendBlockKey (hash) = ((LeaseTxExpireSendBlockKey + "_") + hash)
199	199
200	200
201	201	func getIsRebalanceByAddressKey (address) = ((IsRebalanceKey + "_") + address)
202	202
203	203
204	204	let controlContract = getStringByKey(ContolContractKey)
205	205
206	206	let price = getNumberByAddressAndKey(controlContract, PriceKey)
207	207
208	208	let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
209	209
210	210	func convertNeutrinoToWavesByPrice (amount,convertPrice) = ((((amount * 100) / convertPrice) * WAVELET) / PAULI)
211	211
212	212
213	213	func convertNeutrinoToWaves (amount) = ((((amount * 100) / price) * WAVELET) / PAULI)
214	214
215	215
216	216	func convertWavesToNeutrino (amount) = ((((amount * price) / 100) * PAULI) / WAVELET)
217	217
218	218
219	219	func convertNeutrinoToBond (amount) = (amount / PAULI)
220	220
221	221
222	222	func convertBondToNeutrino (amount) = (amount * PAULI)
223	223
224	224
225	225	func convertWavesToBond (amount) = convertNeutrinoToBond(convertWavesToNeutrino(amount))
226	226
227	227
228	228	let leasingTxCount = getNumberByKey(LeasingTxCountKey)
229	229
230	230	let isRebalance = getBoolByKey(IsRebalanceKey)
231	231
232	232	let leasingInterval = getNumberByKey(LeasingIntervalKey)
233	233
234	234	let leasingExpireBlock = getNumberByKey(LeasingExpireBlockKey)
235	235
236	236	let leasingAmount = getNumberByKey(LeasingAmountKey)
237	237
238	238	let swapNeutrinoLockedBalance = getNumberByKey(SwapNeutrinoLockedBalanceKey)
239	239
240	240	let swapWavesLockedBalance = getNumberByKey(SwapLockedBalanceKey)
241	241
242	242	let nodeAddress = getStringByKey(NodeAddressKey)
243	243
244	244	let scriptUpdateInterval = getNumberByAddressAndKey(ContolContractKey, ScriptUpdateIntervalKey)
245	245
246	246	let scriptUpdateBlock = getNumberByAddressAndKey(controlContract, ScriptUpdateBlockKey)
247	247
248	248	let rpdSyncIndex = getNumberByKey(RPDSyncIndexKey)
249	249
250	250	let balanceLockInterval = getNumberByKey(BalanceLockIntervalKey)
251	251
252	252	let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
253	253
254	254	let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
255	255
256	256	let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
257	257
258	258	let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
259	259
260	260	let reserveContract = getStringByKey(ReserveContractKey)
261	261
262	262	let auctionContract = getStringByKey(AuctionContractKey)
263	263
264	264	let rpdContract = getStringByKey(RPDContractKey)
265	265
266	266	let reserve = (wavesBalance(this) - swapWavesLockedBalance)
267	267
268	268	let reserveWithoutLeasing = (reserve - leasingAmount)
269	269
270	270	let orderbook = getStringByKey(OrderbookKey)
271	271
272	272	let bondAssetId = fromBase58String(getStringByKey(BondAssetIdKey))
273	273
274	274	let bondSupply = {
275	275	let info = extract(assetInfo(bondAssetId))
276	276	(info.quantity - assetBalance(this, bondAssetId))
277	277	}
278	278
279	279	let neutrinoSupply = {
280	280	let info = extract(assetInfo(neutrinoAssetId))
281	281	((info.quantity - assetBalance(this, neutrinoAssetId)) + swapNeutrinoLockedBalance)
282	282	}
283	283
284	284	let surplus = (convertWavesToNeutrino(reserve) - neutrinoSupply)
285	285
286	286	let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve))
287	287
288	288	func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
289	289
290	290
291	291	func getWavesBalance (owner) = getNumberByKey(getWavesBalanceKey(owner))
292	292
293	293
294	294	func getNeutrinoBalance (owner) = getNumberByKey(getNeutrinoBalanceKey(owner))
295	295
296	296
297	297	func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
298	298
299	299
300	300	func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
301	301
302	302
303	303	func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
304	304
305	305
306	306	func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
307	307
308	308
309	309	func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
310	310
311	311
312	312	func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
313	313
314	314
315	315	func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
316	316
317	317
318	318	func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
319	319
320	320
321	321	func getLeaseTxStatus (hash) = getStringByKey(getLeaseTxStatusKey(hash))
322	322
323	323
324	324	func getLeaseTxAmountByHash (hash) = getNumberByKey(getLeaseTxAmountByHashKey(hash))
325	325
326	326
327	327	func getLeaseTxBytesByHash (hash) = getStringByKey(getLeaseTxBytesByHashKey(hash))
328	328
329	329
330	330	func getLeaseTxExpireSendBlock (hash) = getNumberByKey(getLeaseTxExpireSendBlockKey(hash))
331	331
332	332
333	333	func getOrderElementById (id) = (id + LISTSPLITSYMBOL)
334	334
335	335
336	336	func addOrder (orderId) = (orderbook + getOrderElementById(orderId))
337	337
338	338
339	339	func dropOrder (orderId) = {
340	340	let parts = split(orderbook, getOrderElementById(orderId))
341	341	(parts[0] + parts[1])
342	342	}
343	343
344	344
345	345	@Callable(i)
346	346	func swapWavesToNeutrino () = {
347	347	let pmt = extract(i.payment)
348	348	if ((minWavesSwapAmount > pmt.amount))
349	349	then throw("amount less min")
350	350	else if (isDefined(pmt.assetId))
351	351	then throw("can use waves only")
352	352	else if (isBlocked)
353	353	then throw("contract is blocked")
354	354	else {
355	355	let amount = convertWavesToNeutrino(pmt.amount)
356	356	TransferSet([ScriptTransfer(i.caller, amount, neutrinoAssetId)])
357	357	}
358	358	}
359	359
360	360
361	361
362	362	@Callable(i)
363	363	func swapNeutrinoToWaves () = {
364	364	let pmt = extract(i.payment)
365	365	let account = toString(i.caller)
366	366	if ((minNeutrinoSwapAmount > pmt.amount))
367	367	then throw("amount less min")
368	368	else if (isBlocked)
369	369	then throw("contract is blocked")
370	370	else if ((pmt.assetId != neutrinoAssetId))
371	371	then throw("can use neutrino only")
372	372	else if ((getUnlockBalanceBlock(account) > height))
373	373	then throw((("await " + toString((getUnlockBalanceBlock(account) - height))) + " blocks"))
374	374	else if ((getNeutrinoBalance(account) != 0))
375	375	then throw("use withdraw")
376	376	else {
377	377	let neutrinoAmount = pmt.amount
378	378	let newSwapNeutrinoLockedBalance = (swapNeutrinoLockedBalance + neutrinoAmount)
379	379	WriteSet([DataEntry(getNeutrinoBalanceKey(account), (getNeutrinoBalance(account) + neutrinoAmount)), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(SwapNeutrinoLockedBalanceKey, newSwapNeutrinoLockedBalance), DataEntry(IsRebalanceKey, if ((reserveWithoutLeasing >= convertNeutrinoToWaves(newSwapNeutrinoLockedBalance)))
380	380	then false
381	381	else true)])
382	382	}
383	383	}
384	384
385	385
386	386
387	387	@Callable(i)
388	388	func withdraw (account,index) = {
389	389	let indexHeight = getHeightPriceByIndex(index)
390	390	let nextIndexHeight = getHeightPriceByIndex((index + 1))
391	391	let unlockHeight = getUnlockBalanceBlock(account)
392	392	let neutrinoAmount = getNeutrinoBalance(account)
393	393	let indexPrice = getPriceHistory(indexHeight)
394	394	let amount = convertNeutrinoToWavesByPrice(neutrinoAmount, indexPrice)
395	395	let totalWavesWithdraw = (getWavesBalance(account) + amount)
396	396	if (isBlocked)
397	397	then throw("contract is blocked")
398	398	else if ((unlockHeight > height))
399	399	then throw("wait a couple of blocks for withdraw")
400	400	else if (if (if ((index > priceIndex))
401	401	then true
402	402	else (indexHeight > unlockHeight))
403	403	then true
404	404	else if ((nextIndexHeight != 0))
405	405	then (unlockHeight >= nextIndexHeight)
406	406	else false)
407	407	then throw("invalid index")
408	408	else ScriptResult(WriteSet([DataEntry(getWavesBalanceKey(account), 0), DataEntry(getNeutrinoBalanceKey(account), 0), DataEntry(SwapLockedBalanceKey, (swapWavesLockedBalance - getWavesBalance(account))), DataEntry(SwapNeutrinoLockedBalanceKey, (swapNeutrinoLockedBalance - neutrinoAmount))]), TransferSet([ScriptTransfer(addressFromStringValue(account), totalWavesWithdraw, unit)]))
409	409	}
410	410
411	411
412	412
413	413	@Callable(i)
414	414	func generateBond () = {
415	415	let balanceAuction = assetBalance(addressFromStringValue(auctionContract), bondAssetId)
416	416	let amount = (convertNeutrinoToBond(deficit) - balanceAuction)
417	417	if (isBlocked)
418	418	then throw("contract is blocked")
419	419	else if ((amount >= 10))
420	420	then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), amount, bondAssetId)])
421	421	else throw("bond were generated or do not need it")
422	422	}
423	423
424	424
425	425
426	426	@Callable(i)
427	427	func setOrder () = {
428	428	let pmt = extract(i.payment)
429	429	let newOrderId = toBase58String(keccak256(((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height))))
430	430	if ((pmt.assetId != bondAssetId))
431	431	then throw("can use bond only")
432	432	else if ((getOrderOwner(newOrderId) != ""))
433	433	then throw("order exists")
434	434	else WriteSet([DataEntry(OrderbookKey, addOrder(newOrderId)), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
435	435	}
436	436
437	437
438	438
439	439	@Callable(i)
440	440	func cancelOrder (orderId) = {
441	441	let owner = getOrderOwner(orderId)
442	442	let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
443	443	if ((owner != toString(i.caller)))
444	444	then throw("permission denied")
445	445	else if ((getOrderStatus(orderId) != NEW))
446	446	then throw("invalid order status")
447	447	else ScriptResult(WriteSet([DataEntry(OrderbookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
448	448	}
449	449
450	450
451	451
452	452	@Callable(i)
453	453	func executeOrder () = {
454	454	let orderId = split(orderbook, LISTSPLITSYMBOL)[0]
455	455	let orderTotal = getOrderTotal(orderId)
456	456	let orderOwner = getOrderOwner(orderId)
457	457	let filledTotal = getOrderFilledTotal(orderId)
458	458	let surplusBond = convertNeutrinoToBond(surplus)
459	459	if (isBlocked)
460	460	then throw("contract is blocked")
461	461	else if ((0 >= surplusBond))
462	462	then throw("surplus is less than zero")
463	463	else if (if ((orderOwner == ""))
464	464	then (surplusBond >= 10)
465	465	else false)
466	466	then {
467	467	let newRpdSyncIndex = (rpdSyncIndex + 1)
468	468	ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), surplus), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), surplus, neutrinoAssetId)]))
469	469	}
470	470	else {
471	471	let amount = (orderTotal - filledTotal)
472	472	let status = if ((surplusBond >= amount))
473	473	then FILLED
474	474	else NEW
475	475	let newFilledTotal = if ((surplusBond >= amount))
476	476	then amount
477	477	else surplusBond
478	478	ScriptResult(WriteSet([DataEntry(OrderbookKey, if ((surplusBond >= amount))
479	479	then dropOrder(orderId)
480	480	else orderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + newFilledTotal)), DataEntry(getOrderStatusKey(orderId), status)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(newFilledTotal), neutrinoAssetId)]))
481	481	}
482	482	}
483	483
484	484
485	485
486	486	@Callable(i)
487	487	func transfer (account) = {
488	488	let pmt = extract(i.payment)
489	489	TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, pmt.assetId)])
490	490	}
491	491
492	492
493	493
494	494	@Callable(i)
495	495	func nodeReward () = {
496	496	let pmt = value(i.payment)
497	497	if ((i.caller != addressFromStringValue(nodeAddress)))
498	498	then throw("permission denied")
499	499	else if (isDefined(pmt.assetId))
500	500	then throw("waves only")

github/deemru/w8io/3ef1775 
78.38 ms ◑