tx · BZwHGKGBu5WqR9u7tSXTtZ9Vr58fMWybdDr3s2Njj5uU

3PG2vMhK5CPqsCDodvLGzQ84QkoHXCJ3oNP:  -0.14000000 Waves

2020.06.25 12:54 [2122397] smart account 3PG2vMhK5CPqsCDodvLGzQ84QkoHXCJ3oNP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BZwHGKGBu5WqR9u7tSXTtZ9Vr58fMWybdDr3s2Njj5uU",
    "fee": 14000000,
    "feeAssetId": null,
    "timestamp": 1593078358601,
    "version": 1,
    "sender": "3PG2vMhK5CPqsCDodvLGzQ84QkoHXCJ3oNP",
    "senderPublicKey": "5RM3w4ysmDbtgfswnVNPx7DQkNwVAG3RoxNFHgt6ToNU",
    "proofs": [
        "",
        "5eF6RRLpYx1fJGGpmmroRHXeubDpupf59oENnUZ9hGtrvjRnRP2KJw79ommy2mJehYP5ikATJtVSXrybk7S5wtLy",
        "",
        "SVf4eSVNvSRXYmovjd7J5PQHQ2Rh2BFMt3JJYotJV269P6gBuZ4V3K3eu8ffiL3NmkjMbZZfpoPHDZkFUpEYxTd"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2122397,
    "spentComplexity": 0
}

View: original | compacted
Prev: 3RT7no7NPzufXne5WMe15g2az8pkdTzpZJjTfFy8uAHD
Next: 8T1wo7TX2VSUkXXt2AhZhWFVAQafiw8MQCoSmjN9A5e1

Diff: 
Old
New
Differences
162
162
 
func orderData (orderId,totalWavelets,owner,status,roi,price) = [DataEntry(getOrderPriceKey(orderId), price), DataEntry(getOrderTotalKey(orderId), totalWavelets), DataEntry(getOrderOwnerKey(orderId), owner), DataEntry(getOrderHeightKey(orderId), height), DataEntry(getOrderStatusKey(orderId), status), DataEntry(("debug_order_currentPrice_" + orderId), currentPrice), DataEntry(getRoiByOrderIdKey(orderId), roi)]
163
163
 
164
164
 
