w8 · tx · 3qt···R3f

tx · 3qttxQ9DrUknrKzdzg3W81iwiXx6JuEAgdtGZLffPR3f

3PG2vMhK5CPqsCDodvLGzQ84QkoHXCJ3oNP:  -0.01400000 Waves

2019.10.21 13:44 [1759938] smart account 3PG2vMhK5CPqsCDodvLGzQ84QkoHXCJ3oNP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3qttxQ9DrUknrKzdzg3W81iwiXx6JuEAgdtGZLffPR3f",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1571654827579,
    "version": 1,
    "sender": "3PG2vMhK5CPqsCDodvLGzQ84QkoHXCJ3oNP",
    "senderPublicKey": "5RM3w4ysmDbtgfswnVNPx7DQkNwVAG3RoxNFHgt6ToNU",
    "proofs": [
        "2ninBpzYoJjv1mm1oP8nndmmBov2yFjS14ECEueNX3wPQjPSDkqgKkEp2QtNLdsNktpGXPESkHbfkkqa97bjQB1k"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 1759938,
    "spentComplexity": 0
}

View: original | compacted
Prev: 6i8uxvG1WufTb1D8ASMpuBiFy7igSBe7kAjtedg4kJq8
Next: CvS8iKeXjeNWH3C1BLWX2UNd8eniaUVpkpE3Qb3dRgL

