w8 · tx · B7v···y7p

tx · B7vtmoajmgVJ3m9xsEFxh9i8egJ1NbrDBDWu12tEy7p

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.01400000 Waves

2021.12.27 12:13 [1852463] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 4cr9ATHeMUnAQtMu8oJo221RR7taPbXpjZLybV6vnF8k
Next: 9CTJUr8BScwyZykb44ubPLGnVXe8ubA7QpZvaVToFH7C

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

Old	New		Differences
643	643		else resultTuple._2, if ((resultAssetId == "WAVES"))
644	644		then unit
645	645		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)]
646		-	if ((state == state))
647		-	then {
648		-	let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
649		-	if ((burn == burn))
650		-	then state
651		-	else throw("Strict value is not equal to itself.")
652		-	}
	646	+	let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
	647	+	if ((burn == burn))
	648	+	then state
653	649		else throw("Strict value is not equal to itself.")
654	650		}
655	651		}

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

github/deemru/w8io/169f3d6 
122.90 ms ◑