2019.10.26 15:23 [1767308] smart account 3PC9BfRwJWWiw9AREE2B3eWzCks3CYtg4yo > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4NaoQwY1ZoYuk1CYjT3FZ9LAmDswxugHhQsRfuEnBdRv",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1572092664781,
    "version": 1,
    "sender": "3PC9BfRwJWWiw9AREE2B3eWzCks3CYtg4yo",
    "senderPublicKey": "BRnVwSVctnV8pge5vRpsJdWnkjWEJspFb6QvrmZvu3Ht",
    "proofs": [
        "5g9bQASedAMGdPhp2EPayP7pSrR8cwdddCmZg2RV4a2c48d3wRJBZVZqz2CYR24VgbizXkeAoZkE6WN3HgUN1smV"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 1767308,
    "spentComplexity": 0
}

View: original | compacted
Prev: 73j1bwzmZ2vHDzcx1DMbgX1FXJwyBAHFFSR52YuwB7md
Next: GBUC3pfCBVG49gjDB4UeSzJLUps1UCucCGcyGNtfXSud

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

github/deemru/w8io/786bc32 
115.17 ms ◑