w8 · tx · HHC···9C3

tx · HHC5SLqKu2qc7FqHQEzrn238VJJWGwMKeA8zAioMA9C3

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.01400000 Waves

2021.12.25 13:48 [1849697] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HHC5SLqKu2qc7FqHQEzrn238VJJWGwMKeA8zAioMA9C3",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1640429395577,
    "version": 1,
    "sender": "3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT",
    "senderPublicKey": "D1BL65meykxFZTCuq7jq9HSGLLnWvQamQPUNrguW5w39",
    "proofs": [
        "67j9gHG6rmwcDz2SogPuHcqYuBft2XyaTVM6e7JPQF2yW7WpXkw5nJKPMVtjaFkFAqTejmoYjUMeAqD5AqXeGEpg"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1849697,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3MmKcPHh1dRgj2unHNPVjmhwX6A6ybLa2vYLyJRLvH7u
Next: 48G5A1xEfH6mzVunUDqUEPxhyV7TU9Xi5hHirRiDoR7s

Diff: 
Old New Differences
245 245          then getAccBalance(prIdStr)
246 246          else (getAccBalance(prIdStr) - inPrAmt)
247 247      if (true)
248 -         then throw(((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)))
248 +         then throw(((((((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)) + " getAccBalance(amIdStr) = ") + toString(getAccBalance(amIdStr))) + " etAccBalance(prIdStr) = ") + toString(getAccBalance(prIdStr))))
249 249          else {
250 250              let inAmAssetAmtX18 = toX18(inAmAmt, amtDcm)
251 251              let inPrAssetAmtX18 = toX18(inPrAmt, priceDcm)
743 743  func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEvaluate,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, userAddress, isEvaluate, emitLp))
744 744  
745 745  
746 - 
747 - @Callable(i)
748 - func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
749 -     let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
750 -     $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
751 -     }
752 - 
753 - 
754 746  @Verifier(tx)
755 747  func verify () = match tx {
756 748      case order: Order => 
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 5 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let lPdecimals = 8
5 5  
6 6  let scale8 = 100000000
7 7  
8 8  let scale8BigInt = toBigInt(100000000)
9 9  
10 10  let calcError = toBigInt(1000000)
11 11  
12 12  let scale18 = toBigInt(1000000000000000000)
13 13  
14 14  let zeroBigInt = toBigInt(0)
15 15  
16 16  let oneBigInt = toBigInt(1)
17 17  
18 18  let SEP = "__"
19 19  
20 20  let EMPTY = ""
21 21  
22 22  let PoolActive = 1
23 23  
24 24  let PoolPutDisabled = 2
25 25  
26 26  let PoolMatcherDisabled = 3
27 27  
28 28  let PoolShutdown = 4
29 29  
30 30  let idxPoolAddress = 1
31 31  
32 32  let idxPoolStatus = 2
33 33  
34 34  let idxLPAsId = 3
35 35  
36 36  let idxAmAsId = 4
37 37  
38 38  let idxPrAsId = 5
39 39  
40 40  let idxAmtAsDcm = 6
41 41  
42 42  let idxPriceAsDcm = 7
43 43  
44 44  let idxIAmtAsId = 8
45 45  
46 46  let idxIPriceAsId = 9
47 47  
48 48  let idxFactStakCntr = 1
49 49  
50 50  let idxFactSlippCntr = 7
51 51  
52 52  let idxFactGwxRewCntr = 10
53 53  
54 54  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
55 55  
56 56  
57 57  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
58 58  
59 59  
60 60  func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
61 61  
62 62  
63 63  func abs (val) = if ((zeroBigInt > val))
64 64      then -(val)
65 65      else val
66 66  
67 67  
68 68  func keyFactCntr () = "%s__factoryContract"
69 69  
70 70  
71 71  func keyManagerPublicKey () = "%s__managerPublicKey"
72 72  
73 73  
74 74  func keyPriceLast () = "%s%s__price__last"
75 75  
76 76  
77 77  func keyPriceHistory (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
78 78  
79 79  
80 80  func keyPutActionByUser (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
81 81  
82 82  
83 83  func keyGetActionByUser (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
84 84  
85 85  
86 86  func keyAmtAsset () = "%s__amountAsset"
87 87  
88 88  
89 89  func keyPriceAsset () = "%s__priceAsset"
90 90  
91 91  
92 92  func keyFactoryConfig () = "%s__factoryConfig"
93 93  
94 94  
95 95  func keyMatcherPub () = "%s%s__matcher__publicKey"
96 96  
97 97  
98 98  func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
99 99  
100 100  
101 101  func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
102 102  
103 103  
104 104  func keyAllPoolsShutdown () = "%s__shutdown"
105 105  
106 106  
107 107  func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
108 108  
109 109  
110 110  func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("Validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
111 111  
112 112  
113 113  func asString (val) = match val {
114 114      case valStr: String => 
115 115          valStr
116 116      case _ => 
117 117          throw("fail cast to String")
118 118  }
119 119  
120 120  
121 121  func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
122 122  
123 123  
124 124  func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
125 125  
126 126  
127 127  let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactCntr()))
128 128  
129 129  func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
130 130  
131 131  
132 132  func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
133 133  
134 134  
135 135  func getPoolConfig () = {
136 136      let amtAs = getStringOrFail(this, keyAmtAsset())
137 137      let priceAs = getStringOrFail(this, keyPriceAsset())
138 138      let iPriceAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAs))
139 139      let iAmtAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAs))
140 140      split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAs), toString(iPriceAs))), SEP)
141 141      }
142 142  
143 143  
144 144  func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
145 145  
146 146  
147 147  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
148 148  
149 149  
150 150  func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
151 151  
152 152  
153 153  func getAccBalance (assetId) = if ((assetId == "WAVES"))
154 154      then wavesBalance(this).available
155 155      else assetBalance(this, fromBase58String(assetId))
156 156  
157 157  
158 158  func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
159 159  
160 160  
161 161  func calcAbsDiff (realAmt,expectedAmt,slippage) = {
162 162      let diff = fraction((realAmt - expectedAmt), scale8BigInt, expectedAmt)
163 163      $Tuple3(((slippage - abs(diff)) > zeroBigInt), min([realAmt, expectedAmt]), diff)
164 164      }
165 165  
166 166  
167 167  func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
168 168      let amtAsAmtX18 = toX18(amAmt, amAssetDcm)
169 169      let prAsAmtX18 = toX18(prAmt, prAssetDcm)
170 170      calcPriceBigInt(prAsAmtX18, amtAsAmtX18)
171 171      }
172 172  
173 173  
174 174  func calcPrices (amAmt,prAmt,lpAmt) = {
175 175      let cfg = getPoolConfig()
176 176      let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
177 177      let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
178 178      let priceX18 = privateCalcPrice(amtAsDcm, prAsDcm, amAmt, prAmt)
179 179      let amAmtX18 = toX18(amAmt, amtAsDcm)
180 180      let prAmtX18 = toX18(prAmt, prAsDcm)
181 181      let lpAmtX18 = toX18(lpAmt, scale8)
182 182      let lpPrInAmAsX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
183 183      let lpPrInPrAsX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
184 184  [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
185 185      }
186 186  
187 187  
188 188  func calculatePrices (amAmt,prAmt,lpAmt) = {
189 189      let prices = calcPrices(amAmt, prAmt, lpAmt)
190 190  [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
191 191      }
192 192  
193 193  
194 194  func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
195 195      let cfg = getPoolConfig()
196 196      let lpId = cfg[idxLPAsId]
197 197      let amId = cfg[idxAmAsId]
198 198      let prId = cfg[idxPrAsId]
199 199      let amDcm = parseIntValue(cfg[idxAmtAsDcm])
200 200      let prDcm = parseIntValue(cfg[idxPriceAsDcm])
201 201      let poolStatus = cfg[idxPoolStatus]
202 202      let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Invalid LP id").quantity
203 203      if ((lpId != pmtAssetId))
204 204          then throw("Invalid pmt asset")
205 205          else {
206 206              let amBalance = getAccBalance(amId)
207 207              let amBalanceX18 = toX18(amBalance, amDcm)
208 208              let prBalance = getAccBalance(prId)
209 209              let prBalanceX18 = toX18(prBalance, prDcm)
210 210              let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
211 211              let curPrice = fromX18(curPriceX18, scale8)
212 212              let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
213 213              let lpEmissionX18 = toX18(lpEmission, scale8)
214 214              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
215 215              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
216 216              let outAmAmt = fromX18(outAmAmtX18, amDcm)
217 217              let outPrAmt = fromX18(outPrAmtX18, prDcm)
218 218              let state = if ((txId58 == ""))
219 219                  then nil
220 220                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
221 221                      then unit
222 222                      else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
223 223                      then unit
224 224                      else fromBase58String(prId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
225 225              $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
226 226              }
227 227      }
228 228  
229 229  
230 230  func estimatePutOperation (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEvaluate,emitLp) = {
231 231      let cfg = getPoolConfig()
232 232      let lpId = fromBase58String(cfg[idxLPAsId])
233 233      let amIdStr = cfg[idxAmAsId]
234 234      let prIdStr = cfg[idxPrAsId]
235 235      let inAmIdStr = cfg[idxIAmtAsId]
236 236      let inPrIdStr = cfg[idxIPriceAsId]
237 237      let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
238 238      let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
239 239      let poolStatus = cfg[idxPoolStatus]
240 240      let lpEmission = valueOrErrorMessage(assetInfo(lpId), "Wrong lp asset").quantity
241 241      let amBalance = if (isEvaluate)
242 242          then getAccBalance(amIdStr)
243 243          else (getAccBalance(amIdStr) - inAmAmt)
244 244      let prBalance = if (isEvaluate)
245 245          then getAccBalance(prIdStr)
246 246          else (getAccBalance(prIdStr) - inPrAmt)
247 247      if (true)
248 -         then throw(((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)))
248 +         then throw(((((((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)) + " getAccBalance(amIdStr) = ") + toString(getAccBalance(amIdStr))) + " etAccBalance(prIdStr) = ") + toString(getAccBalance(prIdStr))))
249 249          else {
250 250              let inAmAssetAmtX18 = toX18(inAmAmt, amtDcm)
251 251              let inPrAssetAmtX18 = toX18(inPrAmt, priceDcm)
252 252              let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
253 253              let amBalanceX18 = toX18(amBalance, amtDcm)
254 254              let prBalanceX18 = toX18(prBalance, priceDcm)
255 255              let res = if ((lpEmission == 0))
256 256                  then {
257 257                      let curPriceX18 = zeroBigInt
258 258                      let slippageX18 = zeroBigInt
259 259                      let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
260 260                      $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtDcm), fromX18(inPrAssetAmtX18, priceDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
261 261                      }
262 262                  else {
263 263                      let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
264 264                      let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
265 265                      let slippageX18 = toX18(slippage, scale8)
266 266                      if (if ((curPriceX18 != zeroBigInt))
267 267                          then (slippageRealX18 > slippageX18)
268 268                          else false)
269 269                          then throw(((("Price slippage " + toString(slippageRealX18)) + " exceeded ") + toString(slippageX18)))
270 270                          else {
271 271                              let lpEmissionX18 = toX18(lpEmission, scale8)
272 272                              let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
273 273                              let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
274 274                              let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
275 275                                  then $Tuple2(amViaPrX18, inPrAssetAmtX18)
276 276                                  else $Tuple2(inAmAssetAmtX18, prViaAmX18)
277 277                              let expAmtAssetAmtX18 = expectedAmts._1
278 278                              let expPriceAssetAmtX18 = expectedAmts._2
279 279                              let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
280 280                              $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtDcm), fromX18(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
281 281                              }
282 282                      }
283 283              let calcLpAmt = res._1
284 284              let calcAmAssetPmt = res._2
285 285              let calcPrAssetPmt = res._3
286 286              let curPrice = fromX18(res._4, scale8)
287 287              let slippageCalc = fromX18(res._5, scale8)
288 288              if ((0 >= calcLpAmt))
289 289                  then throw("LP < 0")
290 290                  else {
291 291                      let emitLpAmt = if (!(emitLp))
292 292                          then 0
293 293                          else calcLpAmt
294 294                      let amDiff = (inAmAmt - calcAmAssetPmt)
295 295                      let prDiff = (inPrAmt - calcPrAssetPmt)
296 296                      let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
297 297                      $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
298 298                      }
299 299              }
300 300      }
301 301  
302 302  
303 303  func validateMatcherOrderAllowed (order) = {
304 304      let cfg = getPoolConfig()
305 305      let amtAsId = cfg[idxAmAsId]
306 306      let prAsId = cfg[idxPrAsId]
307 307      let poolStatus = parseIntValue(cfg[idxPoolStatus])
308 308      let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
309 309      let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
310 310      let accAmtAsBalance = getAccBalance(amtAsId)
311 311      let accPrAsBalance = getAccBalance(prAsId)
312 312      let curPriceX18 = if ((order.orderType == Buy))
313 313          then privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
314 314          else privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
315 315      let curPrice = fromX18(curPriceX18, scale8)
316 316      if (if (if (isGlobalShutdown())
317 317          then true
318 318          else (poolStatus == PoolMatcherDisabled))
319 319          then true
320 320          else (poolStatus == PoolShutdown))
321 321          then throw("Blocked by admin")
322 322          else {
323 323              let orAmtAsset = order.assetPair.amountAsset
324 324              let orAmtAsStr = if ((orAmtAsset == unit))
325 325                  then "WAVES"
326 326                  else toBase58String(value(orAmtAsset))
327 327              let orPrAsset = order.assetPair.priceAsset
328 328              let orPrAsStr = if ((orPrAsset == unit))
329 329                  then "WAVES"
330 330                  else toBase58String(value(orPrAsset))
331 331              if (if ((orAmtAsStr != amtAsId))
332 332                  then true
333 333                  else (orPrAsStr != prAsId))
334 334                  then throw("Wrong order assets")
335 335                  else {
336 336                      let orderPrice = order.price
337 337                      let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
338 338                      let castOrderPrice = toScale(orderPrice, scale8, priceDcm)
339 339                      let isOrderPriceValid = if ((order.orderType == Buy))
340 340                          then (curPrice >= castOrderPrice)
341 341                          else (castOrderPrice >= curPrice)
342 342                      true
343 343                      }
344 344              }
345 345      }
346 346  
347 347  
348 348  func commonGet (i) = if ((size(i.payments) != 1))
349 349      then throw("1 payment expected")
350 350      else {
351 351          let pmt = value(i.payments[0])
352 352          let pmtAssetId = value(pmt.assetId)
353 353          let pmtAmt = pmt.amount
354 354          let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
355 355          let outAmAmt = res._1
356 356          let outPrAmt = res._2
357 357          let poolStatus = parseIntValue(res._9)
358 358          let state = res._10
359 359          if (if (isGlobalShutdown())
360 360              then true
361 361              else (poolStatus == PoolShutdown))
362 362              then throw(("Blocked by admin: " + toString(poolStatus)))
363 363              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
364 364          }
365 365  
366 366  
367 367  func commonPut (caller,txId,amAsPmt,prAsPmt,slippage,emitLp) = {
368 368      let r = estimatePutOperation(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp)
369 369      let status = parseIntValue(r._8)
370 370      if (if (if (isGlobalShutdown())
371 371          then true
372 372          else (status == PoolPutDisabled))
373 373          then true
374 374          else (status == PoolShutdown))
375 375          then throw(("Blocked by admin: " + toString(status)))
376 376          else r
377 377      }
378 378  
379 379  
380 380  @Callable(i)
381 381  func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
382 382      then throw("permissions denied")
383 383      else [StringEntry(keyFactCntr(), factoryContract), StringEntry(keyManagerPublicKey(), managerPublicKey)]
384 384  
385 385  
386 386  
387 387  @Callable(i)
388 388  func put (slip,autoStake) = {
389 389      let factCfg = getFactoryConfig()
390 390      let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Incorrect staking addr")
391 391      let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Incorrect slippage addr")
392 392      if ((0 > slip))
393 393          then throw("Invalid slippage.")
394 394          else if ((size(i.payments) != 2))
395 395              then throw("2 payments expected")
396 396              else {
397 397                  let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true)
398 398                  let emitLpAmt = estPut._2
399 399                  let lpAssetId = estPut._7
400 400                  let state = estPut._9
401 401                  let amDiff = estPut._10
402 402                  let prDiff = estPut._11
403 403                  let amId = estPut._12
404 404                  let prId = estPut._13
405 405                  let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
406 406                  if ((emitInv == emitInv))
407 407                      then {
408 408                          let slippageAInv = if ((amDiff > 0))
409 409                              then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
410 410                              else nil
411 411                          if ((slippageAInv == slippageAInv))
412 412                              then {
413 413                                  let slippagePInv = if ((prDiff > 0))
414 414                                      then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
415 415                                      else nil
416 416                                  if ((slippagePInv == slippagePInv))
417 417                                      then {
418 418                                          let lpTrnsfr = if (autoStake)
419 419                                              then {
420 420                                                  let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
421 421                                                  if ((slpStakeInv == slpStakeInv))
422 422                                                      then nil
423 423                                                      else throw("Strict value is not equal to itself.")
424 424                                                  }
425 425                                              else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
426 426                                          (state ++ lpTrnsfr)
427 427                                          }
428 428                                      else throw("Strict value is not equal to itself.")
429 429                                  }
430 430                              else throw("Strict value is not equal to itself.")
431 431                          }
432 432                      else throw("Strict value is not equal to itself.")
433 433                  }
434 434      }
435 435  
436 436  
437 437  
438 438  @Callable(i)
439 439  func putOneTkn (inAmtAmount,inPrAmount,outLp,slippage,autoStake) = {
440 440      let cfg = getFactoryConfig()
441 441      let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wrong staking addr")
442 442      let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wrong slippage addr")
443 443      let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wrong slippage addr")
444 444      let poolCfg = getPoolConfig()
445 445      let amId = poolCfg[idxAmAsId]
446 446      let prId = poolCfg[idxPrAsId]
447 447      let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
448 448      let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
449 449      if ((size(i.payments) != 1))
450 450          then throw("1 payment expected")
451 451          else {
452 452              let pmt = value(i.payments[0])
453 453              let pmtAssetId = toBase58String(value(pmt.assetId))
454 454              let pmtAmt = pmt.amount
455 455              let amAssetSwapX18 = toX18(inAmtAmount, amDcm)
456 456              let prAssetSwapX18 = toX18(inPrAmount, prDcm)
457 457              let amBalance = getAccBalance(amId)
458 458              let amBalanceX18 = toX18(amBalance, amDcm)
459 459              let prBalance = getAccBalance(prId)
460 460              let prBalanceX18 = toX18(prBalance, prDcm)
461 461              let amBalanceNow = if ((pmtAssetId == amId))
462 462                  then (amBalance - pmtAmt)
463 463                  else amBalance
464 464              let prBalanceNow = if ((pmtAssetId == prId))
465 465                  then (prBalance - pmtAmt)
466 466                  else prBalance
467 467              let dCur = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), "50", "100000000", "1"], nil)
468 468              let invLeft = parseBigIntValue(asString(dCur))
469 469              let invRight = if ((pmtAssetId == amId))
470 470                  then {
471 471                      let pmtAmtX18 = toX18(pmtAmt, amDcm)
472 472                      let prAdiff = prAssetSwapX18
473 473                      let amAdiff = (pmtAmtX18 - amAssetSwapX18)
474 474                      let dSwap = invoke(gwxCntr, "calcD", [toString((toBigInt(amBalanceNow) + toBigInt(fromX18(amAdiff, amDcm)))), toString((toBigInt(prBalanceNow) - toBigInt(fromX18(prAdiff, prDcm)))), "50", "100000000", "1"], nil)
475 475                      parseBigIntValue(asString(dSwap))
476 476                      }
477 477                  else {
478 478                      let pmtPrX18 = toX18(pmtAmt, prDcm)
479 479                      let prAdiff = (pmtPrX18 - prAssetSwapX18)
480 480                      let amAdiff = amAssetSwapX18
481 481                      let dSwap = invoke(gwxCntr, "calcD", [toString((toBigInt(amBalanceNow) - toBigInt(fromX18(amAdiff, amDcm)))), toString((toBigInt(prBalanceNow) + toBigInt(fromX18(prAdiff, prDcm)))), "50", "100000000", "1"], nil)
482 482                      parseBigIntValue(asString(dSwap))
483 483                      }
484 484              if (!(calcAbsDiff(invRight, invLeft, toBigInt(1000))._1))
485 485                  then throw("D mismatch.")
486 486                  else {
487 487                      let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), inAmtAmount), AttachedPayment(fromBase58String(prId), inPrAmount), 50000000000, true)
488 488                      let estimLP = estPut._2
489 489                      let lpAssetId = estPut._7
490 490                      let state = estPut._9
491 491                      let amDiff = estPut._10
492 492                      let prDiff = estPut._11
493 493                      let lpCalcRes = calcAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
494 494                      if (!(lpCalcRes._1))
495 495                          then throw(((("Too big slippage: " + toString(lpCalcRes._3)) + " vs ") + toString(slippage)))
496 496                          else {
497 497                              let emitLpAmt = toInt(lpCalcRes._2)
498 498                              let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
499 499                              if ((emitInv == emitInv))
500 500                                  then {
501 501                                      let slippageAInv = if ((amDiff > 0))
502 502                                          then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
503 503                                          else nil
504 504                                      if ((slippageAInv == slippageAInv))
505 505                                          then {
506 506                                              let slippagePInv = if ((prDiff > 0))
507 507                                                  then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
508 508                                                  else nil
509 509                                              if ((slippagePInv == slippagePInv))
510 510                                                  then {
511 511                                                      let lpTrnsfr = if (autoStake)
512 512                                                          then {
513 513                                                              let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
514 514                                                              if ((slpStakeInv == slpStakeInv))
515 515                                                                  then nil
516 516                                                                  else throw("Strict value is not equal to itself.")
517 517                                                              }
518 518                                                          else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
519 519                                                      (state ++ lpTrnsfr)
520 520                                                      }
521 521                                                  else throw("Strict value is not equal to itself.")
522 522                                              }
523 523                                          else throw("Strict value is not equal to itself.")
524 524                                      }
525 525                                  else throw("Strict value is not equal to itself.")
526 526                              }
527 527                      }
528 528              }
529 529      }
530 530  
531 531  
532 532  
533 533  @Callable(i)
534 534  func putForFree (maxSlippage) = if ((0 > maxSlippage))
535 535      then throw("Invalid slippage")
536 536      else if ((size(i.payments) != 2))
537 537          then throw("2 payments expected")
538 538          else {
539 539              let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlippage, false)
540 540              estPut._9
541 541              }
542 542  
543 543  
544 544  
545 545  @Callable(i)
546 546  func get () = {
547 547      let res = commonGet(i)
548 548      let outAmtAmt = res._1
549 549      let outPrAmt = res._2
550 550      let pmtAmt = res._3
551 551      let pmtAssetId = res._4
552 552      let state = res._5
553 553      let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
554 554      if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
555 555          then state
556 556          else throw("Strict value is not equal to itself.")
557 557      }
558 558  
559 559  
560 560  
561 561  @Callable(i)
562 562  func getOneTkn (amAssetSwap,prAssetSwap,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
563 563      then throw("1 payment expected")
564 564      else {
565 565          let cfg = getPoolConfig()
566 566          let lpId = cfg[idxLPAsId]
567 567          let amId = cfg[idxAmAsId]
568 568          let prId = cfg[idxPrAsId]
569 569          let amDcm = parseIntValue(cfg[idxAmtAsDcm])
570 570          let prDcm = parseIntValue(cfg[idxPriceAsDcm])
571 571          let poolStatus = cfg[idxPoolStatus]
572 572          let fcfg = getFactoryConfig()
573 573          let gwxCntr = valueOrErrorMessage(addressFromString(fcfg[idxFactGwxRewCntr]), "Wrong slippage address")
574 574          if (if ((outAssetId != amId))
575 575              then (outAssetId != prId)
576 576              else false)
577 577              then throw("Invalid out asset")
578 578              else {
579 579                  let resultAssetId = if ((outAssetId == amId))
580 580                      then amId
581 581                      else prId
582 582                  let pmt = value(i.payments[0])
583 583                  let userAddress = i.caller
584 584                  let txId58 = toBase58String(i.transactionId)
585 585                  let pmtAssetId = value(pmt.assetId)
586 586                  let pmtAmt = pmt.amount
587 587                  if ((lpId != toBase58String(pmtAssetId)))
588 588                      then throw("Invalid LP")
589 589                      else {
590 590                          let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
591 591                          let estimAmAmt = r._1
592 592                          let estimPrAmt = r._2
593 593                          let amBalance = getAccBalance(amId)
594 594                          let amBalanceX18 = toX18(amBalance, amDcm)
595 595                          let prBalance = getAccBalance(prId)
596 596                          let prBalanceX18 = toX18(prBalance, prDcm)
597 597                          let invLeft = invoke(gwxCntr, "calcD", [toString(amBalance), toString(prBalance), "50", "100000000", "1"], nil)
598 598                          let resultTuple = if ((outAssetId == amId))
599 599                              then {
600 600                                  let amAssetDiff = (outAmount - estimAmAmt)
601 601                                  let invRight = invoke(gwxCntr, "calcD", [toString((amBalance - amAssetDiff)), toString((prBalance + prAssetSwap)), "50", "100000000", "1"], nil)
602 602                                  if (!(calcAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))._1))
603 603                                      then throw("D mismatch")
604 604                                      else {
605 605                                          let resultAmt = (estimAmAmt + amAssetSwap)
606 606                                          let lpCalcRes = calcAbsDiff(toBigInt(resultAmt), toBigInt(outAmount), toBigInt(slippage))
607 607                                          if (!(lpCalcRes._1))
608 608                                              then throw(((("Too big slippage: " + toString(lpCalcRes._3)) + " vs ") + toString(slippage)))
609 609                                              else $Tuple2(toInt(lpCalcRes._2), 0)
610 610                                          }
611 611                                  }
612 612                              else {
613 613                                  let prAssetDiff = (outAmount - estimPrAmt)
614 614                                  let invRight = invoke(gwxCntr, "calcD", [toString((amBalance + amAssetSwap)), toString((prBalance - prAssetDiff)), "50", "100000000", "1"], nil)
615 615                                  if (!(calcAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(5000))._1))
616 616                                      then throw("D mismatch.")
617 617                                      else {
618 618                                          let resultAmt = (estimPrAmt + prAssetSwap)
619 619                                          let lpCalcRes = calcAbsDiff(toBigInt(resultAmt), toBigInt(outAmount), toBigInt(slippage))
620 620                                          if (!(lpCalcRes._1))
621 621                                              then throw(((("Too big slippage: " + toString(lpCalcRes._3)) + " vs ") + toString(slippage)))
622 622                                              else $Tuple2(0, toInt(lpCalcRes._2))
623 623                                          }
624 624                                  }
625 625                          let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
626 626                          let curPrice = fromX18(curPriceX18, scale8)
627 627                          let state = [ScriptTransfer(userAddress, if ((resultAssetId == amId))
628 628                              then resultTuple._1
629 629                              else resultTuple._2, if ((resultAssetId == "WAVES"))
630 630                              then unit
631 631                              else fromBase58String(resultAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(resultTuple._1, resultTuple._2, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
632 632                          let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
633 633                          if ((burn == burn))
634 634                              then state
635 635                              else throw("Strict value is not equal to itself.")
636 636                          }
637 637                  }
638 638          }
639 639  
640 640  
641 641  
642 642  @Callable(i)
643 643  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
644 644      let res = commonGet(i)
645 645      let outAmAmt = res._1
646 646      let outPrAmt = res._2
647 647      let pmtAmt = res._3
648 648      let pmtAssetId = res._4
649 649      let state = res._5
650 650      if ((noLessThenAmtAsset > outAmAmt))
651 651          then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
652 652          else if ((noLessThenPriceAsset > outPrAmt))
653 653              then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
654 654              else {
655 655                  let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
656 656                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
657 657                      then state
658 658                      else throw("Strict value is not equal to itself.")
659 659                  }
660 660      }
661 661  
662 662  
663 663  
664 664  @Callable(i)
665 665  func unstakeAndGet (amount) = {
666 666      let checkPayments = if ((size(i.payments) != 0))
667 667          then throw("No payments expected")
668 668          else true
669 669      if ((checkPayments == checkPayments))
670 670          then {
671 671              let cfg = getPoolConfig()
672 672              let factoryCfg = getFactoryConfig()
673 673              let lpAssetId = fromBase58String(cfg[idxLPAsId])
674 674              let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wrong staking address.")
675 675              let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
676 676              if ((unstakeInv == unstakeInv))
677 677                  then {
678 678                      let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
679 679                      let poolStatus = parseIntValue(r._9)
680 680                      let state = r._10
681 681                      let checkPoolStatus = if (if (isGlobalShutdown())
682 682                          then true
683 683                          else (poolStatus == PoolShutdown))
684 684                          then throw(("Blocked by admin: " + toString(poolStatus)))
685 685                          else true
686 686                      if ((checkPoolStatus == checkPoolStatus))
687 687                          then {
688 688                              let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
689 689                              if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
690 690                                  then state
691 691                                  else throw("Strict value is not equal to itself.")
692 692                              }
693 693                          else throw("Strict value is not equal to itself.")
694 694                      }
695 695                  else throw("Strict value is not equal to itself.")
696 696              }
697 697          else throw("Strict value is not equal to itself.")
698 698      }
699 699  
700 700  
701 701  
702 702  @Callable(i)
703 703  func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
704 704      then throw("permissions denied")
705 705      else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
706 706  
707 707  
708 708  
709 709  @Callable(i)
710 710  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
711 711  
712 712  
713 713  
714 714  @Callable(i)
715 715  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
716 716  
717 717  
718 718  
719 719  @Callable(i)
720 720  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
721 721      let prices = calcPrices(amAmt, prAmt, lpAmt)
722 722      $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
723 723      }
724 724  
725 725  
726 726  
727 727  @Callable(i)
728 728  func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
729 729  
730 730  
731 731  
732 732  @Callable(i)
733 733  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
734 734  
735 735  
736 736  
737 737  @Callable(i)
738 738  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
739 739  
740 740  
741 741  
742 742  @Callable(i)
743 743  func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEvaluate,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, userAddress, isEvaluate, emitLp))
744 744  
745 745  
746 - 
747 - @Callable(i)
748 - func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
749 -     let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
750 -     $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
751 -     }
752 - 
753 - 
754 746  @Verifier(tx)
755 747  func verify () = match tx {
756 748      case order: Order => 
757 749          let matcherPub = getMatcherPubOrFail()
758 750          let orderValid = validateMatcherOrderAllowed(order)
759 751          let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
760 752          let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
761 753          if (if (if (orderValid)
762 754              then senderValid
763 755              else false)
764 756              then matcherValid
765 757              else false)
766 758              then true
767 759              else throwOrderError(orderValid, senderValid, matcherValid)
768 760      case _ => 
769 761          let managerPublic = valueOrElse(getString(this, keyManagerPublicKey()), EMPTY)
770 762          if ((managerPublic == EMPTY))
771 763              then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
772 764              else sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(managerPublic))
773 765  }
774 766