Diff: 
Old New Differences
44 44  let NEW = "new"
45 45  
46 46  let FILLED = "filled"
47 + 
48 + let PERCENTACCURACY = 1000
47 49  
48 50  let OrderBookKey = "orderbook"
49 51  
243 245                  let orderTotal = getOrderTotal(orderId)
244 246                  let orderPrice = getOrderPrice(orderId)
245 247                  let orderOwner = getOrderOwner(orderId)
246 -                 let amount = ((((orderTotal - filledTotal) * 100) / orderPrice) / PAULI)
248 +                 let amount = convertNeutrinoToBond((((orderTotal - filledTotal) * 100) / orderPrice))
247 249                  let newOrderbook = if ((bondAmount >= amount))
248 250                      then dropOrder(orderId)
249 251                      else orderbook
250 252                  let filledAmount = if ((bondAmount >= amount))
251 253                      then amount
252 254                      else bondAmount
253 -                 let total = (((filledAmount * orderPrice) / 100) * PAULI)
255 +                 let total = (((filledAmount * orderPrice) * PAULI) / 100)
254 256                  let status = if ((bondAmount >= amount))
255 257                      then FILLED
256 258                      else NEW
257 -                 ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
259 +                 if ((total == 0))
260 +                     then throw("total equal zero")
261 +                     else ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
258 262                  }
259 263      }
260 264  
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 getStringByAddressAndKey (address,key) = match getString(address, key) {
21 21      case a: String => 
22 22          a
23 23      case _ => 
24 24          ""
25 25  }
26 26  
27 27  
28 28  func getNumberByAddressAndKey (address,key) = match getInteger(address, key) {
29 29      case a: Int => 
30 30          a
31 31      case _ => 
32 32          0
33 33  }
34 34  
35 35  
36 36  let WAVELET = 100000000
37 37  
38 38  let ORDERSPLITSYMBOL = "_"
39 39  
40 40  let PAULI = 100
41 41  
42 42  let CANCELED = "canceled"
43 43  
44 44  let NEW = "new"
45 45  
46 46  let FILLED = "filled"
47 + 
48 + let PERCENTACCURACY = 1000
47 49  
48 50  let OrderBookKey = "orderbook"
49 51  
50 52  let OrderPriceKey = "order_price_"
51 53  
52 54  let OrderTotalKey = "order_total_"
53 55  
54 56  let OrderFilledTotalKey = "order_filled_total_"
55 57  
56 58  let OrderOwnerKey = "order_owner_"
57 59  
58 60  let OrderHeightKey = "order_height_"
59 61  
60 62  let OrderStatusKey = "order_status_"
61 63  
62 64  let PriceKey = "price"
63 65  
64 66  let BondAssetIdKey = "bond_asset_id"
65 67  
66 68  let NeutrinoAssetIdKey = "neutrino_asset_id"
67 69  
68 70  let NeutrinoContractKey = "neutrino_contract"
69 71  
70 72  let ControlContractKey = "control_contract"
71 73  
72 74  let OrderHistoryKey = "order_history_"
73 75  
74 76  let SwapLockedBalanceKey = "swap_locked_balance"
75 77  
76 78  func getOrderPriceKey (orderId) = (OrderPriceKey + orderId)
77 79  
78 80  
79 81  func getOrderTotalKey (orderId) = (OrderTotalKey + orderId)
80 82  
81 83  
82 84  func getOrderOwnerKey (orderId) = (OrderOwnerKey + orderId)
83 85  
84 86  
85 87  func getOrderHeightKey (orderId) = (OrderHeightKey + orderId)
86 88  
87 89  
88 90  func getOrderStatusKey (orderId) = (OrderStatusKey + orderId)
89 91  
90 92  
91 93  func getOrderFilledTotalKey (orderId) = (OrderFilledTotalKey + orderId)
92 94  
93 95  
94 96  func getOrderHistoryKey (height) = (OrderHistoryKey + toString(height))
95 97  
96 98  
97 99  let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
98 100  
99 101  let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
100 102  
101 103  let priceNeutrino = getNumberByAddressAndKey(controlContract, PriceKey)
102 104  
103 105  func convertNeutrinoToWaves (amount) = ((((amount * 100) / priceNeutrino) * WAVELET) / PAULI)
104 106  
105 107  
106 108  func convertWavesToNeutrino (amount) = ((((amount * priceNeutrino) / 100) * PAULI) / WAVELET)
107 109  
108 110  
109 111  func convertNeutrinoToBond (amount) = (amount / PAULI)
110 112  
111 113  
112 114  func convertBondToNeutrino (amount) = (amount * PAULI)
113 115  
114 116  
115 117  func convertWavesToBond (amount) = convertNeutrinoToBond(convertWavesToNeutrino(amount))
116 118  
117 119  
118 120  let swapLockedBalance = getNumberByAddressAndKey(neutrinoContract, SwapLockedBalanceKey)
119 121  
120 122  let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
121 123  
122 124  let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
123 125  
124 126  let orderbook = getStringByKey(OrderBookKey)
125 127  
126 128  let reserve = (wavesBalance(this) - swapLockedBalance)
127 129  
128 130  let neutrinoSupply = {
129 131      let info = extract(assetInfo(neutrinoAssetId))
130 132      (info.quantity - assetBalance(neutrinoContract, neutrinoAssetId))
131 133      }
132 134  
133 135  let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve))
134 136  
135 137  func getOrderPrice (id) = getNumberByKey(getOrderPriceKey(id))
136 138  
137 139  
138 140  func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
139 141  
140 142  
141 143  func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
142 144  
143 145  
144 146  func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
145 147  
146 148  
147 149  func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
148 150  
149 151  
150 152  func getOrderElementById (id) = (id + ORDERSPLITSYMBOL)
151 153  
152 154  
153 155  func addOrder (orderId,position) = {
154 156      let orders = split(orderbook, ORDERSPLITSYMBOL)
155 157      let newOrder = getOrderElementById(orderId)
156 158      if ((position == 0))
157 159          then (newOrder + orderbook)
158 160          else if ((position >= (size(orders) - 1)))
159 161              then (orderbook + newOrder)
160 162              else {
161 163                  let parts = split(orderbook, getOrderElementById(orders[position]))
162 164                  (((parts[0] + newOrder) + getOrderElementById(orders[position])) + parts[1])
163 165                  }
164 166      }
165 167  
166 168  
167 169  func dropOrder (orderId) = {
168 170      let parts = split(orderbook, getOrderElementById(orderId))
169 171      (parts[0] + parts[1])
170 172      }
171 173  
172 174  
173 175  @Callable(i)
174 176  func setOrder (price,position) = {
175 177      let pmt = extract(i.payment)
176 178      let newOrderId = toBase58String(keccak256((((toBytes(price) + toBytes(pmt.amount)) + i.caller.bytes) + toBytes(height))))
177 179      if ((pmt.assetId != neutrinoAssetId))
178 180          then throw("can use neutrino only")
179 181          else if ((0 >= price))
180 182              then throw("price less zero")
181 183              else if ((getOrderOwner(newOrderId) != ""))
182 184                  then throw("order exists")
183 185                  else {
184 186                      let orders = split(orderbook, ORDERSPLITSYMBOL)
185 187                      let nextOrderId = if ((position == 0))
186 188                          then ""
187 189                          else orders[(position - 1)]
188 190                      let nextOrderPrice = getOrderPrice(nextOrderId)
189 191                      let isNextOrderError = if (if ((nextOrderId != ""))
190 192                          then (price > nextOrderPrice)
191 193                          else false)
192 194                          then true
193 195                          else false
194 196                      let prevOrderId = orders[position]
195 197                      let prevOrderPrice = getOrderPrice(prevOrderId)
196 198                      let isPrevOrderError = if ((prevOrderPrice >= price))
197 199                          then true
198 200                          else false
199 201                      if (if (isNextOrderError)
200 202                          then true
201 203                          else isPrevOrderError)
202 204                          then throw(((("invalid order isPrevOrderError:" + toString(isPrevOrderError)) + " isNextOrderError:") + toString(isNextOrderError)))
203 205                          else WriteSet([DataEntry(OrderBookKey, addOrder(newOrderId, position)), DataEntry(getOrderPriceKey(newOrderId), price), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
204 206                      }
205 207      }
206 208  
207 209  
208 210  
209 211  @Callable(i)
210 212  func cancelOrder (orderId) = {
211 213      let owner = getOrderOwner(orderId)
212 214      let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
213 215      if ((owner != toString(i.caller)))
214 216          then throw("permission denied")
215 217          else if ((getOrderStatus(orderId) != NEW))
216 218              then throw("invalid order status")
217 219              else ScriptResult(WriteSet([DataEntry(OrderBookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, neutrinoAssetId)]))
218 220      }
219 221  
220 222  
221 223  
222 224  @Callable(i)
223 225  func executeOrder () = {
224 226      let bondBalance = assetBalance(this, bondAssetId)
225 227      let deficitPositive = if ((0 >= deficit))
226 228          then 0
227 229          else deficit
228 230      let bondAmount = if ((deficitPositive >= bondBalance))
229 231          then bondBalance
230 232          else deficitPositive
231 233      let returnAmount = if ((deficitPositive >= bondBalance))
232 234          then 0
233 235          else (bondBalance - deficitPositive)
234 236      if (if ((returnAmount == 0))
235 237          then (bondAmount == 0)
236 238          else false)
237 239          then throw("without deficit")
238 240          else if ((bondAmount == 0))
239 241              then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, bondAssetId)])
240 242              else {
241 243                  let orderId = split(orderbook, ORDERSPLITSYMBOL)[0]
242 244                  let filledTotal = getOrderFilledTotal(orderId)
243 245                  let orderTotal = getOrderTotal(orderId)
244 246                  let orderPrice = getOrderPrice(orderId)
245 247                  let orderOwner = getOrderOwner(orderId)
246 -                 let amount = ((((orderTotal - filledTotal) * 100) / orderPrice) / PAULI)
248 +                 let amount = convertNeutrinoToBond((((orderTotal - filledTotal) * 100) / orderPrice))
247 249                  let newOrderbook = if ((bondAmount >= amount))
248 250                      then dropOrder(orderId)
249 251                      else orderbook
250 252                  let filledAmount = if ((bondAmount >= amount))
251 253                      then amount
252 254                      else bondAmount
253 -                 let total = (((filledAmount * orderPrice) / 100) * PAULI)
255 +                 let total = (((filledAmount * orderPrice) * PAULI) / 100)
254 256                  let status = if ((bondAmount >= amount))
255 257                      then FILLED
256 258                      else NEW
257 -                 ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
259 +                 if ((total == 0))
260 +                     then throw("total equal zero")
261 +                     else ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
258 262                  }
259 263      }
260 264  
261 265