165
-
func internalSellBond (pFirstOrder,pNextOrder,pFilledTotal,pRoi,pPrice,pPaymentWavelets,orderOwnerAddress,instantOrder) = {
165
+
func internalSellBond (currentMaxRoi,pFirstOrder,pNextOrder,pFilledTotal,pRoi,pPrice,pPaymentWavelets,orderOwnerAddress,instantOrder) = {
166
166
 
    let priceWavesByBondCents = fraction((100 + pRoi), currentPrice, 100)
167
167
 
    let remainedTotal = (pPaymentWavelets - pFilledTotal)
168
168
 
    let fillableOrderAmount = convertWavesToBond(remainedTotal, priceWavesByBondCents)
169
169
 
    let totalOrderWaveletesRequired = convertBondToWaves(fillableOrderAmount, priceWavesByBondCents)
170
-
    let nbTokensSellCondition = (fraction(deficit, 100, neutrinoSupply) >= pRoi)
170
+
    let nbTokensSellCondition = (currentMaxRoi >= pRoi)
171
171
 
    if (!(nbTokensSellCondition))
172
172
 
        then throw(("innapropriate roi: " + toString(pRoi)))
173
173
 
        else if ((totalOrderWaveletesRequired == 0))
182
182
 
    }
183
183
 
184
184
 
185
-
func internalAddBuyBondOrder (roi,price,prevOrder,inv,instantOrder) = {
185
+
func internalAddBuyBondOrder (currentMaxRoi,roi,price,prevOrder,inv,instantOrder) = {
186
186
 
    let pmt = extract(inv.payment)
187
187
 
    let newOrderId = toBase58String(inv.transactionId)
188
188
 
    if (isBlocked)
232
232
 
                                                else if (if (isNewOrderAtFirstPosition)
233
233
 
                                                    then instantOrder
234
234
 
                                                    else false)
235
-
                                                    then internalSellBond(newOrderId, nextOrder, 0, roi, price, pmt.amount, inv.caller, true)
235
+
                                                    then internalSellBond(currentMaxRoi, newOrderId, nextOrder, 0, roi, price, pmt.amount, inv.caller, true)
236
236
 
                                                    else if (instantOrder)
237
237
 
                                                        then throw("Instant order couldn't be added into waiting queue")
238
238
 
                                                        else WriteSet([DataEntry(getPrevOrderKey(newOrderId), prevOrder), DataEntry(getNextOrderKey(newOrderId), nextOrder), DataEntry(getNextOrderKey(prevOrder), if ((prevOrder == ""))
249
249
 
250
250
 
251
251
 
@Callable(i)
252
-
func instantBuyNsbtOrFail (roi) = {
252
+
func instantBuyNsbtOrFail (noLessThenRoi) = {
253
253
 
    let pmt = extract(i.payment)
254
-
    let priceWavesByBondCents = fraction((100 + roi), currentPrice, 100)
255
-
    let price = ((100 * 100) / priceWavesByBondCents)
256
-
    internalAddBuyBondOrder(roi, price, "", i, true)
254
+
    let currentMaxRoi = fraction(deficit, 100, neutrinoSupply)
255
+
    if ((noLessThenRoi > currentMaxRoi))
256
+
        then throw(((("Current maxRoi=" + toString(currentMaxRoi)) + " is less then passed parameter noLessThenRoi=") + toString(noLessThenRoi)))
257
+
        else {
258
+
            let priceWavesByBondCents = fraction((100 + currentMaxRoi), currentPrice, 100)
259
+
            internalAddBuyBondOrder(currentMaxRoi, currentMaxRoi, ((100 * 100) / priceWavesByBondCents), "", i, true)
260
+
            }
257
261
 
    }
258
262
 
259
263
 
262
266
 
func addBuyBondOrder (price,prevOrder) = {
263
267
 
    let pmt = extract(i.payment)
264
268
 
    let priceWavesByBondCents = fraction(100, 100, price)
265
-
    let roi = fraction((priceWavesByBondCents - currentPrice), 100, currentPrice)
266
269
 
    if ((0 >= price))
267
270
 
        then throw("price less zero")
268
-
        else internalAddBuyBondOrder(roi, price, prevOrder, i, false)
271
+
        else internalAddBuyBondOrder(fraction(deficit, 100, neutrinoSupply), fraction((priceWavesByBondCents - currentPrice), 100, currentPrice), price, prevOrder, i, false)
269
272
 
    }
270
273
 
271
274
 
302
305
 
            let roi = getNumberByKey(getRoiByOrderIdKey(firstOrder))
303
306
 
            let paymentWavelets = getOrderTotal(firstOrder)
304
307
 
            let orderOwnerAddress = Address(fromBase58String(getOrderOwner(firstOrder)))
305
-
            internalSellBond(firstOrder, nextOrder, filledTotal, roi, orderPrice, paymentWavelets, orderOwnerAddress, false)
308
+
            internalSellBond(fraction(deficit, 100, neutrinoSupply), firstOrder, nextOrder, filledTotal, roi, orderPrice, paymentWavelets, orderOwnerAddress, false)
306
309
 
            }
307
310
 
308
311
 

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 getBoolByAddressAndKey (address,key) = match getBoolean(address, key) {
21
21
 
    case a: Boolean => 
22
22
 
        a
23
23
 
    case _ => 
24
24
 
        false
25
25
 
}
26
26
 
27
27
 
28
28
 
func getStringByAddressAndKey (address,key) = match getString(address, key) {
29
29
 
    case a: String => 
30
30
 
        a
31
31
 
    case _ => 
32
32
 
        ""
33
33
 
}
34
34
 
35
35
 
36
36
 
func getNumberByAddressAndKey (address,key) = match getInteger(address, key) {
37
37
 
    case a: Int => 
38
38
 
        a
39
39
 
    case _ => 
40
40
 
        0
41
41
 
}
42
42
 
43
43
 
44
44
 
let WAVELET = 100000000
45
45
 
46
46
 
let PAULI = 1000000
47
47
 
48
48
 
let MINORDERTOTAL = (10 * WAVELET)
49
49
 
50
50
 
let MAXROI = 95
51
51
 
52
52
 
let CANCELED = "canceled"
53
53
 
54
54
 
let NEW = "new"
55
55
 
56
56
 
let FILLED = "filled"
57
57
 
58
58
 
let NeutrinoContractKey = "neutrino_contract"
59
59
 
60
60
 
let PriceKey = "price"
61
61
 
62
62
 
let BondAssetIdKey = "bond_asset_id"
63
63
 
64
64
 
let NeutrinoAssetIdKey = "neutrino_asset_id"
65
65
 
66
66
 
let ControlContractKey = "control_contract"
67
67
 
68
68
 
let BalanceLockedkKey = "balance_lock_"
69
69
 
70
70
 
let WavesLockedBalanceKey = (BalanceLockedkKey + "waves")
71
71
 
72
72
 
let NeutrinoLockedBalanceKey = (BalanceLockedkKey + "neutrino")
73
73
 
74
74
 
let LiquidationContractKey = "liquidation_contract"
75
75
 
76
76
 
let FirstOrderKey = "order_first"
77
77
 
78
78
 
func getRoiByOrderIdKey (orderId) = ("debug_order_roi_" + orderId)
79
79
 
80
80
 
81
81
 
func getOrderPriceKey (orderId) = ("order_price_" + orderId)
82
82
 
83
83
 
84
84
 
func getOrderTotalKey (orderId) = ("order_total_" + orderId)
85
85
 
86
86
 
87
87
 
func getOrderOwnerKey (orderId) = ("order_owner_" + orderId)
88
88
 
89
89
 
90
90
 
func getOrderHeightKey (orderId) = ("order_height_" + orderId)
91
91
 
92
92
 
93
93
 
func getOrderStatusKey (orderId) = ("order_status_" + orderId)
94
94
 
95
95
 
96
96
 
func getOrderFilledTotalKey (orderId) = ("order_filled_total_" + orderId)
97
97
 
98
98
 
99
99
 
func getPrevOrderKey (orderId) = ("order_prev_" + orderId)
100
100
 
101
101
 
102
102
 
func getNextOrderKey (orderId) = ("order_next_" + orderId)
103
103
 
104
104
 
105
105
 
func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, 100, price), WAVELET, PAULI)
106
106
 
107
107
 
108
108
 
func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, 100), PAULI, WAVELET)
109
109
 
110
110
 
111
111
 
func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
112
112
 
113
113
 
114
114
 
func convertBondToWaves (amount,price) = convertNeutrinoToWaves(amount, price)
115
115
 
116
116
 
117
117
 
let neutrinoContract = Address(base58'3PC9BfRwJWWiw9AREE2B3eWzCks3CYtg4yo')
118
118
 
119
119
 
let controlContract = Address(base58'3P5Bfd58PPfNvBM2Hy8QfbcDqMeNtzg7KfP')
120
120
 
121
121
 
let liquidationContract = Address(base58'3P4PCxsJqMzQBALo8zANHtBDZRRquobHQp7')
122
122
 
123
123
 
let neutrinoAssetId = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
124
124
 
125
125
 
let bondAssetId = base58'6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g'
126
126
 
127
127
 
let isBlocked = getBoolByAddressAndKey(controlContract, "is_blocked")
128
128
 
129
129
 
let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
130
130
 
131
131
 
let neutrinoLockedBalance = getNumberByAddressAndKey(neutrinoContract, NeutrinoLockedBalanceKey)
132
132
 
133
133
 
let reserve = (wavesBalance(neutrinoContract) - getNumberByAddressAndKey(neutrinoContract, WavesLockedBalanceKey))
134
134
 
135
135
 
let neutrinoSupply = (((neutrinoLockedBalance + extract(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(liquidationContract, neutrinoAssetId))
136
136
 
137
137
 
let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
138
138
 
139
139
 
let firstOrder = getStringByKey(FirstOrderKey)
140
140
 
141
141
 
func getOrderPrice (id) = getNumberByKey(getOrderPriceKey(id))
142
142
 
143
143
 
144
144
 
func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
145
145
 
146
146
 
147
147
 
func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
148
148
 
149
149
 
150
150
 
func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
151
151
 
152
152
 
153
153
 
func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
154
154
 
155
155
 
156
156
 
func getPrevOrder (id) = getStringByKey(getPrevOrderKey(id))
157
157
 
158
158
 
159
159
 
func getNextOrder (id) = getStringByKey(getNextOrderKey(id))
160
160
 
161
161
 
162
162
 
func orderData (orderId,totalWavelets,owner,status,roi,price) = [DataEntry(getOrderPriceKey(orderId), price), DataEntry(getOrderTotalKey(orderId), totalWavelets), DataEntry(getOrderOwnerKey(orderId), owner), DataEntry(getOrderHeightKey(orderId), height), DataEntry(getOrderStatusKey(orderId), status), DataEntry(("debug_order_currentPrice_" + orderId), currentPrice), DataEntry(getRoiByOrderIdKey(orderId), roi)]
163
163
 
164
164
 
165
-
func internalSellBond (pFirstOrder,pNextOrder,pFilledTotal,pRoi,pPrice,pPaymentWavelets,orderOwnerAddress,instantOrder) = {
165
+
func internalSellBond (currentMaxRoi,pFirstOrder,pNextOrder,pFilledTotal,pRoi,pPrice,pPaymentWavelets,orderOwnerAddress,instantOrder) = {
166
166
 
    let priceWavesByBondCents = fraction((100 + pRoi), currentPrice, 100)
167
167
 
    let remainedTotal = (pPaymentWavelets - pFilledTotal)
168
168
 
    let fillableOrderAmount = convertWavesToBond(remainedTotal, priceWavesByBondCents)
169
169
 
    let totalOrderWaveletesRequired = convertBondToWaves(fillableOrderAmount, priceWavesByBondCents)
170
-
    let nbTokensSellCondition = (fraction(deficit, 100, neutrinoSupply) >= pRoi)
170
+
    let nbTokensSellCondition = (currentMaxRoi >= pRoi)
171
171
 
    if (!(nbTokensSellCondition))
172
172
 
        then throw(("innapropriate roi: " + toString(pRoi)))
173
173
 
        else if ((totalOrderWaveletesRequired == 0))
174
174
 
            then throw("cannot fill order at the moment")
175
175
 
            else {
176
176
 
                let changeWavelets = (remainedTotal - totalOrderWaveletesRequired)
177
177
 
                let writeSetData = if (instantOrder)
178
178
 
                    then [DataEntry(getOrderPriceKey(pFirstOrder), pPrice), DataEntry(getOrderTotalKey(pFirstOrder), pPaymentWavelets), DataEntry(getOrderOwnerKey(pFirstOrder), toBase58String(orderOwnerAddress.bytes)), DataEntry(getOrderHeightKey(pFirstOrder), height), DataEntry(getOrderStatusKey(pFirstOrder), FILLED), DataEntry(("debug_order_currentPrice_" + pFirstOrder), currentPrice), DataEntry(getRoiByOrderIdKey(pFirstOrder), pRoi)]
179
179
 
                    else [DataEntry(getOrderFilledTotalKey(pFirstOrder), (pFilledTotal + totalOrderWaveletesRequired)), DataEntry(getOrderStatusKey(pFirstOrder), FILLED), DataEntry(getOrderTotalKey(pFirstOrder), pPaymentWavelets), DataEntry(getPrevOrderKey(pNextOrder), ""), DataEntry(FirstOrderKey, pNextOrder)]
180
180
 
                ScriptResult(WriteSet(writeSetData), TransferSet([ScriptTransfer(orderOwnerAddress, fillableOrderAmount, bondAssetId), ScriptTransfer(neutrinoContract, totalOrderWaveletesRequired, unit), ScriptTransfer(orderOwnerAddress, changeWavelets, unit)]))
181
181
 
                }
182
182
 
    }
183
183
 
184
184
 
185
-
func internalAddBuyBondOrder (roi,price,prevOrder,inv,instantOrder) = {
185
+
func internalAddBuyBondOrder (currentMaxRoi,roi,price,prevOrder,inv,instantOrder) = {
186
186
 
    let pmt = extract(inv.payment)
187
187
 
    let newOrderId = toBase58String(inv.transactionId)
188
188
 
    if (isBlocked)
189
189
 
        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
190
190
 
        else if ((MINORDERTOTAL > pmt.amount))
191
191
 
            then throw(("min order total equals " + toString(MINORDERTOTAL)))
192
192
 
            else if ((roi > MAXROI))
193
193
 
                then throw("max setOrder ROI is 95%")
194
194
 
                else if (if ((deficit > 0))
195
195
 
                    then (0 > roi)
196
196
 
                    else false)
197
197
 
                    then throw("can't place order with negative roi during deficit")
198
198
 
                    else if ((-(MAXROI) > roi))
199
199
 
                        then throw("min setOrder ROI is -95%")
200
200
 
                        else if ((roi == 0))
201
201
 
                            then throw("roi should not be equal to 0")
202
202
 
                            else if (isDefined(pmt.assetId))
203
203
 
                                then throw("can use waves only")
204
204
 
                                else if ((getOrderOwner(newOrderId) != ""))
205
205
 
                                    then throw("order exists")
206
206
 
                                    else if (if ((prevOrder != ""))
207
207
 
                                        then (getOrderStatus(prevOrder) != NEW)
208
208
 
                                        else false)
209
209
 
                                        then throw("prev order status is not new")
210
210
 
                                        else {
211
211
 
                                            let isNewOrderAtFirstPosition = (prevOrder == "")
212
212
 
                                            let owner = toString(inv.caller)
213
213
 
                                            let nextOrder = if (isNewOrderAtFirstPosition)
214
214
 
                                                then firstOrder
215
215
 
                                                else getNextOrder(prevOrder)
216
216
 
                                            let nextOrderRoi = getNumberByKey(getRoiByOrderIdKey(nextOrder))
217
217
 
                                            let isNextOrderError = if (if ((nextOrder != ""))
218
218
 
                                                then (roi >= nextOrderRoi)
219
219
 
                                                else false)
220
220
 
                                                then true
221
221
 
                                                else false
222
222
 
                                            let prevOrderRoi = getNumberByKey(getRoiByOrderIdKey(prevOrder))
223
223
 
                                            let isPrevOrderError = if (if ((prevOrder != ""))
224
224
 
                                                then (prevOrderRoi > roi)
225
225
 
                                                else false)
226
226
 
                                                then true
227
227
 
                                                else false
228
228
 
                                            if (if (isNextOrderError)
229
229
 
                                                then true
230
230
 
                                                else isPrevOrderError)
231
231
 
                                                then throw(((("invalid order isPrevOrderError:" + toString(isPrevOrderError)) + " isNextOrderError:") + toString(isNextOrderError)))
232
232
 
                                                else if (if (isNewOrderAtFirstPosition)
233
233
 
                                                    then instantOrder
234
234
 
                                                    else false)
235
-
                                                    then internalSellBond(newOrderId, nextOrder, 0, roi, price, pmt.amount, inv.caller, true)
235
+
                                                    then internalSellBond(currentMaxRoi, newOrderId, nextOrder, 0, roi, price, pmt.amount, inv.caller, true)
236
236
 
                                                    else if (instantOrder)
237
237
 
                                                        then throw("Instant order couldn't be added into waiting queue")
238
238
 
                                                        else WriteSet([DataEntry(getPrevOrderKey(newOrderId), prevOrder), DataEntry(getNextOrderKey(newOrderId), nextOrder), DataEntry(getNextOrderKey(prevOrder), if ((prevOrder == ""))
239
239
 
                                                            then ""
240
240
 
                                                            else newOrderId), DataEntry(getPrevOrderKey(nextOrder), if ((nextOrder == ""))
241
241
 
                                                            then ""
242
242
 
                                                            else newOrderId), DataEntry(FirstOrderKey, if (if ((firstOrder == ""))
243
243
 
                                                            then true
244
244
 
                                                            else (firstOrder == nextOrder))
245
245
 
                                                            then newOrderId
246
246
 
                                                            else firstOrder), orderData(newOrderId, pmt.amount, owner, NEW, roi, price)])
247
247
 
                                            }
248
248
 
    }
249
249
 
250
250
 
251
251
 
@Callable(i)
252
-
func instantBuyNsbtOrFail (roi) = {
252
+
func instantBuyNsbtOrFail (noLessThenRoi) = {
253
253
 
    let pmt = extract(i.payment)
254
-
    let priceWavesByBondCents = fraction((100 + roi), currentPrice, 100)
255
-
    let price = ((100 * 100) / priceWavesByBondCents)
256
-
    internalAddBuyBondOrder(roi, price, "", i, true)
254
+
    let currentMaxRoi = fraction(deficit, 100, neutrinoSupply)
255
+
    if ((noLessThenRoi > currentMaxRoi))
256
+
        then throw(((("Current maxRoi=" + toString(currentMaxRoi)) + " is less then passed parameter noLessThenRoi=") + toString(noLessThenRoi)))
257
+
        else {
258
+
            let priceWavesByBondCents = fraction((100 + currentMaxRoi), currentPrice, 100)
259
+
            internalAddBuyBondOrder(currentMaxRoi, currentMaxRoi, ((100 * 100) / priceWavesByBondCents), "", i, true)
260
+
            }
257
261
 
    }
258
262
 
259
263
 
260
264
 
261
265
 
@Callable(i)
262
266
 
func addBuyBondOrder (price,prevOrder) = {
263
267
 
    let pmt = extract(i.payment)
264
268
 
    let priceWavesByBondCents = fraction(100, 100, price)
265
-
    let roi = fraction((priceWavesByBondCents - currentPrice), 100, currentPrice)
266
269
 
    if ((0 >= price))
267
270
 
        then throw("price less zero")
268
-
        else internalAddBuyBondOrder(roi, price, prevOrder, i, false)
271
+
        else internalAddBuyBondOrder(fraction(deficit, 100, neutrinoSupply), fraction((priceWavesByBondCents - currentPrice), 100, currentPrice), price, prevOrder, i, false)
269
272
 
    }
270
273
 
271
274
 
272
275
 
273
276
 
@Callable(i)
274
277
 
func cancelOrder (orderId) = {
275
278
 
    let owner = getOrderOwner(orderId)
276
279
 
    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
277
280
 
    let caller = toString(i.caller)
278
281
 
    let nextOrder = getNextOrder(orderId)
279
282
 
    let prevOrder = getPrevOrder(orderId)
280
283
 
    if (isBlocked)
281
284
 
        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
282
285
 
        else if ((owner != caller))
283
286
 
            then throw("permission denied")
284
287
 
            else if ((getOrderStatus(orderId) != NEW))
285
288
 
                then throw("invalid order status")
286
289
 
                else ScriptResult(WriteSet([DataEntry(FirstOrderKey, if ((firstOrder == orderId))
287
290
 
                    then nextOrder
288
291
 
                    else firstOrder), DataEntry(getNextOrderKey(prevOrder), nextOrder), DataEntry(getPrevOrderKey(nextOrder), prevOrder), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, unit)]))
289
292
 
    }
290
293
 
291
294
 
292
295
 
293
296
 
@Callable(i)
294
297
 
func sellBond () = if (isBlocked)
295
298
 
    then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
296
299
 
    else if ((firstOrder == ""))
297
300
 
        then throw("empty orderbook")
298
301
 
        else {
299
302
 
            let nextOrder = getNextOrder(firstOrder)
300
303
 
            let filledTotal = getOrderFilledTotal(firstOrder)
301
304
 
            let orderPrice = getOrderPrice(firstOrder)
302
305
 
            let roi = getNumberByKey(getRoiByOrderIdKey(firstOrder))
303
306
 
            let paymentWavelets = getOrderTotal(firstOrder)
304
307
 
            let orderOwnerAddress = Address(fromBase58String(getOrderOwner(firstOrder)))
305
-
            internalSellBond(firstOrder, nextOrder, filledTotal, roi, orderPrice, paymentWavelets, orderOwnerAddress, false)
308
+
            internalSellBond(fraction(deficit, 100, neutrinoSupply), firstOrder, nextOrder, filledTotal, roi, orderPrice, paymentWavelets, orderOwnerAddress, false)
306
309
 
            }
307
310
 
308
311
 
309
312
 
@Verifier(tx)
310
313
 
func verify () = {
311
314
 
    let pubKeyAdminsList = ["BLEoguzPVKVTfXxxT3W7Rqf8aUm2ggC9Vemd2MQawM2G", "FWVffYr2ALmHMejZm3WqeLz6Sdym3gLFGtJn4KTwyU5x", "3Wh2LaWcb5gg7K2pPcW3Ep6EAuRBzYkAgrdpt43jTDFa", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
312
315
 
    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
313
316
 
        then 1
314
317
 
        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
315
318
 
        then 1
316
319
 
        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
317
320
 
        then 1
318
321
 
        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
319
322
 
        then 2
320
323
 
        else 0))
321
324
 
    (count >= 3)
322
325
 
    }
323
326
 

github/deemru/w8io/6500d08 
64.85 ms ◑