Old	New		Differences
245	245		then getAccBalance(prIdStr)
246	246		else (getAccBalance(prIdStr) - inPrAmt)
247	247		if (true)
248		-	then throw(((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)))
	248	+	then throw(((((((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)) + " getAccBalance(amIdStr) = ") + toString(getAccBalance(amIdStr))) + " etAccBalance(prIdStr) = ") + toString(getAccBalance(prIdStr))))
249	249		else {
250	250		let inAmAssetAmtX18 = toX18(inAmAmt, amtDcm)
251	251		let inPrAssetAmtX18 = toX18(inPrAmt, priceDcm)

743	743		func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEvaluate,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, userAddress, isEvaluate, emitLp))
744	744
745	745
746		-
747		-	@Callable(i)
748		-	func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
749		-	let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
750		-	$Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
751		-	}
752		-
753		-
754	746		@Verifier(tx)
755	747		func verify () = match tx {
756	748		case order: Order =>

Old	New		Differences
1	1		{-# STDLIB_VERSION 5 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let lPdecimals = 8
5	5
6	6		let scale8 = 100000000
7	7
8	8		let scale8BigInt = toBigInt(100000000)
9	9
10	10		let calcError = toBigInt(1000000)
11	11
12	12		let scale18 = toBigInt(1000000000000000000)
13	13
14	14		let zeroBigInt = toBigInt(0)
15	15
16	16		let oneBigInt = toBigInt(1)
17	17
18	18		let SEP = "__"
19	19
20	20		let EMPTY = ""
21	21
22	22		let PoolActive = 1
23	23
24	24		let PoolPutDisabled = 2
25	25
26	26		let PoolMatcherDisabled = 3
27	27
28	28		let PoolShutdown = 4
29	29
30	30		let idxPoolAddress = 1
31	31
32	32		let idxPoolStatus = 2
33	33
34	34		let idxLPAsId = 3
35	35
36	36		let idxAmAsId = 4
37	37
38	38		let idxPrAsId = 5
39	39
40	40		let idxAmtAsDcm = 6
41	41
42	42		let idxPriceAsDcm = 7
43	43
44	44		let idxIAmtAsId = 8
45	45
46	46		let idxIPriceAsId = 9
47	47
48	48		let idxFactStakCntr = 1
49	49
50	50		let idxFactSlippCntr = 7
51	51
52	52		let idxFactGwxRewCntr = 10
53	53
54	54		func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
55	55
56	56
57	57		func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
58	58
59	59
60	60		func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
61	61
62	62
63	63		func abs (val) = if ((zeroBigInt > val))
64	64		then -(val)
65	65		else val
66	66
67	67
68	68		func keyFactCntr () = "%s__factoryContract"
69	69
70	70
71	71		func keyManagerPublicKey () = "%s__managerPublicKey"
72	72
73	73
74	74		func keyPriceLast () = "%s%s__price__last"
75	75
76	76
77	77		func keyPriceHistory (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
78	78
79	79
80	80		func keyPutActionByUser (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
81	81
82	82
83	83		func keyGetActionByUser (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
84	84
85	85
86	86		func keyAmtAsset () = "%s__amountAsset"
87	87
88	88
89	89		func keyPriceAsset () = "%s__priceAsset"
90	90
91	91
92	92		func keyFactoryConfig () = "%s__factoryConfig"
93	93
94	94
95	95		func keyMatcherPub () = "%s%s__matcher__publicKey"
96	96
97	97
98	98		func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
99	99
100	100
101	101		func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
102	102
103	103
104	104		func keyAllPoolsShutdown () = "%s__shutdown"
105	105
106	106
107	107		func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
108	108
109	109
110	110		func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("Validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
111	111
112	112
113	113		func asString (val) = match val {
114	114		case valStr: String =>
115	115		valStr
116	116		case _ =>
117	117		throw("fail cast to String")
118	118		}
119	119
120	120
121	121		func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
122	122
123	123
124	124		func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
125	125
126	126
127	127		let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactCntr()))
128	128
129	129		func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
130	130
131	131
132	132		func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
133	133
134	134
135	135		func getPoolConfig () = {
136	136		let amtAs = getStringOrFail(this, keyAmtAsset())
137	137		let priceAs = getStringOrFail(this, keyPriceAsset())
138	138		let iPriceAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAs))
139	139		let iAmtAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAs))
140	140		split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAs), toString(iPriceAs))), SEP)
141	141		}
142	142
143	143
144	144		func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
145	145
146	146
147	147		func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
148	148
149	149
150	150		func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
151	151
152	152
153	153		func getAccBalance (assetId) = if ((assetId == "WAVES"))
154	154		then wavesBalance(this).available
155	155		else assetBalance(this, fromBase58String(assetId))
156	156
157	157
158	158		func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
159	159
160	160
161	161		func calcAbsDiff (realAmt,expectedAmt,slippage) = {
162	162		let diff = fraction((realAmt - expectedAmt), scale8BigInt, expectedAmt)
163	163		$Tuple3(((slippage - abs(diff)) > zeroBigInt), min([realAmt, expectedAmt]), diff)
164	164		}
165	165
166	166
167	167		func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
168	168		let amtAsAmtX18 = toX18(amAmt, amAssetDcm)
169	169		let prAsAmtX18 = toX18(prAmt, prAssetDcm)
170	170		calcPriceBigInt(prAsAmtX18, amtAsAmtX18)
171	171		}
172	172
173	173
174	174		func calcPrices (amAmt,prAmt,lpAmt) = {
175	175		let cfg = getPoolConfig()
176	176		let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
177	177		let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
178	178		let priceX18 = privateCalcPrice(amtAsDcm, prAsDcm, amAmt, prAmt)
179	179		let amAmtX18 = toX18(amAmt, amtAsDcm)
180	180		let prAmtX18 = toX18(prAmt, prAsDcm)
181	181		let lpAmtX18 = toX18(lpAmt, scale8)
182	182		let lpPrInAmAsX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
183	183		let lpPrInPrAsX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
184	184		[priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
185	185		}
186	186
187	187
188	188		func calculatePrices (amAmt,prAmt,lpAmt) = {
189	189		let prices = calcPrices(amAmt, prAmt, lpAmt)
190	190		[fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
191	191		}
192	192
193	193
194	194		func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
195	195		let cfg = getPoolConfig()
196	196		let lpId = cfg[idxLPAsId]
197	197		let amId = cfg[idxAmAsId]
198	198		let prId = cfg[idxPrAsId]
199	199		let amDcm = parseIntValue(cfg[idxAmtAsDcm])
200	200		let prDcm = parseIntValue(cfg[idxPriceAsDcm])
201	201		let poolStatus = cfg[idxPoolStatus]
202	202		let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Invalid LP id").quantity
203	203		if ((lpId != pmtAssetId))
204	204		then throw("Invalid pmt asset")
205	205		else {
206	206		let amBalance = getAccBalance(amId)
207	207		let amBalanceX18 = toX18(amBalance, amDcm)
208	208		let prBalance = getAccBalance(prId)
209	209		let prBalanceX18 = toX18(prBalance, prDcm)
210	210		let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
211	211		let curPrice = fromX18(curPriceX18, scale8)
212	212		let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
213	213		let lpEmissionX18 = toX18(lpEmission, scale8)
214	214		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
215	215		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
216	216		let outAmAmt = fromX18(outAmAmtX18, amDcm)
217	217		let outPrAmt = fromX18(outPrAmtX18, prDcm)
218	218		let state = if ((txId58 == ""))
219	219		then nil
220	220		else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
221	221		then unit
222	222		else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
223	223		then unit
224	224		else fromBase58String(prId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
225	225		$Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
226	226		}
227	227		}
228	228
229	229
230	230		func estimatePutOperation (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEvaluate,emitLp) = {
231	231		let cfg = getPoolConfig()
232	232		let lpId = fromBase58String(cfg[idxLPAsId])
233	233		let amIdStr = cfg[idxAmAsId]
234	234		let prIdStr = cfg[idxPrAsId]
235	235		let inAmIdStr = cfg[idxIAmtAsId]
236	236		let inPrIdStr = cfg[idxIPriceAsId]
237	237		let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
238	238		let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
239	239		let poolStatus = cfg[idxPoolStatus]
240	240		let lpEmission = valueOrErrorMessage(assetInfo(lpId), "Wrong lp asset").quantity
241	241		let amBalance = if (isEvaluate)
242	242		then getAccBalance(amIdStr)
243	243		else (getAccBalance(amIdStr) - inAmAmt)
244	244		let prBalance = if (isEvaluate)
245	245		then getAccBalance(prIdStr)
246	246		else (getAccBalance(prIdStr) - inPrAmt)
247	247		if (true)
248		-	then throw(((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)))
	248	+	then throw(((((((((("lpEmission = " + toString(lpEmission)) + " amBalance = ") + toString(amBalance)) + " prBalance = ") + toString(prBalance)) + " getAccBalance(amIdStr) = ") + toString(getAccBalance(amIdStr))) + " etAccBalance(prIdStr) = ") + toString(getAccBalance(prIdStr))))
249	249		else {
250	250		let inAmAssetAmtX18 = toX18(inAmAmt, amtDcm)
251	251		let inPrAssetAmtX18 = toX18(inPrAmt, priceDcm)
252	252		let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
253	253		let amBalanceX18 = toX18(amBalance, amtDcm)
254	254		let prBalanceX18 = toX18(prBalance, priceDcm)
255	255		let res = if ((lpEmission == 0))
256	256		then {
257	257		let curPriceX18 = zeroBigInt
258	258		let slippageX18 = zeroBigInt
259	259		let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
260	260		$Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtDcm), fromX18(inPrAssetAmtX18, priceDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
261	261		}
262	262		else {
263	263		let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
264	264		let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
265	265		let slippageX18 = toX18(slippage, scale8)
266	266		if (if ((curPriceX18 != zeroBigInt))
267	267		then (slippageRealX18 > slippageX18)
268	268		else false)
269	269		then throw(((("Price slippage " + toString(slippageRealX18)) + " exceeded ") + toString(slippageX18)))
270	270		else {
271	271		let lpEmissionX18 = toX18(lpEmission, scale8)
272	272		let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
273	273		let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
274	274		let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
275	275		then $Tuple2(amViaPrX18, inPrAssetAmtX18)
276	276		else $Tuple2(inAmAssetAmtX18, prViaAmX18)
277	277		let expAmtAssetAmtX18 = expectedAmts._1
278	278		let expPriceAssetAmtX18 = expectedAmts._2
279	279		let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
280	280		$Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtDcm), fromX18(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
281	281		}
282	282		}
283	283		let calcLpAmt = res._1
284	284		let calcAmAssetPmt = res._2
285	285		let calcPrAssetPmt = res._3
286	286		let curPrice = fromX18(res._4, scale8)
287	287		let slippageCalc = fromX18(res._5, scale8)
288	288		if ((0 >= calcLpAmt))
289	289		then throw("LP < 0")
290	290		else {
291	291		let emitLpAmt = if (!(emitLp))
292	292		then 0
293	293		else calcLpAmt
294	294		let amDiff = (inAmAmt - calcAmAssetPmt)
295	295		let prDiff = (inPrAmt - calcPrAssetPmt)
296	296		let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
297	297		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
298	298		}
299	299		}
300	300		}
301	301
302	302
303	303		func validateMatcherOrderAllowed (order) = {
304	304		let cfg = getPoolConfig()
305	305		let amtAsId = cfg[idxAmAsId]
306	306		let prAsId = cfg[idxPrAsId]
307	307		let poolStatus = parseIntValue(cfg[idxPoolStatus])
308	308		let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
309	309		let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
310	310		let accAmtAsBalance = getAccBalance(amtAsId)
311	311		let accPrAsBalance = getAccBalance(prAsId)
312	312		let curPriceX18 = if ((order.orderType == Buy))
313	313		then privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
314	314		else privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
315	315		let curPrice = fromX18(curPriceX18, scale8)
316	316		if (if (if (isGlobalShutdown())
317	317		then true
318	318		else (poolStatus == PoolMatcherDisabled))
319	319		then true
320	320		else (poolStatus == PoolShutdown))
321	321		then throw("Blocked by admin")
322	322		else {
323	323		let orAmtAsset = order.assetPair.amountAsset
324	324		let orAmtAsStr = if ((orAmtAsset == unit))
325	325		then "WAVES"
326	326		else toBase58String(value(orAmtAsset))
327	327		let orPrAsset = order.assetPair.priceAsset
328	328		let orPrAsStr = if ((orPrAsset == unit))
329	329		then "WAVES"
330	330		else toBase58String(value(orPrAsset))
331	331		if (if ((orAmtAsStr != amtAsId))
332	332		then true
333	333		else (orPrAsStr != prAsId))
334	334		then throw("Wrong order assets")
335	335		else {
336	336		let orderPrice = order.price
337	337		let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
338	338		let castOrderPrice = toScale(orderPrice, scale8, priceDcm)
339	339		let isOrderPriceValid = if ((order.orderType == Buy))
340	340		then (curPrice >= castOrderPrice)
341	341		else (castOrderPrice >= curPrice)
342	342		true
343	343		}
344	344		}
345	345		}
346	346
347	347
348	348		func commonGet (i) = if ((size(i.payments) != 1))
349	349		then throw("1 payment expected")
350	350		else {
351	351		let pmt = value(i.payments[0])
352	352		let pmtAssetId = value(pmt.assetId)
353	353		let pmtAmt = pmt.amount
354	354		let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
355	355		let outAmAmt = res._1
356	356		let outPrAmt = res._2
357	357		let poolStatus = parseIntValue(res._9)
358	358		let state = res._10
359	359		if (if (isGlobalShutdown())
360	360		then true
361	361		else (poolStatus == PoolShutdown))
362	362		then throw(("Blocked by admin: " + toString(poolStatus)))
363	363		else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
364	364		}
365	365
366	366
367	367		func commonPut (caller,txId,amAsPmt,prAsPmt,slippage,emitLp) = {
368	368		let r = estimatePutOperation(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp)
369	369		let status = parseIntValue(r._8)
370	370		if (if (if (isGlobalShutdown())
371	371		then true
372	372		else (status == PoolPutDisabled))
373	373		then true
374	374		else (status == PoolShutdown))
375	375		then throw(("Blocked by admin: " + toString(status)))
376	376		else r
377	377		}
378	378
379	379
380	380		@Callable(i)
381	381		func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
382	382		then throw("permissions denied")
383	383		else [StringEntry(keyFactCntr(), factoryContract), StringEntry(keyManagerPublicKey(), managerPublicKey)]
384	384
385	385
386	386
387	387		@Callable(i)
388	388		func put (slip,autoStake) = {
389	389		let factCfg = getFactoryConfig()
390	390		let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Incorrect staking addr")
391	391		let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Incorrect slippage addr")
392	392		if ((0 > slip))
393	393		then throw("Invalid slippage.")
394	394		else if ((size(i.payments) != 2))
395	395		then throw("2 payments expected")
396	396		else {
397	397		let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true)
398	398		let emitLpAmt = estPut._2
399	399		let lpAssetId = estPut._7
400	400		let state = estPut._9
401	401		let amDiff = estPut._10
402	402		let prDiff = estPut._11
403	403		let amId = estPut._12
404	404		let prId = estPut._13
405	405		let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
406	406		if ((emitInv == emitInv))
407	407		then {
408	408		let slippageAInv = if ((amDiff > 0))
409	409		then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
410	410		else nil
411	411		if ((slippageAInv == slippageAInv))
412	412		then {
413	413		let slippagePInv = if ((prDiff > 0))
414	414		then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
415	415		else nil
416	416		if ((slippagePInv == slippagePInv))
417	417		then {
418	418		let lpTrnsfr = if (autoStake)
419	419		then {
420	420		let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
421	421		if ((slpStakeInv == slpStakeInv))
422	422		then nil
423	423		else throw("Strict value is not equal to itself.")
424	424		}
425	425		else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
426	426		(state ++ lpTrnsfr)
427	427		}
428	428		else throw("Strict value is not equal to itself.")
429	429		}
430	430		else throw("Strict value is not equal to itself.")
431	431		}
432	432		else throw("Strict value is not equal to itself.")
433	433		}
434	434		}
435	435
436	436
437	437
438	438		@Callable(i)
439	439		func putOneTkn (inAmtAmount,inPrAmount,outLp,slippage,autoStake) = {
440	440		let cfg = getFactoryConfig()
441	441		let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wrong staking addr")
442	442		let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wrong slippage addr")
443	443		let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wrong slippage addr")
444	444		let poolCfg = getPoolConfig()
445	445		let amId = poolCfg[idxAmAsId]
446	446		let prId = poolCfg[idxPrAsId]
447	447		let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
448	448		let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
449	449		if ((size(i.payments) != 1))
450	450		then throw("1 payment expected")
451	451		else {
452	452		let pmt = value(i.payments[0])
453	453		let pmtAssetId = toBase58String(value(pmt.assetId))
454	454		let pmtAmt = pmt.amount
455	455		let amAssetSwapX18 = toX18(inAmtAmount, amDcm)
456	456		let prAssetSwapX18 = toX18(inPrAmount, prDcm)
457	457		let amBalance = getAccBalance(amId)
458	458		let amBalanceX18 = toX18(amBalance, amDcm)
459	459		let prBalance = getAccBalance(prId)
460	460		let prBalanceX18 = toX18(prBalance, prDcm)
461	461		let amBalanceNow = if ((pmtAssetId == amId))
462	462		then (amBalance - pmtAmt)
463	463		else amBalance
464	464		let prBalanceNow = if ((pmtAssetId == prId))
465	465		then (prBalance - pmtAmt)
466	466		else prBalance
467	467		let dCur = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), "50", "100000000", "1"], nil)
468	468		let invLeft = parseBigIntValue(asString(dCur))
469	469		let invRight = if ((pmtAssetId == amId))
470	470		then {
471	471		let pmtAmtX18 = toX18(pmtAmt, amDcm)
472	472		let prAdiff = prAssetSwapX18
473	473		let amAdiff = (pmtAmtX18 - amAssetSwapX18)
474	474		let dSwap = invoke(gwxCntr, "calcD", [toString((toBigInt(amBalanceNow) + toBigInt(fromX18(amAdiff, amDcm)))), toString((toBigInt(prBalanceNow) - toBigInt(fromX18(prAdiff, prDcm)))), "50", "100000000", "1"], nil)
475	475		parseBigIntValue(asString(dSwap))
476	476		}
477	477		else {
478	478		let pmtPrX18 = toX18(pmtAmt, prDcm)
479	479		let prAdiff = (pmtPrX18 - prAssetSwapX18)
480	480		let amAdiff = amAssetSwapX18
481	481		let dSwap = invoke(gwxCntr, "calcD", [toString((toBigInt(amBalanceNow) - toBigInt(fromX18(amAdiff, amDcm)))), toString((toBigInt(prBalanceNow) + toBigInt(fromX18(prAdiff, prDcm)))), "50", "100000000", "1"], nil)
482	482		parseBigIntValue(asString(dSwap))
483	483		}
484	484		if (!(calcAbsDiff(invRight, invLeft, toBigInt(1000))._1))
485	485		then throw("D mismatch.")
486	486		else {
487	487		let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), inAmtAmount), AttachedPayment(fromBase58String(prId), inPrAmount), 50000000000, true)
488	488		let estimLP = estPut._2
489	489		let lpAssetId = estPut._7
490	490		let state = estPut._9
491	491		let amDiff = estPut._10
492	492		let prDiff = estPut._11
493	493		let lpCalcRes = calcAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
494	494		if (!(lpCalcRes._1))
495	495		then throw(((("Too big slippage: " + toString(lpCalcRes._3)) + " vs ") + toString(slippage)))
496	496		else {
497	497		let emitLpAmt = toInt(lpCalcRes._2)
498	498		let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
499	499		if ((emitInv == emitInv))

github/deemru/w8io/169f3d6 
92.92 ms ◑