Old	New		Differences
44	44		let NEW = "new"
45	45
46	46		let FILLED = "filled"
	47	+
	48	+	let PERCENTACCURACY = 1000
47	49
48	50		let OrderBookKey = "orderbook"
49	51

243	245		let orderTotal = getOrderTotal(orderId)
244	246		let orderPrice = getOrderPrice(orderId)
245	247		let orderOwner = getOrderOwner(orderId)
246		-	let amount = ((((orderTotal - filledTotal) * 100) / orderPrice) ~~/ PAULI~~)
	248	+	let amount = convertNeutrinoToBond((((orderTotal - filledTotal) * 100) / orderPrice))
247	249		let newOrderbook = if ((bondAmount >= amount))
248	250		then dropOrder(orderId)
249	251		else orderbook
250	252		let filledAmount = if ((bondAmount >= amount))
251	253		then amount
252	254		else bondAmount
253		-	let total = (((filledAmount * orderPrice) / 100) * PAULI)
	255	+	let total = (((filledAmount * orderPrice) * PAULI) / 100)
254	256		let status = if ((bondAmount >= amount))
255	257		then FILLED
256	258		else NEW
257		-	ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
	259	+	if ((total == 0))
	260	+	then throw("total equal zero")
	261	+	else ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
258	262		}
259	263		}
260	264

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 getStringByAddressAndKey (address,key) = match getString(address, key) {
21	21		case a: String =>
22	22		a
23	23		case _ =>
24	24		""
25	25		}
26	26
27	27
28	28		func getNumberByAddressAndKey (address,key) = match getInteger(address, key) {
29	29		case a: Int =>
30	30		a
31	31		case _ =>
32	32		0
33	33		}
34	34
35	35
36	36		let WAVELET = 100000000
37	37
38	38		let ORDERSPLITSYMBOL = "_"
39	39
40	40		let PAULI = 100
41	41
42	42		let CANCELED = "canceled"
43	43
44	44		let NEW = "new"
45	45
46	46		let FILLED = "filled"
	47	+
	48	+	let PERCENTACCURACY = 1000
47	49
48	50		let OrderBookKey = "orderbook"
49	51
50	52		let OrderPriceKey = "order_price_"
51	53
52	54		let OrderTotalKey = "order_total_"
53	55
54	56		let OrderFilledTotalKey = "order_filled_total_"
55	57
56	58		let OrderOwnerKey = "order_owner_"
57	59
58	60		let OrderHeightKey = "order_height_"
59	61
60	62		let OrderStatusKey = "order_status_"
61	63
62	64		let PriceKey = "price"
63	65
64	66		let BondAssetIdKey = "bond_asset_id"
65	67
66	68		let NeutrinoAssetIdKey = "neutrino_asset_id"
67	69
68	70		let NeutrinoContractKey = "neutrino_contract"
69	71
70	72		let ControlContractKey = "control_contract"
71	73
72	74		let OrderHistoryKey = "order_history_"
73	75
74	76		let SwapLockedBalanceKey = "swap_locked_balance"
75	77
76	78		func getOrderPriceKey (orderId) = (OrderPriceKey + orderId)
77	79
78	80
79	81		func getOrderTotalKey (orderId) = (OrderTotalKey + orderId)
80	82
81	83
82	84		func getOrderOwnerKey (orderId) = (OrderOwnerKey + orderId)
83	85
84	86
85	87		func getOrderHeightKey (orderId) = (OrderHeightKey + orderId)
86	88
87	89
88	90		func getOrderStatusKey (orderId) = (OrderStatusKey + orderId)
89	91
90	92
91	93		func getOrderFilledTotalKey (orderId) = (OrderFilledTotalKey + orderId)
92	94
93	95
94	96		func getOrderHistoryKey (height) = (OrderHistoryKey + toString(height))
95	97
96	98
97	99		let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
98	100
99	101		let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
100	102
101	103		let priceNeutrino = getNumberByAddressAndKey(controlContract, PriceKey)
102	104
103	105		func convertNeutrinoToWaves (amount) = ((((amount * 100) / priceNeutrino) * WAVELET) / PAULI)
104	106
105	107
106	108		func convertWavesToNeutrino (amount) = ((((amount * priceNeutrino) / 100) * PAULI) / WAVELET)
107	109
108	110
109	111		func convertNeutrinoToBond (amount) = (amount / PAULI)
110	112
111	113
112	114		func convertBondToNeutrino (amount) = (amount * PAULI)
113	115
114	116
115	117		func convertWavesToBond (amount) = convertNeutrinoToBond(convertWavesToNeutrino(amount))
116	118
117	119
118	120		let swapLockedBalance = getNumberByAddressAndKey(neutrinoContract, SwapLockedBalanceKey)
119	121
120	122		let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
121	123
122	124		let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
123	125
124	126		let orderbook = getStringByKey(OrderBookKey)
125	127
126	128		let reserve = (wavesBalance(this) - swapLockedBalance)
127	129
128	130		let neutrinoSupply = {
129	131		let info = extract(assetInfo(neutrinoAssetId))
130	132		(info.quantity - assetBalance(neutrinoContract, neutrinoAssetId))
131	133		}
132	134
133	135		let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve))
134	136
135	137		func getOrderPrice (id) = getNumberByKey(getOrderPriceKey(id))
136	138
137	139
138	140		func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
139	141
140	142
141	143		func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
142	144
143	145
144	146		func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
145	147
146	148
147	149		func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
148	150
149	151
150	152		func getOrderElementById (id) = (id + ORDERSPLITSYMBOL)
151	153
152	154
153	155		func addOrder (orderId,position) = {
154	156		let orders = split(orderbook, ORDERSPLITSYMBOL)
155	157		let newOrder = getOrderElementById(orderId)
156	158		if ((position == 0))
157	159		then (newOrder + orderbook)
158	160		else if ((position >= (size(orders) - 1)))
159	161		then (orderbook + newOrder)
160	162		else {
161	163		let parts = split(orderbook, getOrderElementById(orders[position]))
162	164		(((parts[0] + newOrder) + getOrderElementById(orders[position])) + parts[1])
163	165		}
164	166		}
165	167
166	168
167	169		func dropOrder (orderId) = {
168	170		let parts = split(orderbook, getOrderElementById(orderId))
169	171		(parts[0] + parts[1])
170	172		}
171	173
172	174
173	175		@Callable(i)
174	176		func setOrder (price,position) = {
175	177		let pmt = extract(i.payment)
176	178		let newOrderId = toBase58String(keccak256((((toBytes(price) + toBytes(pmt.amount)) + i.caller.bytes) + toBytes(height))))
177	179		if ((pmt.assetId != neutrinoAssetId))
178	180		then throw("can use neutrino only")
179	181		else if ((0 >= price))
180	182		then throw("price less zero")
181	183		else if ((getOrderOwner(newOrderId) != ""))
182	184		then throw("order exists")
183	185		else {
184	186		let orders = split(orderbook, ORDERSPLITSYMBOL)
185	187		let nextOrderId = if ((position == 0))
186	188		then ""
187	189		else orders[(position - 1)]
188	190		let nextOrderPrice = getOrderPrice(nextOrderId)
189	191		let isNextOrderError = if (if ((nextOrderId != ""))
190	192		then (price > nextOrderPrice)
191	193		else false)
192	194		then true
193	195		else false
194	196		let prevOrderId = orders[position]
195	197		let prevOrderPrice = getOrderPrice(prevOrderId)
196	198		let isPrevOrderError = if ((prevOrderPrice >= price))
197	199		then true
198	200		else false
199	201		if (if (isNextOrderError)
200	202		then true
201	203		else isPrevOrderError)
202	204		then throw(((("invalid order isPrevOrderError:" + toString(isPrevOrderError)) + " isNextOrderError:") + toString(isNextOrderError)))
203	205		else WriteSet([DataEntry(OrderBookKey, addOrder(newOrderId, position)), DataEntry(getOrderPriceKey(newOrderId), price), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
204	206		}
205	207		}
206	208
207	209
208	210
209	211		@Callable(i)
210	212		func cancelOrder (orderId) = {
211	213		let owner = getOrderOwner(orderId)
212	214		let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
213	215		if ((owner != toString(i.caller)))
214	216		then throw("permission denied")
215	217		else if ((getOrderStatus(orderId) != NEW))
216	218		then throw("invalid order status")
217	219		else ScriptResult(WriteSet([DataEntry(OrderBookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, neutrinoAssetId)]))
218	220		}
219	221
220	222
221	223
222	224		@Callable(i)
223	225		func executeOrder () = {
224	226		let bondBalance = assetBalance(this, bondAssetId)
225	227		let deficitPositive = if ((0 >= deficit))
226	228		then 0
227	229		else deficit
228	230		let bondAmount = if ((deficitPositive >= bondBalance))
229	231		then bondBalance
230	232		else deficitPositive
231	233		let returnAmount = if ((deficitPositive >= bondBalance))
232	234		then 0
233	235		else (bondBalance - deficitPositive)
234	236		if (if ((returnAmount == 0))
235	237		then (bondAmount == 0)
236	238		else false)
237	239		then throw("without deficit")
238	240		else if ((bondAmount == 0))
239	241		then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, bondAssetId)])
240	242		else {
241	243		let orderId = split(orderbook, ORDERSPLITSYMBOL)[0]
242	244		let filledTotal = getOrderFilledTotal(orderId)
243	245		let orderTotal = getOrderTotal(orderId)
244	246		let orderPrice = getOrderPrice(orderId)
245	247		let orderOwner = getOrderOwner(orderId)
246		-	let amount = ((((orderTotal - filledTotal) * 100) / orderPrice) ~~/ PAULI~~)
	248	+	let amount = convertNeutrinoToBond((((orderTotal - filledTotal) * 100) / orderPrice))
247	249		let newOrderbook = if ((bondAmount >= amount))
248	250		then dropOrder(orderId)
249	251		else orderbook
250	252		let filledAmount = if ((bondAmount >= amount))
251	253		then amount
252	254		else bondAmount
253		-	let total = (((filledAmount * orderPrice) / 100) * PAULI)
	255	+	let total = (((filledAmount * orderPrice) * PAULI) / 100)
254	256		let status = if ((bondAmount >= amount))
255	257		then FILLED
256	258		else NEW
257		-	ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
	259	+	if ((total == 0))
	260	+	then throw("total equal zero")
	261	+	else ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
258	262		}
259	263		}
260	264
261	265

github/deemru/w8io/3ef1775 
84.46 ms ◑