w8 · tx

2023.01.23 13:23 [3482978] smart account 3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4Z8oeqecHpe5bwSBnSwLaJzfKZbboCL9EcFgZRVS9NPx",
    "fee": 3600000,
    "feeAssetId": null,
    "timestamp": 1674469419300,
    "version": 1,
    "sender": "3PPZWgFNRKHLvM51pwS934C8VZ7d2F4Z58g",
    "senderPublicKey": "7JeravxHejNM5QqFiU1URLXYHueuDGzjdGucMBFJe5nz",
    "proofs": [
        "2ZE71z4ChVYodiJvBCFHY8eLGeKm2iZ6Kg1FCAGtDeqknzu9G3ngFChmQVzzyGd8KhnPhwq5EozSqoG4QF2vMQw5"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3482978,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: B5vQ4SHTDHhgsWnLgdJ7ejDDqh7YBfhq85XGw77HpoUt
Next: 7WrYjPcin1j7xPoqSFM2Q5YoGELrA9QzmEkij9euM1Hm

Diff: 
Old New Differences
62 62  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
63 63  
64 64  
65 + func toX18BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
66 + 
67 + 
65 68  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
69 + 
70 + 
71 + func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
66 72  
67 73  
68 74  func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
105 111  func pa () = "%s__priceAsset"
106 112  
107 113  
114 + let keyFee = "%s__fee"
115 + 
116 + let feeDefault = fraction(10, scale8, 10000)
117 + 
118 + let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
119 + 
120 + let keyKLp = makeString(["%s", "kLp"], SEP)
121 + 
122 + let keyKLpRefreshedHeight = makeString(["%s", "kLpRefreshedHeight"], SEP)
123 + 
124 + let keyKLpRefreshDelay = makeString(["%s", "refreshKLpDelay"], SEP)
125 + 
126 + let kLpRefreshDelayDefault = 30
127 + 
128 + let kLpRefreshDelay = valueOrElse(getInteger(this, keyKLpRefreshDelay), kLpRefreshDelayDefault)
129 + 
108 130  func keyFactoryConfig () = "%s__factoryConfig"
109 131  
110 132  
131 153  
132 154  let keyFeeCollectorAddress = "%s__feeCollectorAddress"
133 155  
134 - func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
156 + func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
135 157  
136 158  
137 159  func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
141 163  
142 164  
143 165  func throwErr (msg) = throw(makeString(["lp.ride:", msg], " "))
166 + 
167 + 
168 + func fmtErr (msg) = makeString(["lp.ride:", msg], " ")
144 169  
145 170  
146 171  let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))
191 216  
192 217  let poolConfigParsed = parsePoolConfig(getPoolConfig())
193 218  
194 - let $t076017767 = poolConfigParsed
219 + let $t084088574 = poolConfigParsed
195 220  
196 - let cfgPoolAddress = $t076017767._1
221 + let cfgPoolAddress = $t084088574._1
197 222  
198 - let cfgPoolStatus = $t076017767._2
223 + let cfgPoolStatus = $t084088574._2
199 224  
200 - let cfgLpAssetId = $t076017767._3
225 + let cfgLpAssetId = $t084088574._3
201 226  
202 - let cfgAmountAssetId = $t076017767._4
227 + let cfgAmountAssetId = $t084088574._4
203 228  
204 - let cfgPriceAssetId = $t076017767._5
229 + let cfgPriceAssetId = $t084088574._5
205 230  
206 - let cfgAmountAssetDecimals = $t076017767._6
231 + let cfgAmountAssetDecimals = $t084088574._6
207 232  
208 - let cfgPriceAssetDecimals = $t076017767._7
233 + let cfgPriceAssetDecimals = $t084088574._7
209 234  
210 235  func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
211 236  
226 251  
227 252  
228 253  func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
254 + 
255 + 
256 + func calcPriceBigIntRound (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
229 257  
230 258  
231 259  func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
277 305              let lpEmissionX18 = toX18(lpEmission, scale8)
278 306              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
279 307              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
280 -             let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
281 -             let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
308 +             let outAmAmt = fromX18Round(outAmAmtX18, amAssetDcm, FLOOR)
309 +             let outPrAmt = fromX18Round(outPrAmtX18, prAssetDcm, FLOOR)
282 310              let state = if ((txId58 == ""))
283 311                  then nil
284 312                  else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
337 365                          then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
338 366                          else {
339 367                              let lpEmissionX18 = toX18(lpEmission, scale8)
340 -                             let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
341 -                             let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
368 +                             let prViaAmX18 = fraction(inAmAssetAmtX18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
369 +                             let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, FLOOR), CEILING)
342 370                              let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
343 371                                  then $Tuple2(amViaPrX18, inPrAssetAmtX18)
344 372                                  else $Tuple2(inAmAssetAmtX18, prViaAmX18)
345 373                              let expAmtAssetAmtX18 = expectedAmts._1
346 374                              let expPriceAssetAmtX18 = expectedAmts._2
347 -                             let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
348 -                             $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
375 +                             let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18, FLOOR)
376 +                             $Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtAssetDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceAssetDcm, CEILING), curPriceX18, slippageX18)
349 377                              }
350 378                      }
351 379              let calcLpAmt = res._1
368 396      }
369 397  
370 398  
399 + func calcKLp (amountBalance,priceBalance,lpEmission) = {
400 +     let amountBalanceX18 = toX18BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals))
401 +     let priceBalanceX18 = toX18BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))
402 +     let updatedKLp = fraction(pow((amountBalanceX18 * priceBalanceX18), 0, toBigInt(5), 1, 18, DOWN), big1, lpEmission)
403 +     if ((lpEmission == big0))
404 +         then big0
405 +         else updatedKLp
406 +     }
407 + 
408 + 
409 + func calcCurrentKLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
410 +     let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
411 +     let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
412 +     let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
413 +     let currentKLp = calcKLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
414 +     currentKLp
415 +     }
416 + 
417 + 
418 + func refreshKLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
419 +     let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
420 +     let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
421 +     let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
422 +     let updatedKLp = calcKLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
423 +     let actions = [IntegerEntry(keyKLpRefreshedHeight, height), StringEntry(keyKLp, toString(updatedKLp))]
424 +     $Tuple2(actions, updatedKLp)
425 +     }
426 + 
427 + 
428 + func validateUpdatedKLp (oldKLp,updatedKLp) = if ((updatedKLp >= oldKLp))
429 +     then true
430 +     else throwErr(makeString(["updated KLp lower than current KLp", toString(oldKLp), toString(updatedKLp)], " "))
431 + 
432 + 
371 433  func validateMatcherOrderAllowed (order) = {
372 -     let cfg = getPoolConfig()
373 -     let amtAssetId = cfg[idxAmtAssetId]
374 -     let priceAssetId = cfg[idxPriceAssetId]
375 -     let poolStatus = parseIntValue(cfg[idxPoolStatus])
376 -     let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
377 -     let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
378 -     let accAmtAssetBalance = getAccBalance(amtAssetId)
379 -     let accPriceAssetBalance = getAccBalance(priceAssetId)
380 -     let curPriceX18 = if ((order.orderType == Buy))
381 -         then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
382 -         else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
383 -     let curPrice = fromX18(curPriceX18, scale8)
434 +     let amountAssetAmount = order.amount
435 +     let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
436 +     let $t02132621538 = if ((order.orderType == Buy))
437 +         then $Tuple2(amountAssetAmount, -(priceAssetAmount))
438 +         else $Tuple2(-(amountAssetAmount), priceAssetAmount)
439 +     let amountAssetBalanceDelta = $t02132621538._1
440 +     let priceAssetBalanceDelta = $t02132621538._2
384 441      if (if (if (isGlobalShutdown())
385 442          then true
386 -         else (poolStatus == PoolMatcherDisabled))
443 +         else (cfgPoolStatus == PoolMatcherDisabled))
387 444          then true
388 -         else (poolStatus == PoolShutdown))
445 +         else (cfgPoolStatus == PoolShutdown))
389 446          then throw("Exchange operations disabled")
390 -         else {
391 -             let orderAmtAsset = order.assetPair.amountAsset
392 -             let orderAmtAssetStr = if ((orderAmtAsset == unit))
393 -                 then "WAVES"
394 -                 else toBase58String(value(orderAmtAsset))
395 -             let orderPriceAsset = order.assetPair.priceAsset
396 -             let orderPriceAssetStr = if ((orderPriceAsset == unit))
397 -                 then "WAVES"
398 -                 else toBase58String(value(orderPriceAsset))
399 -             if (if ((orderAmtAssetStr != amtAssetId))
400 -                 then true
401 -                 else (orderPriceAssetStr != priceAssetId))
402 -                 then throw("Wrong order assets.")
403 -                 else {
404 -                     let orderPrice = order.price
405 -                     let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
406 -                     let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
407 -                     let isOrderPriceValid = if ((order.orderType == Buy))
408 -                         then (curPrice >= castedOrderPrice)
409 -                         else (castedOrderPrice >= curPrice)
410 -                     true
411 -                     }
412 -             }
447 +         else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
448 +             then true
449 +             else (order.assetPair.priceAsset != cfgPriceAssetId))
450 +             then throw("Wrong order assets.")
451 +             else {
452 +                 let kLp = valueOrErrorMessage(parseBigInt(valueOrErrorMessage(getString(this, keyKLp), fmtErr("kLp is required"))), fmtErr("invalid kLp"))
453 +                 let $t02200922109 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
454 +                 let unusedActions = $t02200922109._1
455 +                 let kLpNew = $t02200922109._2
456 +                 let isOrderValid = (kLpNew >= kLp)
457 +                 let info = makeString([toString(kLp), toString(kLpNew)], " ")
458 +                 $Tuple2(isOrderValid, info)
459 +                 }
413 460      }
414 461  
415 462  
484 531          else if ((paymentAssetId == cfgPriceAssetId))
485 532              then false
486 533              else throwErr("invalid asset")
487 -     let $t02266422957 = if (isEval)
534 +     let $t02491625209 = if (isEval)
488 535          then $Tuple2(amountBalanceRaw, priceBalanceRaw)
489 536          else if (paymentInAmountAsset)
490 537              then $Tuple2((amountBalanceRaw - paymentAmountRaw), priceBalanceRaw)
491 538              else $Tuple2(amountBalanceRaw, (priceBalanceRaw - paymentAmountRaw))
492 -     let amountBalanceOld = $t02266422957._1
493 -     let priceBalanceOld = $t02266422957._2
494 -     let $t02296123110 = if (paymentInAmountAsset)
539 +     let amountBalanceOld = $t02491625209._1
540 +     let priceBalanceOld = $t02491625209._2
541 +     let $t02521325362 = if (paymentInAmountAsset)
495 542          then $Tuple2(paymentAmountRaw, 0)
496 543          else $Tuple2(0, paymentAmountRaw)
497 -     let amountAssetAmountRaw = $t02296123110._1
498 -     let priceAssetAmountRaw = $t02296123110._2
544 +     let amountAssetAmountRaw = $t02521325362._1
545 +     let priceAssetAmountRaw = $t02521325362._2
499 546      let amountAssetAmount = takeFee(amountAssetAmountRaw, inFee)._1
500 547      let priceAssetAmount = takeFee(priceAssetAmountRaw, inFee)._1
501 -     let $t02324223306 = takeFee(paymentAmountRaw, inFee)
502 -     let paymentAmount = $t02324223306._1
503 -     let feeAmount = $t02324223306._2
548 +     let $t02549425558 = takeFee(paymentAmountRaw, inFee)
549 +     let paymentAmount = $t02549425558._1
550 +     let feeAmount = $t02549425558._2
504 551      let amountBalanceNew = (amountBalanceOld + amountAssetAmount)
505 552      let priceBalanceNew = (priceBalanceOld + priceAssetAmount)
506 553      let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, cfgPriceAssetDecimals), toX18(amountBalanceNew, cfgAmountAssetDecimals))
523 570              let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, cfgPriceAssetDecimals), toX18(amountBalanceOld, cfgAmountAssetDecimals))
524 571              let priceOld = fromX18(priceOldX18, scale8)
525 572              let loss = {
526 -                 let $t02478324950 = if (paymentInAmountAsset)
573 +                 let $t02723927406 = if (paymentInAmountAsset)
527 574                      then $Tuple2(amountAssetAmountRaw, amountBalanceOld)
528 575                      else $Tuple2(priceAssetAmountRaw, priceBalanceOld)
529 -                 let amount = $t02478324950._1
530 -                 let balance = $t02478324950._2
576 +                 let amount = $t02723927406._1
577 +                 let balance = $t02723927406._2
531 578                  let issueAmountBoth = toInt(fraction(supplyBigInt, toBigInt((amount / 2)), toBigInt(balance)))
532 579                  fraction((issueAmount - issueAmountBoth), scale8, issueAmountBoth)
533 580                  }
534 -             $Tuple4(issueAmount, commonState, feeAmount, loss)
581 +             $Tuple5(issueAmount, commonState, feeAmount, loss, paymentInAmountAsset)
535 582              }
536 583          else throw("Strict value is not equal to itself.")
537 584      }
539 586  
540 587  func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
541 588      let isEval = (txId == unit)
589 +     let cfg = getPoolConfig()
590 +     let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
591 +     let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
542 592      let checks = [if ((paymentAssetId == cfgLpAssetId))
543 593          then true
544 594          else throwErr("invalid lp asset")]
552 602              let balanceBigInt = if (outInAmountAsset)
553 603                  then toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId)))
554 604                  else toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId)))
605 +             let outInAmountAssetDecimals = if (outInAmountAsset)
606 +                 then amtAssetDcm
607 +                 else priceAssetDcm
555 608              let amBalanceOld = getAccBalance(assetIdToString(cfgAmountAssetId))
556 609              let prBalanceOld = getAccBalance(assetIdToString(cfgPriceAssetId))
557 610              let outBalance = if (outInAmountAsset)
561 614              let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
562 615              let redeemedBigInt = toBigInt(paymentAmount)
563 616              let amountRaw = max([0, toInt(((balanceBigInt * (scale18 - pow((scale18 - ((redeemedBigInt * scale18) / supplyBigInt)), 18, big2, 0, 18, DOWN))) / scale18))])
564 -             let $t02653026586 = takeFee(amountRaw, outFee)
565 -             let totalAmount = $t02653026586._1
566 -             let feeAmount = $t02653026586._2
567 -             let $t02659026816 = if (outInAmountAsset)
617 +             let $t02948429540 = takeFee(amountRaw, outFee)
618 +             let totalAmount = $t02948429540._1
619 +             let feeAmount = $t02948429540._2
620 +             let $t02954429770 = if (outInAmountAsset)
568 621                  then $Tuple4(totalAmount, 0, (amBalanceOld - amountRaw), prBalanceOld)
569 622                  else $Tuple4(0, totalAmount, amBalanceOld, (prBalanceOld - amountRaw))
570 -             let outAmAmount = $t02659026816._1
571 -             let outPrAmount = $t02659026816._2
572 -             let amBalanceNew = $t02659026816._3
573 -             let prBalanceNew = $t02659026816._4
623 +             let outAmAmount = $t02954429770._1
624 +             let outPrAmount = $t02954429770._2
625 +             let amBalanceNew = $t02954429770._3
626 +             let prBalanceNew = $t02954429770._4
574 627              let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, cfgPriceAssetDecimals), toX18(amBalanceNew, cfgAmountAssetDecimals))
575 628              let priceNew = fromX18(priceNewX18, scale8)
576 629              let commonState = if (isEval)
582 635                  let amountBothInPaymentAsset = (toInt(fraction(balanceBigInt, redeemedBigInt, supplyBigInt)) * 2)
583 636                  fraction((totalAmount - amountBothInPaymentAsset), scale8, amountBothInPaymentAsset)
584 637                  }
585 -             $Tuple4(totalAmount, commonState, feeAmount, loss)
638 +             $Tuple5(totalAmount, commonState, feeAmount, loss, outInAmountAsset)
586 639              }
587 640          else throw("Strict value is not equal to itself.")
588 641      }
682 735          let prDiff = estPut._11
683 736          let amId = estPut._12
684 737          let prId = estPut._13
685 -         let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
686 -         if ((emitInv == emitInv))
738 +         let amAssetPmt = toBigInt(value(i.payments[0]).amount)
739 +         let prAssetPmt = toBigInt(value(i.payments[1]).amount)
740 +         let currentKLp = calcCurrentKLp(amAssetPmt, prAssetPmt, toBigInt(0))
741 +         if ((currentKLp == currentKLp))
687 742              then {
688 -                 let emitInvLegacy =                 match emitInv {
689 -                     case legacyFactoryContract: Address => 
690 -                         invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
691 -                     case _ => 
692 -                         unit
693 -                 }
694 -                 if ((emitInvLegacy == emitInvLegacy))
743 +                 let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
744 +                 if ((emitInv == emitInv))
695 745                      then {
696 -                         let slippageAInv = if ((amDiff > 0))
697 -                             then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
698 -                             else nil
699 -                         if ((slippageAInv == slippageAInv))
746 +                         let emitInvLegacy =                         match emitInv {
747 +                             case legacyFactoryContract: Address => 
748 +                                 invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
749 +                             case _ => 
750 +                                 unit
751 +                         }
752 +                         if ((emitInvLegacy == emitInvLegacy))
700 753                              then {
701 -                                 let slippagePInv = if ((prDiff > 0))
702 -                                     then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
754 +                                 let slippageAInv = if ((amDiff > 0))
755 +                                     then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
703 756                                      else nil
704 -                                 if ((slippagePInv == slippagePInv))
757 +                                 if ((slippageAInv == slippageAInv))
705 758                                      then {
706 -                                         let lpTransfer = if (shouldAutoStake)
759 +                                         let slippagePInv = if ((prDiff > 0))
760 +                                             then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
761 +                                             else nil
762 +                                         if ((slippagePInv == slippagePInv))
707 763                                              then {
708 -                                                 let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
709 -                                                 if ((slpStakeInv == slpStakeInv))
710 -                                                     then nil
764 +                                                 let lpTransfer = if (shouldAutoStake)
765 +                                                     then {
766 +                                                         let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
767 +                                                         if ((slpStakeInv == slpStakeInv))
768 +                                                             then nil
769 +                                                             else throw("Strict value is not equal to itself.")
770 +                                                         }
771 +                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
772 +                                                 let $t03429834760 = refreshKLpInternal(0, 0, 0)
773 +                                                 if (($t03429834760 == $t03429834760))
774 +                                                     then {
775 +                                                         let updatedKLp = $t03429834760._2
776 +                                                         let refreshKLpActions = $t03429834760._1
777 +                                                         let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
778 +                                                         if ((isUpdatedKLpValid == isUpdatedKLpValid))
779 +                                                             then ((state ++ lpTransfer) ++ refreshKLpActions)
780 +                                                             else throw("Strict value is not equal to itself.")
781 +                                                         }
711 782                                                      else throw("Strict value is not equal to itself.")
712 783                                                  }
713 -                                             else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
714 -                                         (state ++ lpTransfer)
784 +                                             else throw("Strict value is not equal to itself.")
715 785                                          }
716 786                                      else throw("Strict value is not equal to itself.")
717 787                                  }
729 799      then throw("Invalid value passed")
730 800      else {
731 801          let estPut = commonPut(i, maxSlippage, false)
732 -         estPut._9
802 +         let state = estPut._9
803 +         let amAssetPmt = toBigInt(value(i.payments[0]).amount)
804 +         let prAssetPmt = toBigInt(value(i.payments[1]).amount)
805 +         let currentKLp = calcCurrentKLp(amAssetPmt, prAssetPmt, toBigInt(0))
806 +         if ((currentKLp == currentKLp))
807 +             then {
808 +                 let $t03532235387 = refreshKLpInternal(0, 0, 0)
809 +                 let refreshKLpActions = $t03532235387._1
810 +                 let updatedKLp = $t03532235387._2
811 +                 let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
812 +                 if ((isUpdatedKLpValid == isUpdatedKLpValid))
813 +                     then (state ++ refreshKLpActions)
814 +                     else throw("Strict value is not equal to itself.")
815 +                 }
816 +             else throw("Strict value is not equal to itself.")
733 817          }
734 818  
735 819  
761 845              let payment = i.payments[0]
762 846              let paymentAssetId = payment.assetId
763 847              let paymentAmountRaw = payment.amount
764 -             let userAddress = i.caller
765 -             let txId = i.transactionId
766 -             let $t03172331853 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
767 -             if (($t03172331853 == $t03172331853))
848 +             let currentKLp = if ((paymentAssetId == cfgAmountAssetId))
849 +                 then calcCurrentKLp(toBigInt(paymentAmountRaw), toBigInt(0), toBigInt(0))
850 +                 else if ((paymentAssetId == cfgPriceAssetId))
851 +                     then calcCurrentKLp(toBigInt(0), toBigInt(paymentAmountRaw), toBigInt(0))
852 +                     else throwErr("payment asset is not supported")
853 +             if ((currentKLp == currentKLp))
768 854                  then {
769 -                     let bonus = $t03172331853._4
770 -                     let feeAmount = $t03172331853._3
771 -                     let commonState = $t03172331853._2
772 -                     let emitAmountEstimated = $t03172331853._1
773 -                     let emitAmount = if (if ((minOutAmount > 0))
774 -                         then (minOutAmount > emitAmountEstimated)
775 -                         else false)
776 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
777 -                         else emitAmountEstimated
778 -                     let emitInv = emit(emitAmount)
779 -                     if ((emitInv == emitInv))
855 +                     let userAddress = i.caller
856 +                     let txId = i.transactionId
857 +                     let $t03657536727 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
858 +                     if (($t03657536727 == $t03657536727))
780 859                          then {
781 -                             let lpTransfer = if (autoStake)
860 +                             let paymentInAmountAsset = $t03657536727._5
861 +                             let bonus = $t03657536727._4
862 +                             let feeAmount = $t03657536727._3
863 +                             let commonState = $t03657536727._2
864 +                             let emitAmountEstimated = $t03657536727._1
865 +                             let emitAmount = if (if ((minOutAmount > 0))
866 +                                 then (minOutAmount > emitAmountEstimated)
867 +                                 else false)
868 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
869 +                                 else emitAmountEstimated
870 +                             let emitInv = emit(emitAmount)
871 +                             if ((emitInv == emitInv))
782 872                                  then {
783 -                                     let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(cfgLpAssetId, emitAmount)])
784 -                                     if ((stakeInv == stakeInv))
785 -                                         then nil
873 +                                     let lpTransfer = if (autoStake)
874 +                                         then {
875 +                                             let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(cfgLpAssetId, emitAmount)])
876 +                                             if ((stakeInv == stakeInv))
877 +                                                 then nil
878 +                                                 else throw("Strict value is not equal to itself.")
879 +                                             }
880 +                                         else [ScriptTransfer(i.caller, emitAmount, cfgLpAssetId)]
881 +                                     let sendFee = if ((feeAmount > 0))
882 +                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, paymentAssetId)]
883 +                                         else nil
884 +                                     let $t03731337510 = if ((this == feeCollectorAddress))
885 +                                         then $Tuple2(0, 0)
886 +                                         else if (paymentInAmountAsset)
887 +                                             then $Tuple2(-(feeAmount), 0)
888 +                                             else $Tuple2(0, -(feeAmount))
889 +                                     let amountAssetBalanceDelta = $t03731337510._1
890 +                                     let priceAssetBalanceDelta = $t03731337510._2
891 +                                     let $t03751337621 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
892 +                                     let refreshKLpActions = $t03751337621._1
893 +                                     let updatedKLp = $t03751337621._2
894 +                                     let kLp = value(getString(keyKLp))
895 +                                     let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
896 +                                     if ((isUpdatedKLpValid == isUpdatedKLpValid))
897 +                                         then $Tuple2((((commonState ++ lpTransfer) ++ sendFee) ++ refreshKLpActions), emitAmount)
786 898                                          else throw("Strict value is not equal to itself.")
787 899                                      }
788 -                                 else [ScriptTransfer(i.caller, emitAmount, cfgLpAssetId)]
789 -                             let sendFee = if ((feeAmount > 0))
790 -                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, paymentAssetId)]
791 -                                 else nil
792 -                             $Tuple2(((commonState ++ lpTransfer) ++ sendFee), emitAmount)
900 +                                 else throw("Strict value is not equal to itself.")
793 901                              }
794 902                          else throw("Strict value is not equal to itself.")
795 903                      }
802 910  
803 911  @Callable(i)
804 912  func putOneTknREADONLY (paymentAssetId,paymentAmountRaw) = {
805 -     let $t03258232717 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
806 -     let emitAmountEstimated = $t03258232717._1
807 -     let commonState = $t03258232717._2
808 -     let feeAmount = $t03258232717._3
809 -     let bonus = $t03258232717._4
913 +     let $t03792738084 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
914 +     let emitAmountEstimated = $t03792738084._1
915 +     let commonState = $t03792738084._2
916 +     let feeAmount = $t03792738084._3
917 +     let bonus = $t03792738084._4
918 +     let paymentInAmountAsset = $t03792738084._5
810 919      $Tuple2(nil, $Tuple3(emitAmountEstimated, feeAmount, bonus))
811 920      }
812 921  
838 947              let payment = i.payments[0]
839 948              let paymentAssetId = payment.assetId
840 949              let paymentAmount = payment.amount
841 -             let userAddress = i.caller
842 -             let txId = i.transactionId
843 -             let $t03352233657 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
844 -             if (($t03352233657 == $t03352233657))
950 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
951 +             if ((currentKLp == currentKLp))
845 952                  then {
846 -                     let bonus = $t03352233657._4
847 -                     let feeAmount = $t03352233657._3
848 -                     let commonState = $t03352233657._2
849 -                     let amountEstimated = $t03352233657._1
850 -                     let amount = if (if ((minOutAmount > 0))
851 -                         then (minOutAmount > amountEstimated)
852 -                         else false)
853 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
854 -                         else amountEstimated
855 -                     let burnInv = invoke(factoryContract, "burn", [paymentAmount], [AttachedPayment(paymentAssetId, paymentAmount)])
856 -                     if ((burnInv == burnInv))
953 +                     let userAddress = i.caller
954 +                     let txId = i.transactionId
955 +                     let $t03896939122 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
956 +                     if (($t03896939122 == $t03896939122))
857 957                          then {
858 -                             let assetTransfer = [ScriptTransfer(userAddress, amount, outAssetId)]
859 -                             let sendFee = if ((feeAmount > 0))
860 -                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
861 -                                 else nil
862 -                             $Tuple2(((commonState ++ assetTransfer) ++ sendFee), amount)
958 +                             let outInAmountAsset = $t03896939122._5
959 +                             let bonus = $t03896939122._4
960 +                             let feeAmount = $t03896939122._3
961 +                             let commonState = $t03896939122._2
962 +                             let amountEstimated = $t03896939122._1
963 +                             let amount = if (if ((minOutAmount > 0))
964 +                                 then (minOutAmount > amountEstimated)
965 +                                 else false)
966 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
967 +                                 else amountEstimated
968 +                             let burnInv = invoke(factoryContract, "burn", [paymentAmount], [AttachedPayment(paymentAssetId, paymentAmount)])
969 +                             if ((burnInv == burnInv))
970 +                                 then {
971 +                                     let assetTransfer = [ScriptTransfer(userAddress, amount, outAssetId)]
972 +                                     let sendFee = if ((feeAmount > 0))
973 +                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
974 +                                         else nil
975 +                                     let $t03962239869 = {
976 +                                         let feeAmountForCalc = if ((this == feeCollectorAddress))
977 +                                             then 0
978 +                                             else feeAmount
979 +                                         if (outInAmountAsset)
980 +                                             then $Tuple2(-((amount + feeAmountForCalc)), 0)
981 +                                             else $Tuple2(0, -((amount + feeAmountForCalc)))
982 +                                         }
983 +                                     let amountAssetBalanceDelta = $t03962239869._1
984 +                                     let priceAssetBalanceDelta = $t03962239869._2
985 +                                     let $t03987239980 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
986 +                                     let refreshKLpActions = $t03987239980._1
987 +                                     let updatedKLp = $t03987239980._2
988 +                                     let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
989 +                                     if ((isUpdatedKLpValid == isUpdatedKLpValid))
990 +                                         then $Tuple2((((commonState ++ assetTransfer) ++ sendFee) ++ refreshKLpActions), amount)
991 +                                         else throw("Strict value is not equal to itself.")
992 +                                     }
993 +                                 else throw("Strict value is not equal to itself.")
863 994                              }
864 995                          else throw("Strict value is not equal to itself.")
865 996                      }
872 1003  
873 1004  @Callable(i)
874 1005  func getOneTknREADONLY (outAssetId,paymentAmount) = {
875 -     let $t03429234430 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
876 -     let amountEstimated = $t03429234430._1
877 -     let commonState = $t03429234430._2
878 -     let feeAmount = $t03429234430._3
879 -     let bonus = $t03429234430._4
1006 +     let $t04023740393 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
1007 +     let amountEstimated = $t04023740393._1
1008 +     let commonState = $t04023740393._2
1009 +     let feeAmount = $t04023740393._3
1010 +     let bonus = $t04023740393._4
1011 +     let outInAmountAsset = $t04023740393._5
880 1012      $Tuple2(nil, $Tuple3(amountEstimated, feeAmount, bonus))
881 1013      }
882 1014  
907 1039              let outAssetId = parseAssetId(outAssetIdStr)
908 1040              let userAddress = i.caller
909 1041              let txId = i.transactionId
910 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
911 -             if ((unstakeInv == unstakeInv))
1042 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1043 +             if ((currentKLp == currentKLp))
912 1044                  then {
913 -                     let $t03525535388 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
914 -                     if (($t03525535388 == $t03525535388))
1045 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1046 +                     if ((unstakeInv == unstakeInv))
915 1047                          then {
916 -                             let bonus = $t03525535388._4
917 -                             let feeAmount = $t03525535388._3
918 -                             let commonState = $t03525535388._2
919 -                             let amountEstimated = $t03525535388._1
920 -                             let amount = if (if ((minOutAmount > 0))
921 -                                 then (minOutAmount > amountEstimated)
922 -                                 else false)
923 -                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
924 -                                 else amountEstimated
925 -                             let burnInv = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
926 -                             if ((burnInv == burnInv))
1048 +                             let $t04129841449 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
1049 +                             if (($t04129841449 == $t04129841449))
927 1050                                  then {
928 -                                     let assetTransfer = [ScriptTransfer(i.caller, amount, outAssetId)]
929 -                                     let sendFee = if ((feeAmount > 0))
930 -                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
931 -                                         else nil
932 -                                     $Tuple2(((commonState ++ assetTransfer) ++ sendFee), amount)
1051 +                                     let outInAmountAsset = $t04129841449._5
1052 +                                     let bonus = $t04129841449._4
1053 +                                     let feeAmount = $t04129841449._3
1054 +                                     let commonState = $t04129841449._2
1055 +                                     let amountEstimated = $t04129841449._1
1056 +                                     let amount = if (if ((minOutAmount > 0))
1057 +                                         then (minOutAmount > amountEstimated)
1058 +                                         else false)
1059 +                                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
1060 +                                         else amountEstimated
1061 +                                     let burnInv = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1062 +                                     if ((burnInv == burnInv))
1063 +                                         then {
1064 +                                             let assetTransfer = [ScriptTransfer(i.caller, amount, outAssetId)]
1065 +                                             let sendFee = if ((feeAmount > 0))
1066 +                                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
1067 +                                                 else nil
1068 +                                             let $t04194442191 = {
1069 +                                                 let feeAmountForCalc = if ((this == feeCollectorAddress))
1070 +                                                     then 0
1071 +                                                     else feeAmount
1072 +                                                 if (outInAmountAsset)
1073 +                                                     then $Tuple2(-((amount + feeAmountForCalc)), 0)
1074 +                                                     else $Tuple2(0, -((amount + feeAmountForCalc)))
1075 +                                                 }
1076 +                                             let amountAssetBalanceDelta = $t04194442191._1
1077 +                                             let priceAssetBalanceDelta = $t04194442191._2
1078 +                                             let $t04219442302 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1079 +                                             let refreshKLpActions = $t04219442302._1
1080 +                                             let updatedKLp = $t04219442302._2
1081 +                                             let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1082 +                                             if ((isUpdatedKLpValid == isUpdatedKLpValid))
1083 +                                                 then $Tuple2((((commonState ++ assetTransfer) ++ sendFee) ++ refreshKLpActions), amount)
1084 +                                                 else throw("Strict value is not equal to itself.")
1085 +                                             }
1086 +                                         else throw("Strict value is not equal to itself.")
933 1087                                      }
934 1088                                  else throw("Strict value is not equal to itself.")
935 1089                              }
950 1104      let pmtAmt = res._3
951 1105      let pmtAssetId = res._4
952 1106      let state = res._5
953 -     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
954 -     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
955 -         then state
1107 +     let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1108 +     if ((currentKLp == currentKLp))
1109 +         then {
1110 +             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1111 +             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1112 +                 then {
1113 +                     let $t04324843330 = refreshKLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1114 +                     let refreshKLpActions = $t04324843330._1
1115 +                     let updatedKLp = $t04324843330._2
1116 +                     let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1117 +                     if ((isUpdatedKLpValid == isUpdatedKLpValid))
1118 +                         then (state ++ refreshKLpActions)
1119 +                         else throw("Strict value is not equal to itself.")
1120 +                     }
1121 +                 else throw("Strict value is not equal to itself.")
1122 +             }
956 1123          else throw("Strict value is not equal to itself.")
957 1124      }
958 1125  
971 1138          else if ((noLessThenPriceAsset > outPrAmt))
972 1139              then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
973 1140              else {
974 -                 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
975 -                 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
976 -                     then state
1141 +                 let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1142 +                 if ((currentKLp == currentKLp))
1143 +                     then {
1144 +                         let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1145 +                         if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1146 +                             then {
1147 +                                 let $t04427944360 = refreshKLpInternal(-(outAmAmt), -(outPrAmt), 0)
1148 +                                 let refreshKLpActions = $t04427944360._1
1149 +                                 let updatedKLp = $t04427944360._2
1150 +                                 let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1151 +                                 if ((isUpdatedKLpValid == isUpdatedKLpValid))
1152 +                                     then (state ++ refreshKLpActions)
1153 +                                     else throw("Strict value is not equal to itself.")
1154 +                                 }
1155 +                             else throw("Strict value is not equal to itself.")
1156 +                         }
977 1157                      else throw("Strict value is not equal to itself.")
978 1158                  }
979 1159      }
989 1169          then {
990 1170              let cfg = getPoolConfig()
991 1171              let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
992 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
993 -             if ((unstakeInv == unstakeInv))
1172 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1173 +             if ((currentKLp == currentKLp))
994 1174                  then {
995 -                     let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
996 -                     let poolStatus = parseIntValue(res._9)
997 -                     let state = res._10
998 -                     let checkPoolStatus = if (if (isGlobalShutdown())
999 -                         then true
1000 -                         else (poolStatus == PoolShutdown))
1001 -                         then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
1002 -                         else true
1003 -                     if ((checkPoolStatus == checkPoolStatus))
1175 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
1176 +                     if ((unstakeInv == unstakeInv))
1004 1177                          then {
1005 -                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1006 -                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1007 -                                 then state
1178 +                             let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1179 +                             let outAmAmt = res._1
1180 +                             let outPrAmt = res._2
1181 +                             let poolStatus = parseIntValue(res._9)
1182 +                             let state = res._10
1183 +                             let checkPoolStatus = if (if (isGlobalShutdown())
1184 +                                 then true
1185 +                                 else (poolStatus == PoolShutdown))
1186 +                                 then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
1187 +                                 else true
1188 +                             if ((checkPoolStatus == checkPoolStatus))
1189 +                                 then {
1190 +                                     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1191 +                                     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1192 +                                         then {
1193 +                                             let $t04548645567 = refreshKLpInternal(-(outAmAmt), -(outPrAmt), 0)
1194 +                                             let refreshKLpActions = $t04548645567._1
1195 +                                             let updatedKLp = $t04548645567._2
1196 +                                             let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1197 +                                             if ((isUpdatedKLpValid == isUpdatedKLpValid))
1198 +                                                 then (state ++ refreshKLpActions)
1199 +                                                 else throw("Strict value is not equal to itself.")
1200 +                                             }
1201 +                                         else throw("Strict value is not equal to itself.")
1202 +                                     }
1008 1203                                  else throw("Strict value is not equal to itself.")
1009 1204                              }
1010 1205                          else throw("Strict value is not equal to itself.")
1028 1223          else throw("no payments are expected")]
1029 1224      if ((checks == checks))
1030 1225          then {
1031 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1032 -             if ((unstakeInv == unstakeInv))
1226 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1227 +             if ((currentKLp == currentKLp))
1033 1228                  then {
1034 -                     let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1035 -                     let outAmAmt = res._1
1036 -                     let outPrAmt = res._2
1037 -                     let state = res._10
1038 -                     let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1039 -                         then true
1040 -                         else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1041 -                         then true
1042 -                         else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1043 -                     if ((checkAmounts == checkAmounts))
1229 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1230 +                     if ((unstakeInv == unstakeInv))
1044 1231                          then {
1045 -                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1046 -                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1047 -                                 then state
1232 +                             let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1233 +                             let outAmAmt = res._1
1234 +                             let outPrAmt = res._2
1235 +                             let state = res._10
1236 +                             let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1237 +                                 then true
1238 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1239 +                                 then true
1240 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1241 +                             if ((checkAmounts == checkAmounts))
1242 +                                 then {
1243 +                                     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1244 +                                     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1245 +                                         then {
1246 +                                             let $t04686246943 = refreshKLpInternal(-(outAmAmt), -(outPrAmt), 0)
1247 +                                             let refreshKLpActions = $t04686246943._1
1248 +                                             let updatedKLp = $t04686246943._2
1249 +                                             let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1250 +                                             if ((isUpdatedKLpValid == isUpdatedKLpValid))
1251 +                                                 then (state ++ refreshKLpActions)
1252 +                                                 else throw("Strict value is not equal to itself.")
1253 +                                             }
1254 +                                         else throw("Strict value is not equal to itself.")
1255 +                                     }
1048 1256                                  else throw("Strict value is not equal to itself.")
1049 1257                              }
1050 1258                          else throw("Strict value is not equal to itself.")
1060 1268  func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
1061 1269      then throw("permissions denied")
1062 1270      else $Tuple2([StringEntry(aa(), amtAssetStr), StringEntry(pa(), priceAssetStr)], "success")
1271 + 
1272 + 
1273 + 
1274 + @Callable(i)
1275 + func refreshKLp () = {
1276 +     let lastRefreshedBlockHeight = valueOrElse(getInteger(keyKLpRefreshedHeight), 0)
1277 +     let checkLastRefreshedBlockHeight = if (((height - lastRefreshedBlockHeight) >= kLpRefreshDelay))
1278 +         then unit
1279 +         else throwErr(makeString([toString(kLpRefreshDelay), " blocks have not passed since the previous call"], ""))
1280 +     if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1281 +         then {
1282 +             let kLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyKLp), "0")), fmtErr("invalid kLp"))
1283 +             let $t04813048194 = refreshKLpInternal(0, 0, 0)
1284 +             let kLpUpdateActions = $t04813048194._1
1285 +             let updatedKLp = $t04813048194._2
1286 +             let actions = if ((kLp != updatedKLp))
1287 +                 then kLpUpdateActions
1288 +                 else throwErr("nothing to refresh")
1289 +             $Tuple2(actions, toString(updatedKLp))
1290 +             }
1291 +         else throw("Strict value is not equal to itself.")
1292 +     }
1063 1293  
1064 1294  
1065 1295  
1227 1457      match tx {
1228 1458          case order: Order => 
1229 1459              let matcherPub = getMatcherPubOrFail()
1230 -             let orderValid = validateMatcherOrderAllowed(order)
1460 +             let $t05685656925 = validateMatcherOrderAllowed(order)
1461 +             let orderValid = $t05685656925._1
1462 +             let orderValidInfo = $t05685656925._2
1231 1463              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1232 1464              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1233 1465              if (if (if (orderValid)
1236 1468                  then matcherValid
1237 1469                  else false)
1238 1470                  then true
1239 -                 else throwOrderError(orderValid, senderValid, matcherValid)
1471 +                 else throwOrderError(orderValid, orderValidInfo, senderValid, matcherValid)
1240 1472          case s: SetScriptTransaction => 
1241 1473              let newHash = blake2b256(value(s.script))
1242 1474              let allowedHash = fromBase64String(value(getString(factoryContract, keyAllowedLpScriptHash())))
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
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 scale18 = toBigInt(1000000000000000000)
11 11  
12 12  let zeroBigInt = toBigInt(0)
13 13  
14 14  let big0 = toBigInt(0)
15 15  
16 16  let big1 = toBigInt(1)
17 17  
18 18  let big2 = toBigInt(2)
19 19  
20 20  let wavesString = "WAVES"
21 21  
22 22  let SEP = "__"
23 23  
24 24  let PoolActive = 1
25 25  
26 26  let PoolPutDisabled = 2
27 27  
28 28  let PoolMatcherDisabled = 3
29 29  
30 30  let PoolShutdown = 4
31 31  
32 32  let idxPoolAddress = 1
33 33  
34 34  let idxPoolStatus = 2
35 35  
36 36  let idxPoolLPAssetId = 3
37 37  
38 38  let idxAmtAssetId = 4
39 39  
40 40  let idxPriceAssetId = 5
41 41  
42 42  let idxAmtAssetDcm = 6
43 43  
44 44  let idxPriceAssetDcm = 7
45 45  
46 46  let idxIAmtAssetId = 8
47 47  
48 48  let idxIPriceAssetId = 9
49 49  
50 50  let idxLPAssetDcm = 10
51 51  
52 52  let idxPoolAmtAssetAmt = 1
53 53  
54 54  let idxPoolPriceAssetAmt = 2
55 55  
56 56  let idxPoolLPAssetAmt = 3
57 57  
58 58  let idxFactoryStakingContract = 1
59 59  
60 60  let idxFactorySlippageContract = 7
61 61  
62 62  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
63 63  
64 64  
65 + func toX18BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
66 + 
67 + 
65 68  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
69 + 
70 + 
71 + func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
66 72  
67 73  
68 74  func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
69 75  
70 76  
71 77  func abs (val) = if ((0 > val))
72 78      then -(val)
73 79      else val
74 80  
75 81  
76 82  func absBigInt (val) = if ((zeroBigInt > val))
77 83      then -(val)
78 84      else val
79 85  
80 86  
81 87  func fc () = "%s__factoryContract"
82 88  
83 89  
84 90  func mpk () = "%s__managerPublicKey"
85 91  
86 92  
87 93  func pmpk () = "%s__pendingManagerPublicKey"
88 94  
89 95  
90 96  func pl () = "%s%s__price__last"
91 97  
92 98  
93 99  func ph (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
94 100  
95 101  
96 102  func pau (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
97 103  
98 104  
99 105  func gau (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
100 106  
101 107  
102 108  func aa () = "%s__amountAsset"
103 109  
104 110  
105 111  func pa () = "%s__priceAsset"
106 112  
107 113  
114 + let keyFee = "%s__fee"
115 + 
116 + let feeDefault = fraction(10, scale8, 10000)
117 + 
118 + let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
119 + 
120 + let keyKLp = makeString(["%s", "kLp"], SEP)
121 + 
122 + let keyKLpRefreshedHeight = makeString(["%s", "kLpRefreshedHeight"], SEP)
123 + 
124 + let keyKLpRefreshDelay = makeString(["%s", "refreshKLpDelay"], SEP)
125 + 
126 + let kLpRefreshDelayDefault = 30
127 + 
128 + let kLpRefreshDelay = valueOrElse(getInteger(this, keyKLpRefreshDelay), kLpRefreshDelayDefault)
129 + 
108 130  func keyFactoryConfig () = "%s__factoryConfig"
109 131  
110 132  
111 133  func keyMatcherPub () = "%s%s__matcher__publicKey"
112 134  
113 135  
114 136  func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
115 137  
116 138  
117 139  func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
118 140  
119 141  
120 142  func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
121 143  
122 144  
123 145  func keyAllPoolsShutdown () = "%s__shutdown"
124 146  
125 147  
126 148  func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
127 149  
128 150  
129 151  func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
130 152  
131 153  
132 154  let keyFeeCollectorAddress = "%s__feeCollectorAddress"
133 155  
134 - func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
156 + func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
135 157  
136 158  
137 159  func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
138 160  
139 161  
140 162  func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
141 163  
142 164  
143 165  func throwErr (msg) = throw(makeString(["lp.ride:", msg], " "))
166 + 
167 + 
168 + func fmtErr (msg) = makeString(["lp.ride:", msg], " ")
144 169  
145 170  
146 171  let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))
147 172  
148 173  let feeCollectorAddress = addressFromStringValue(getStringOrFail(factoryContract, keyFeeCollectorAddress))
149 174  
150 175  let inFee = {
151 176      let @ = invoke(factoryContract, "getInFeeREADONLY", [toString(this)], nil)
152 177      if ($isInstanceOf(@, "Int"))
153 178          then @
154 179          else throw(($getType(@) + " couldn't be cast to Int"))
155 180      }
156 181  
157 182  let outFee = {
158 183      let @ = invoke(factoryContract, "getOutFeeREADONLY", [toString(this)], nil)
159 184      if ($isInstanceOf(@, "Int"))
160 185          then @
161 186          else throw(($getType(@) + " couldn't be cast to Int"))
162 187      }
163 188  
164 189  func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
165 190  
166 191  
167 192  func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
168 193  
169 194  
170 195  func getPoolConfig () = {
171 196      let amtAsset = getStringOrFail(this, aa())
172 197      let priceAsset = getStringOrFail(this, pa())
173 198      let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
174 199      let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
175 200      split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
176 201      }
177 202  
178 203  
179 204  func parseAssetId (input) = if ((input == wavesString))
180 205      then unit
181 206      else fromBase58String(input)
182 207  
183 208  
184 209  func assetIdToString (input) = if ((input == unit))
185 210      then wavesString
186 211      else toBase58String(value(input))
187 212  
188 213  
189 214  func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolStatus]), fromBase58String(poolConfig[idxPoolLPAssetId]), parseAssetId(poolConfig[idxAmtAssetId]), parseAssetId(poolConfig[idxPriceAssetId]), parseIntValue(poolConfig[idxAmtAssetDcm]), parseIntValue(poolConfig[idxPriceAssetDcm]))
190 215  
191 216  
192 217  let poolConfigParsed = parsePoolConfig(getPoolConfig())
193 218  
194 - let $t076017767 = poolConfigParsed
219 + let $t084088574 = poolConfigParsed
195 220  
196 - let cfgPoolAddress = $t076017767._1
221 + let cfgPoolAddress = $t084088574._1
197 222  
198 - let cfgPoolStatus = $t076017767._2
223 + let cfgPoolStatus = $t084088574._2
199 224  
200 - let cfgLpAssetId = $t076017767._3
225 + let cfgLpAssetId = $t084088574._3
201 226  
202 - let cfgAmountAssetId = $t076017767._4
227 + let cfgAmountAssetId = $t084088574._4
203 228  
204 - let cfgPriceAssetId = $t076017767._5
229 + let cfgPriceAssetId = $t084088574._5
205 230  
206 - let cfgAmountAssetDecimals = $t076017767._6
231 + let cfgAmountAssetDecimals = $t084088574._6
207 232  
208 - let cfgPriceAssetDecimals = $t076017767._7
233 + let cfgPriceAssetDecimals = $t084088574._7
209 234  
210 235  func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
211 236  
212 237  
213 238  let stakingContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactoryStakingContract]), "incorrect staking address")
214 239  
215 240  let slippageContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactorySlippageContract]), "incorrect staking address")
216 241  
217 242  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
218 243  
219 244  
220 245  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)
221 246  
222 247  
223 248  func getAccBalance (assetId) = if ((assetId == "WAVES"))
224 249      then wavesBalance(this).available
225 250      else assetBalance(this, fromBase58String(assetId))
226 251  
227 252  
228 253  func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
254 + 
255 + 
256 + func calcPriceBigIntRound (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
229 257  
230 258  
231 259  func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
232 260      let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
233 261      let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
234 262      calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
235 263      }
236 264  
237 265  
238 266  func calcPrices (amAmt,prAmt,lpAmt) = {
239 267      let cfg = getPoolConfig()
240 268      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
241 269      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
242 270      let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
243 271      let amAmtX18 = toX18(amAmt, amtAssetDcm)
244 272      let prAmtX18 = toX18(prAmt, priceAssetDcm)
245 273      let lpAmtX18 = toX18(lpAmt, scale8)
246 274      let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
247 275      let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
248 276  [priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
249 277      }
250 278  
251 279  
252 280  func calculatePrices (amAmt,prAmt,lpAmt) = {
253 281      let prices = calcPrices(amAmt, prAmt, lpAmt)
254 282  [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
255 283      }
256 284  
257 285  
258 286  func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
259 287      let cfg = getPoolConfig()
260 288      let lpAssetId = cfg[idxPoolLPAssetId]
261 289      let amAssetId = cfg[idxAmtAssetId]
262 290      let prAssetId = cfg[idxPriceAssetId]
263 291      let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
264 292      let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
265 293      let poolStatus = cfg[idxPoolStatus]
266 294      let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
267 295      if ((lpAssetId != pmtAssetId))
268 296          then throw("Invalid asset passed.")
269 297          else {
270 298              let amBalance = getAccBalance(amAssetId)
271 299              let amBalanceX18 = toX18(amBalance, amAssetDcm)
272 300              let prBalance = getAccBalance(prAssetId)
273 301              let prBalanceX18 = toX18(prBalance, prAssetDcm)
274 302              let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
275 303              let curPrice = fromX18(curPriceX18, scale8)
276 304              let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
277 305              let lpEmissionX18 = toX18(lpEmission, scale8)
278 306              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
279 307              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
280 -             let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
281 -             let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
308 +             let outAmAmt = fromX18Round(outAmAmtX18, amAssetDcm, FLOOR)
309 +             let outPrAmt = fromX18Round(outPrAmtX18, prAssetDcm, FLOOR)
282 310              let state = if ((txId58 == ""))
283 311                  then nil
284 312                  else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
285 313                      then unit
286 314                      else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
287 315                      then unit
288 316                      else fromBase58String(prAssetId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
289 317              $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
290 318              }
291 319      }
292 320  
293 321  
294 322  func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
295 323      let cfg = getPoolConfig()
296 324      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
297 325      let amAssetIdStr = cfg[idxAmtAssetId]
298 326      let prAssetIdStr = cfg[idxPriceAssetId]
299 327      let iAmtAssetId = cfg[idxIAmtAssetId]
300 328      let iPriceAssetId = cfg[idxIPriceAssetId]
301 329      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
302 330      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
303 331      let poolStatus = cfg[idxPoolStatus]
304 332      let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
305 333      let inAmAssetIdStr = toBase58String(valueOrElse(inAmAssetId, fromBase58String("WAVES")))
306 334      let inPrAssetIdStr = toBase58String(valueOrElse(inPrAssetId, fromBase58String("WAVES")))
307 335      if (if ((amAssetIdStr != inAmAssetIdStr))
308 336          then true
309 337          else (prAssetIdStr != inPrAssetIdStr))
310 338          then throw("Invalid amt or price asset passed.")
311 339          else {
312 340              let amBalance = if (isEvaluate)
313 341                  then getAccBalance(amAssetIdStr)
314 342                  else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
315 343              let prBalance = if (isEvaluate)
316 344                  then getAccBalance(prAssetIdStr)
317 345                  else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
318 346              let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
319 347              let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
320 348              let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
321 349              let amBalanceX18 = toX18(amBalance, amtAssetDcm)
322 350              let prBalanceX18 = toX18(prBalance, priceAssetDcm)
323 351              let res = if ((lpEmission == 0))
324 352                  then {
325 353                      let curPriceX18 = zeroBigInt
326 354                      let slippageX18 = zeroBigInt
327 355                      let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
328 356                      $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
329 357                      }
330 358                  else {
331 359                      let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
332 360                      let slippageX18 = fraction(absBigInt((curPriceX18 - userPriceX18)), scale18, curPriceX18)
333 361                      let slippageToleranceX18 = toX18(slippageTolerance, scale8)
334 362                      if (if ((curPriceX18 != zeroBigInt))
335 363                          then (slippageX18 > slippageToleranceX18)
336 364                          else false)
337 365                          then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
338 366                          else {
339 367                              let lpEmissionX18 = toX18(lpEmission, scale8)
340 -                             let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
341 -                             let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
368 +                             let prViaAmX18 = fraction(inAmAssetAmtX18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
369 +                             let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, FLOOR), CEILING)
342 370                              let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
343 371                                  then $Tuple2(amViaPrX18, inPrAssetAmtX18)
344 372                                  else $Tuple2(inAmAssetAmtX18, prViaAmX18)
345 373                              let expAmtAssetAmtX18 = expectedAmts._1
346 374                              let expPriceAssetAmtX18 = expectedAmts._2
347 -                             let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
348 -                             $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
375 +                             let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18, FLOOR)
376 +                             $Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtAssetDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceAssetDcm, CEILING), curPriceX18, slippageX18)
349 377                              }
350 378                      }
351 379              let calcLpAmt = res._1
352 380              let calcAmAssetPmt = res._2
353 381              let calcPrAssetPmt = res._3
354 382              let curPrice = fromX18(res._4, scale8)
355 383              let slippageCalc = fromX18(res._5, scale8)
356 384              if ((0 >= calcLpAmt))
357 385                  then throw("Invalid calculations. LP calculated is less than zero.")
358 386                  else {
359 387                      let emitLpAmt = if (!(emitLp))
360 388                          then 0
361 389                          else calcLpAmt
362 390                      let amDiff = (inAmAssetAmt - calcAmAssetPmt)
363 391                      let prDiff = (inPrAssetAmt - calcPrAssetPmt)
364 392                      let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
365 393                      $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
366 394                      }
367 395              }
368 396      }
369 397  
370 398  
399 + func calcKLp (amountBalance,priceBalance,lpEmission) = {
400 +     let amountBalanceX18 = toX18BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals))
401 +     let priceBalanceX18 = toX18BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))
402 +     let updatedKLp = fraction(pow((amountBalanceX18 * priceBalanceX18), 0, toBigInt(5), 1, 18, DOWN), big1, lpEmission)
403 +     if ((lpEmission == big0))
404 +         then big0
405 +         else updatedKLp
406 +     }
407 + 
408 + 
409 + func calcCurrentKLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
410 +     let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
411 +     let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
412 +     let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
413 +     let currentKLp = calcKLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
414 +     currentKLp
415 +     }
416 + 
417 + 
418 + func refreshKLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
419 +     let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
420 +     let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
421 +     let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
422 +     let updatedKLp = calcKLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
423 +     let actions = [IntegerEntry(keyKLpRefreshedHeight, height), StringEntry(keyKLp, toString(updatedKLp))]
424 +     $Tuple2(actions, updatedKLp)
425 +     }
426 + 
427 + 
428 + func validateUpdatedKLp (oldKLp,updatedKLp) = if ((updatedKLp >= oldKLp))
429 +     then true
430 +     else throwErr(makeString(["updated KLp lower than current KLp", toString(oldKLp), toString(updatedKLp)], " "))
431 + 
432 + 
371 433  func validateMatcherOrderAllowed (order) = {
372 -     let cfg = getPoolConfig()
373 -     let amtAssetId = cfg[idxAmtAssetId]
374 -     let priceAssetId = cfg[idxPriceAssetId]
375 -     let poolStatus = parseIntValue(cfg[idxPoolStatus])
376 -     let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
377 -     let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
378 -     let accAmtAssetBalance = getAccBalance(amtAssetId)
379 -     let accPriceAssetBalance = getAccBalance(priceAssetId)
380 -     let curPriceX18 = if ((order.orderType == Buy))
381 -         then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
382 -         else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
383 -     let curPrice = fromX18(curPriceX18, scale8)
434 +     let amountAssetAmount = order.amount
435 +     let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
436 +     let $t02132621538 = if ((order.orderType == Buy))
437 +         then $Tuple2(amountAssetAmount, -(priceAssetAmount))
438 +         else $Tuple2(-(amountAssetAmount), priceAssetAmount)
439 +     let amountAssetBalanceDelta = $t02132621538._1
440 +     let priceAssetBalanceDelta = $t02132621538._2
384 441      if (if (if (isGlobalShutdown())
385 442          then true
386 -         else (poolStatus == PoolMatcherDisabled))
443 +         else (cfgPoolStatus == PoolMatcherDisabled))
387 444          then true
388 -         else (poolStatus == PoolShutdown))
445 +         else (cfgPoolStatus == PoolShutdown))
389 446          then throw("Exchange operations disabled")
390 -         else {
391 -             let orderAmtAsset = order.assetPair.amountAsset
392 -             let orderAmtAssetStr = if ((orderAmtAsset == unit))
393 -                 then "WAVES"
394 -                 else toBase58String(value(orderAmtAsset))
395 -             let orderPriceAsset = order.assetPair.priceAsset
396 -             let orderPriceAssetStr = if ((orderPriceAsset == unit))
397 -                 then "WAVES"
398 -                 else toBase58String(value(orderPriceAsset))
399 -             if (if ((orderAmtAssetStr != amtAssetId))
400 -                 then true
401 -                 else (orderPriceAssetStr != priceAssetId))
402 -                 then throw("Wrong order assets.")
403 -                 else {
404 -                     let orderPrice = order.price
405 -                     let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
406 -                     let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
407 -                     let isOrderPriceValid = if ((order.orderType == Buy))
408 -                         then (curPrice >= castedOrderPrice)
409 -                         else (castedOrderPrice >= curPrice)
410 -                     true
411 -                     }
412 -             }
447 +         else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
448 +             then true
449 +             else (order.assetPair.priceAsset != cfgPriceAssetId))
450 +             then throw("Wrong order assets.")
451 +             else {
452 +                 let kLp = valueOrErrorMessage(parseBigInt(valueOrErrorMessage(getString(this, keyKLp), fmtErr("kLp is required"))), fmtErr("invalid kLp"))
453 +                 let $t02200922109 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
454 +                 let unusedActions = $t02200922109._1
455 +                 let kLpNew = $t02200922109._2
456 +                 let isOrderValid = (kLpNew >= kLp)
457 +                 let info = makeString([toString(kLp), toString(kLpNew)], " ")
458 +                 $Tuple2(isOrderValid, info)
459 +                 }
413 460      }
414 461  
415 462  
416 463  func commonGet (i) = if ((size(i.payments) != 1))
417 464      then throw("exactly 1 payment is expected")
418 465      else {
419 466          let pmt = value(i.payments[0])
420 467          let pmtAssetId = value(pmt.assetId)
421 468          let pmtAmt = pmt.amount
422 469          let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
423 470          let outAmAmt = res._1
424 471          let outPrAmt = res._2
425 472          let poolStatus = parseIntValue(res._9)
426 473          let state = res._10
427 474          if (if (isGlobalShutdown())
428 475              then true
429 476              else (poolStatus == PoolShutdown))
430 477              then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
431 478              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
432 479          }
433 480  
434 481  
435 482  func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
436 483      then throw("exactly 2 payments are expected")
437 484      else {
438 485          let amAssetPmt = value(i.payments[0])
439 486          let prAssetPmt = value(i.payments[1])
440 487          let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp)
441 488          let poolStatus = parseIntValue(estPut._8)
442 489          if (if (if (isGlobalShutdown())
443 490              then true
444 491              else (poolStatus == PoolPutDisabled))
445 492              then true
446 493              else (poolStatus == PoolShutdown))
447 494              then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
448 495              else estPut
449 496          }
450 497  
451 498  
452 499  func emit (amount) = {
453 500      let emitInv = invoke(factoryContract, "emit", [amount], nil)
454 501      if ((emitInv == emitInv))
455 502          then {
456 503              let emitInvLegacy =             match emitInv {
457 504                  case legacyFactoryContract: Address => 
458 505                      invoke(legacyFactoryContract, "emit", [amount], nil)
459 506                  case _ => 
460 507                      unit
461 508              }
462 509              if ((emitInvLegacy == emitInvLegacy))
463 510                  then amount
464 511                  else throw("Strict value is not equal to itself.")
465 512              }
466 513          else throw("Strict value is not equal to itself.")
467 514      }
468 515  
469 516  
470 517  func takeFee (amount,fee) = {
471 518      let feeAmount = if ((fee == 0))
472 519          then 0
473 520          else fraction(amount, fee, scale8)
474 521      $Tuple2((amount - feeAmount), feeAmount)
475 522      }
476 523  
477 524  
478 525  func calcPutOneToken (paymentAmountRaw,paymentAssetId,userAddress,txId) = {
479 526      let isEval = (txId == unit)
480 527      let amountBalanceRaw = getAccBalance(assetIdToString(cfgAmountAssetId))
481 528      let priceBalanceRaw = getAccBalance(assetIdToString(cfgPriceAssetId))
482 529      let paymentInAmountAsset = if ((paymentAssetId == cfgAmountAssetId))
483 530          then true
484 531          else if ((paymentAssetId == cfgPriceAssetId))
485 532              then false
486 533              else throwErr("invalid asset")
487 -     let $t02266422957 = if (isEval)
534 +     let $t02491625209 = if (isEval)
488 535          then $Tuple2(amountBalanceRaw, priceBalanceRaw)
489 536          else if (paymentInAmountAsset)
490 537              then $Tuple2((amountBalanceRaw - paymentAmountRaw), priceBalanceRaw)
491 538              else $Tuple2(amountBalanceRaw, (priceBalanceRaw - paymentAmountRaw))
492 -     let amountBalanceOld = $t02266422957._1
493 -     let priceBalanceOld = $t02266422957._2
494 -     let $t02296123110 = if (paymentInAmountAsset)
539 +     let amountBalanceOld = $t02491625209._1
540 +     let priceBalanceOld = $t02491625209._2
541 +     let $t02521325362 = if (paymentInAmountAsset)
495 542          then $Tuple2(paymentAmountRaw, 0)
496 543          else $Tuple2(0, paymentAmountRaw)
497 -     let amountAssetAmountRaw = $t02296123110._1
498 -     let priceAssetAmountRaw = $t02296123110._2
544 +     let amountAssetAmountRaw = $t02521325362._1
545 +     let priceAssetAmountRaw = $t02521325362._2
499 546      let amountAssetAmount = takeFee(amountAssetAmountRaw, inFee)._1
500 547      let priceAssetAmount = takeFee(priceAssetAmountRaw, inFee)._1
501 -     let $t02324223306 = takeFee(paymentAmountRaw, inFee)
502 -     let paymentAmount = $t02324223306._1
503 -     let feeAmount = $t02324223306._2
548 +     let $t02549425558 = takeFee(paymentAmountRaw, inFee)
549 +     let paymentAmount = $t02549425558._1
550 +     let feeAmount = $t02549425558._2
504 551      let amountBalanceNew = (amountBalanceOld + amountAssetAmount)
505 552      let priceBalanceNew = (priceBalanceOld + priceAssetAmount)
506 553      let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, cfgPriceAssetDecimals), toX18(amountBalanceNew, cfgAmountAssetDecimals))
507 554      let priceNew = fromX18(priceNewX18, scale8)
508 555      let paymentBalance = if (paymentInAmountAsset)
509 556          then amountBalanceOld
510 557          else priceBalanceOld
511 558      let paymentBalanceBigInt = toBigInt(paymentBalance)
512 559      let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
513 560      let chechSupply = if ((supplyBigInt > big0))
514 561          then true
515 562          else throwErr("initial deposit requires all coins")
516 563      if ((chechSupply == chechSupply))
517 564          then {
518 565              let depositBigInt = toBigInt(paymentAmount)
519 566              let issueAmount = max([0, toInt(((supplyBigInt * (sqrtBigInt((scale18 + ((depositBigInt * scale18) / paymentBalanceBigInt)), 18, 18, DOWN) - scale18)) / scale18))])
520 567              let commonState = if (isEval)
521 568                  then nil
522 569                  else [IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew), StringEntry(pau(toString(value(userAddress)), toBase58String(value(txId))), dataPutActionInfo(amountAssetAmountRaw, priceAssetAmountRaw, issueAmount, priceNew, 0, 0, height, lastBlock.timestamp, 0, 0))]
523 570              let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, cfgPriceAssetDecimals), toX18(amountBalanceOld, cfgAmountAssetDecimals))
524 571              let priceOld = fromX18(priceOldX18, scale8)
525 572              let loss = {
526 -                 let $t02478324950 = if (paymentInAmountAsset)
573 +                 let $t02723927406 = if (paymentInAmountAsset)
527 574                      then $Tuple2(amountAssetAmountRaw, amountBalanceOld)
528 575                      else $Tuple2(priceAssetAmountRaw, priceBalanceOld)
529 -                 let amount = $t02478324950._1
530 -                 let balance = $t02478324950._2
576 +                 let amount = $t02723927406._1
577 +                 let balance = $t02723927406._2
531 578                  let issueAmountBoth = toInt(fraction(supplyBigInt, toBigInt((amount / 2)), toBigInt(balance)))
532 579                  fraction((issueAmount - issueAmountBoth), scale8, issueAmountBoth)
533 580                  }
534 -             $Tuple4(issueAmount, commonState, feeAmount, loss)
581 +             $Tuple5(issueAmount, commonState, feeAmount, loss, paymentInAmountAsset)
535 582              }
536 583          else throw("Strict value is not equal to itself.")
537 584      }
538 585  
539 586  
540 587  func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
541 588      let isEval = (txId == unit)
589 +     let cfg = getPoolConfig()
590 +     let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
591 +     let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
542 592      let checks = [if ((paymentAssetId == cfgLpAssetId))
543 593          then true
544 594          else throwErr("invalid lp asset")]
545 595      if ((checks == checks))
546 596          then {
547 597              let outInAmountAsset = if ((outAssetId == cfgAmountAssetId))
548 598                  then true
549 599                  else if ((outAssetId == cfgPriceAssetId))
550 600                      then false
551 601                      else throwErr("invalid asset")
552 602              let balanceBigInt = if (outInAmountAsset)
553 603                  then toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId)))
554 604                  else toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId)))
605 +             let outInAmountAssetDecimals = if (outInAmountAsset)
606 +                 then amtAssetDcm
607 +                 else priceAssetDcm
555 608              let amBalanceOld = getAccBalance(assetIdToString(cfgAmountAssetId))
556 609              let prBalanceOld = getAccBalance(assetIdToString(cfgPriceAssetId))
557 610              let outBalance = if (outInAmountAsset)
558 611                  then amBalanceOld
559 612                  else prBalanceOld
560 613              let outBalanceBigInt = toBigInt(outBalance)
561 614              let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
562 615              let redeemedBigInt = toBigInt(paymentAmount)
563 616              let amountRaw = max([0, toInt(((balanceBigInt * (scale18 - pow((scale18 - ((redeemedBigInt * scale18) / supplyBigInt)), 18, big2, 0, 18, DOWN))) / scale18))])
564 -             let $t02653026586 = takeFee(amountRaw, outFee)
565 -             let totalAmount = $t02653026586._1
566 -             let feeAmount = $t02653026586._2
567 -             let $t02659026816 = if (outInAmountAsset)
617 +             let $t02948429540 = takeFee(amountRaw, outFee)
618 +             let totalAmount = $t02948429540._1
619 +             let feeAmount = $t02948429540._2
620 +             let $t02954429770 = if (outInAmountAsset)
568 621                  then $Tuple4(totalAmount, 0, (amBalanceOld - amountRaw), prBalanceOld)
569 622                  else $Tuple4(0, totalAmount, amBalanceOld, (prBalanceOld - amountRaw))
570 -             let outAmAmount = $t02659026816._1
571 -             let outPrAmount = $t02659026816._2
572 -             let amBalanceNew = $t02659026816._3
573 -             let prBalanceNew = $t02659026816._4
623 +             let outAmAmount = $t02954429770._1
624 +             let outPrAmount = $t02954429770._2
625 +             let amBalanceNew = $t02954429770._3
626 +             let prBalanceNew = $t02954429770._4
574 627              let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, cfgPriceAssetDecimals), toX18(amBalanceNew, cfgAmountAssetDecimals))
575 628              let priceNew = fromX18(priceNewX18, scale8)
576 629              let commonState = if (isEval)
577 630                  then nil
578 631                  else [StringEntry(gau(toString(value(userAddress)), toBase58String(value(txId))), dataGetActionInfo(outAmAmount, outPrAmount, paymentAmount, priceNew, height, lastBlock.timestamp)), IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew)]
579 632              let priceOldX18 = calcPriceBigInt(toX18(prBalanceOld, cfgPriceAssetDecimals), toX18(amBalanceOld, cfgAmountAssetDecimals))
580 633              let priceOld = fromX18(priceOldX18, scale8)
581 634              let loss = {
582 635                  let amountBothInPaymentAsset = (toInt(fraction(balanceBigInt, redeemedBigInt, supplyBigInt)) * 2)
583 636                  fraction((totalAmount - amountBothInPaymentAsset), scale8, amountBothInPaymentAsset)
584 637                  }
585 -             $Tuple4(totalAmount, commonState, feeAmount, loss)
638 +             $Tuple5(totalAmount, commonState, feeAmount, loss, outInAmountAsset)
586 639              }
587 640          else throw("Strict value is not equal to itself.")
588 641      }
589 642  
590 643  
591 644  func managerPublicKeyOrUnit () = match getString(mpk()) {
592 645      case s: String => 
593 646          fromBase58String(s)
594 647      case _: Unit => 
595 648          unit
596 649      case _ => 
597 650          throw("Match error")
598 651  }
599 652  
600 653  
601 654  func pendingManagerPublicKeyOrUnit () = match getString(pmpk()) {
602 655      case s: String => 
603 656          fromBase58String(s)
604 657      case _: Unit => 
605 658          unit
606 659      case _ => 
607 660          throw("Match error")
608 661  }
609 662  
610 663  
611 664  func isManager (i) = match managerPublicKeyOrUnit() {
612 665      case pk: ByteVector => 
613 666          (i.callerPublicKey == pk)
614 667      case _: Unit => 
615 668          (i.caller == this)
616 669      case _ => 
617 670          throw("Match error")
618 671  }
619 672  
620 673  
621 674  func mustManager (i) = {
622 675      let pd = throw("Permission denied")
623 676      match managerPublicKeyOrUnit() {
624 677          case pk: ByteVector => 
625 678              if ((i.callerPublicKey == pk))
626 679                  then true
627 680                  else pd
628 681          case _: Unit => 
629 682              if ((i.caller == this))
630 683                  then true
631 684                  else pd
632 685          case _ => 
633 686              throw("Match error")
634 687      }
635 688      }
636 689  
637 690  
638 691  @Callable(i)
639 692  func setManager (pendingManagerPublicKey) = {
640 693      let checkCaller = mustManager(i)
641 694      if ((checkCaller == checkCaller))
642 695          then {
643 696              let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
644 697              if ((checkManagerPublicKey == checkManagerPublicKey))
645 698                  then [StringEntry(pmpk(), pendingManagerPublicKey)]
646 699                  else throw("Strict value is not equal to itself.")
647 700              }
648 701          else throw("Strict value is not equal to itself.")
649 702      }
650 703  
651 704  
652 705  
653 706  @Callable(i)
654 707  func confirmManager () = {
655 708      let pm = pendingManagerPublicKeyOrUnit()
656 709      let hasPM = if (isDefined(pm))
657 710          then true
658 711          else throw("No pending manager")
659 712      if ((hasPM == hasPM))
660 713          then {
661 714              let checkPM = if ((i.callerPublicKey == value(pm)))
662 715                  then true
663 716                  else throw("You are not pending manager")
664 717              if ((checkPM == checkPM))
665 718                  then [StringEntry(mpk(), toBase58String(value(pm))), DeleteEntry(pmpk())]
666 719                  else throw("Strict value is not equal to itself.")
667 720              }
668 721          else throw("Strict value is not equal to itself.")
669 722      }
670 723  
671 724  
672 725  
673 726  @Callable(i)
674 727  func put (slippageTolerance,shouldAutoStake) = if ((0 > slippageTolerance))
675 728      then throw("Invalid slippageTolerance passed")
676 729      else {
677 730          let estPut = commonPut(i, slippageTolerance, true)
678 731          let emitLpAmt = estPut._2
679 732          let lpAssetId = estPut._7
680 733          let state = estPut._9
681 734          let amDiff = estPut._10
682 735          let prDiff = estPut._11
683 736          let amId = estPut._12
684 737          let prId = estPut._13
685 -         let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
686 -         if ((emitInv == emitInv))
738 +         let amAssetPmt = toBigInt(value(i.payments[0]).amount)
739 +         let prAssetPmt = toBigInt(value(i.payments[1]).amount)
740 +         let currentKLp = calcCurrentKLp(amAssetPmt, prAssetPmt, toBigInt(0))
741 +         if ((currentKLp == currentKLp))
687 742              then {
688 -                 let emitInvLegacy =                 match emitInv {
689 -                     case legacyFactoryContract: Address => 
690 -                         invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
691 -                     case _ => 
692 -                         unit
693 -                 }
694 -                 if ((emitInvLegacy == emitInvLegacy))
743 +                 let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
744 +                 if ((emitInv == emitInv))
695 745                      then {
696 -                         let slippageAInv = if ((amDiff > 0))
697 -                             then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
698 -                             else nil
699 -                         if ((slippageAInv == slippageAInv))
746 +                         let emitInvLegacy =                         match emitInv {
747 +                             case legacyFactoryContract: Address => 
748 +                                 invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
749 +                             case _ => 
750 +                                 unit
751 +                         }
752 +                         if ((emitInvLegacy == emitInvLegacy))
700 753                              then {
701 -                                 let slippagePInv = if ((prDiff > 0))
702 -                                     then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
754 +                                 let slippageAInv = if ((amDiff > 0))
755 +                                     then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
703 756                                      else nil
704 -                                 if ((slippagePInv == slippagePInv))
757 +                                 if ((slippageAInv == slippageAInv))
705 758                                      then {
706 -                                         let lpTransfer = if (shouldAutoStake)
759 +                                         let slippagePInv = if ((prDiff > 0))
760 +                                             then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
761 +                                             else nil
762 +                                         if ((slippagePInv == slippagePInv))
707 763                                              then {
708 -                                                 let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
709 -                                                 if ((slpStakeInv == slpStakeInv))
710 -                                                     then nil
764 +                                                 let lpTransfer = if (shouldAutoStake)
765 +                                                     then {
766 +                                                         let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
767 +                                                         if ((slpStakeInv == slpStakeInv))
768 +                                                             then nil
769 +                                                             else throw("Strict value is not equal to itself.")
770 +                                                         }
771 +                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
772 +                                                 let $t03429834760 = refreshKLpInternal(0, 0, 0)
773 +                                                 if (($t03429834760 == $t03429834760))
774 +                                                     then {
775 +                                                         let updatedKLp = $t03429834760._2
776 +                                                         let refreshKLpActions = $t03429834760._1
777 +                                                         let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
778 +                                                         if ((isUpdatedKLpValid == isUpdatedKLpValid))
779 +                                                             then ((state ++ lpTransfer) ++ refreshKLpActions)
780 +                                                             else throw("Strict value is not equal to itself.")
781 +                                                         }
711 782                                                      else throw("Strict value is not equal to itself.")
712 783                                                  }
713 -                                             else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
714 -                                         (state ++ lpTransfer)
784 +                                             else throw("Strict value is not equal to itself.")
715 785                                          }
716 786                                      else throw("Strict value is not equal to itself.")
717 787                                  }
718 788                              else throw("Strict value is not equal to itself.")
719 789                          }
720 790                      else throw("Strict value is not equal to itself.")
721 791                  }
722 792              else throw("Strict value is not equal to itself.")
723 793          }
724 794  
725 795  
726 796  
727 797  @Callable(i)
728 798  func putForFree (maxSlippage) = if ((0 > maxSlippage))
729 799      then throw("Invalid value passed")
730 800      else {
731 801          let estPut = commonPut(i, maxSlippage, false)
732 -         estPut._9
802 +         let state = estPut._9
803 +         let amAssetPmt = toBigInt(value(i.payments[0]).amount)
804 +         let prAssetPmt = toBigInt(value(i.payments[1]).amount)
805 +         let currentKLp = calcCurrentKLp(amAssetPmt, prAssetPmt, toBigInt(0))
806 +         if ((currentKLp == currentKLp))
807 +             then {
808 +                 let $t03532235387 = refreshKLpInternal(0, 0, 0)
809 +                 let refreshKLpActions = $t03532235387._1
810 +                 let updatedKLp = $t03532235387._2
811 +                 let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
812 +                 if ((isUpdatedKLpValid == isUpdatedKLpValid))
813 +                     then (state ++ refreshKLpActions)
814 +                     else throw("Strict value is not equal to itself.")
815 +                 }
816 +             else throw("Strict value is not equal to itself.")
733 817          }
734 818  
735 819  
736 820  
737 821  @Callable(i)
738 822  func putOneTkn (minOutAmount,autoStake) = {
739 823      let isPoolOneTokenOperationsDisabled = {
740 824          let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
741 825          if ($isInstanceOf(@, "Boolean"))
742 826              then @
743 827              else throw(($getType(@) + " couldn't be cast to Boolean"))
744 828          }
745 829      let isPutDisabled = if (if (if (isGlobalShutdown())
746 830          then true
747 831          else (cfgPoolStatus == PoolPutDisabled))
748 832          then true
749 833          else (cfgPoolStatus == PoolShutdown))
750 834          then true
751 835          else isPoolOneTokenOperationsDisabled
752 836      let checks = [if (if (!(isPutDisabled))
753 837          then true
754 838          else isManager(i))
755 839          then true
756 840          else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
757 841          then true
758 842          else throwErr("exactly 1 payment are expected")]
759 843      if ((checks == checks))
760 844          then {
761 845              let payment = i.payments[0]
762 846              let paymentAssetId = payment.assetId
763 847              let paymentAmountRaw = payment.amount
764 -             let userAddress = i.caller
765 -             let txId = i.transactionId
766 -             let $t03172331853 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
767 -             if (($t03172331853 == $t03172331853))
848 +             let currentKLp = if ((paymentAssetId == cfgAmountAssetId))
849 +                 then calcCurrentKLp(toBigInt(paymentAmountRaw), toBigInt(0), toBigInt(0))
850 +                 else if ((paymentAssetId == cfgPriceAssetId))
851 +                     then calcCurrentKLp(toBigInt(0), toBigInt(paymentAmountRaw), toBigInt(0))
852 +                     else throwErr("payment asset is not supported")
853 +             if ((currentKLp == currentKLp))
768 854                  then {
769 -                     let bonus = $t03172331853._4
770 -                     let feeAmount = $t03172331853._3
771 -                     let commonState = $t03172331853._2
772 -                     let emitAmountEstimated = $t03172331853._1
773 -                     let emitAmount = if (if ((minOutAmount > 0))
774 -                         then (minOutAmount > emitAmountEstimated)
775 -                         else false)
776 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
777 -                         else emitAmountEstimated
778 -                     let emitInv = emit(emitAmount)
779 -                     if ((emitInv == emitInv))
855 +                     let userAddress = i.caller
856 +                     let txId = i.transactionId
857 +                     let $t03657536727 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
858 +                     if (($t03657536727 == $t03657536727))
780 859                          then {
781 -                             let lpTransfer = if (autoStake)
860 +                             let paymentInAmountAsset = $t03657536727._5
861 +                             let bonus = $t03657536727._4
862 +                             let feeAmount = $t03657536727._3
863 +                             let commonState = $t03657536727._2
864 +                             let emitAmountEstimated = $t03657536727._1
865 +                             let emitAmount = if (if ((minOutAmount > 0))
866 +                                 then (minOutAmount > emitAmountEstimated)
867 +                                 else false)
868 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
869 +                                 else emitAmountEstimated
870 +                             let emitInv = emit(emitAmount)
871 +                             if ((emitInv == emitInv))
782 872                                  then {
783 -                                     let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(cfgLpAssetId, emitAmount)])
784 -                                     if ((stakeInv == stakeInv))
785 -                                         then nil
873 +                                     let lpTransfer = if (autoStake)
874 +                                         then {
875 +                                             let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(cfgLpAssetId, emitAmount)])
876 +                                             if ((stakeInv == stakeInv))
877 +                                                 then nil
878 +                                                 else throw("Strict value is not equal to itself.")
879 +                                             }
880 +                                         else [ScriptTransfer(i.caller, emitAmount, cfgLpAssetId)]
881 +                                     let sendFee = if ((feeAmount > 0))
882 +                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, paymentAssetId)]
883 +                                         else nil
884 +                                     let $t03731337510 = if ((this == feeCollectorAddress))
885 +                                         then $Tuple2(0, 0)
886 +                                         else if (paymentInAmountAsset)
887 +                                             then $Tuple2(-(feeAmount), 0)
888 +                                             else $Tuple2(0, -(feeAmount))
889 +                                     let amountAssetBalanceDelta = $t03731337510._1
890 +                                     let priceAssetBalanceDelta = $t03731337510._2
891 +                                     let $t03751337621 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
892 +                                     let refreshKLpActions = $t03751337621._1
893 +                                     let updatedKLp = $t03751337621._2
894 +                                     let kLp = value(getString(keyKLp))
895 +                                     let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
896 +                                     if ((isUpdatedKLpValid == isUpdatedKLpValid))
897 +                                         then $Tuple2((((commonState ++ lpTransfer) ++ sendFee) ++ refreshKLpActions), emitAmount)
786 898                                          else throw("Strict value is not equal to itself.")
787 899                                      }
788 -                                 else [ScriptTransfer(i.caller, emitAmount, cfgLpAssetId)]
789 -                             let sendFee = if ((feeAmount > 0))
790 -                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, paymentAssetId)]
791 -                                 else nil
792 -                             $Tuple2(((commonState ++ lpTransfer) ++ sendFee), emitAmount)
900 +                                 else throw("Strict value is not equal to itself.")
793 901                              }
794 902                          else throw("Strict value is not equal to itself.")
795 903                      }
796 904                  else throw("Strict value is not equal to itself.")
797 905              }
798 906          else throw("Strict value is not equal to itself.")
799 907      }
800 908  
801 909  
802 910  
803 911  @Callable(i)
804 912  func putOneTknREADONLY (paymentAssetId,paymentAmountRaw) = {
805 -     let $t03258232717 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
806 -     let emitAmountEstimated = $t03258232717._1
807 -     let commonState = $t03258232717._2
808 -     let feeAmount = $t03258232717._3
809 -     let bonus = $t03258232717._4
913 +     let $t03792738084 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
914 +     let emitAmountEstimated = $t03792738084._1
915 +     let commonState = $t03792738084._2
916 +     let feeAmount = $t03792738084._3
917 +     let bonus = $t03792738084._4
918 +     let paymentInAmountAsset = $t03792738084._5
810 919      $Tuple2(nil, $Tuple3(emitAmountEstimated, feeAmount, bonus))
811 920      }
812 921  
813 922  
814 923  
815 924  @Callable(i)
816 925  func getOneTkn (outAssetIdStr,minOutAmount) = {
817 926      let isPoolOneTokenOperationsDisabled = {
818 927          let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
819 928          if ($isInstanceOf(@, "Boolean"))
820 929              then @
821 930              else throw(($getType(@) + " couldn't be cast to Boolean"))
822 931          }
823 932      let isGetDisabled = if (if (isGlobalShutdown())
824 933          then true
825 934          else (cfgPoolStatus == PoolShutdown))
826 935          then true
827 936          else isPoolOneTokenOperationsDisabled
828 937      let checks = [if (if (!(isGetDisabled))
829 938          then true
830 939          else isManager(i))
831 940          then true
832 941          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
833 942          then true
834 943          else throwErr("exactly 1 payment are expected")]
835 944      if ((checks == checks))
836 945          then {
837 946              let outAssetId = parseAssetId(outAssetIdStr)
838 947              let payment = i.payments[0]
839 948              let paymentAssetId = payment.assetId
840 949              let paymentAmount = payment.amount
841 -             let userAddress = i.caller
842 -             let txId = i.transactionId
843 -             let $t03352233657 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
844 -             if (($t03352233657 == $t03352233657))
950 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
951 +             if ((currentKLp == currentKLp))
845 952                  then {
846 -                     let bonus = $t03352233657._4
847 -                     let feeAmount = $t03352233657._3
848 -                     let commonState = $t03352233657._2
849 -                     let amountEstimated = $t03352233657._1
850 -                     let amount = if (if ((minOutAmount > 0))
851 -                         then (minOutAmount > amountEstimated)
852 -                         else false)
853 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
854 -                         else amountEstimated
855 -                     let burnInv = invoke(factoryContract, "burn", [paymentAmount], [AttachedPayment(paymentAssetId, paymentAmount)])
856 -                     if ((burnInv == burnInv))
953 +                     let userAddress = i.caller
954 +                     let txId = i.transactionId
955 +                     let $t03896939122 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
956 +                     if (($t03896939122 == $t03896939122))
857 957                          then {
858 -                             let assetTransfer = [ScriptTransfer(userAddress, amount, outAssetId)]
859 -                             let sendFee = if ((feeAmount > 0))
860 -                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
861 -                                 else nil
862 -                             $Tuple2(((commonState ++ assetTransfer) ++ sendFee), amount)
958 +                             let outInAmountAsset = $t03896939122._5
959 +                             let bonus = $t03896939122._4
960 +                             let feeAmount = $t03896939122._3
961 +                             let commonState = $t03896939122._2
962 +                             let amountEstimated = $t03896939122._1
963 +                             let amount = if (if ((minOutAmount > 0))
964 +                                 then (minOutAmount > amountEstimated)
965 +                                 else false)
966 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
967 +                                 else amountEstimated
968 +                             let burnInv = invoke(factoryContract, "burn", [paymentAmount], [AttachedPayment(paymentAssetId, paymentAmount)])
969 +                             if ((burnInv == burnInv))
970 +                                 then {
971 +                                     let assetTransfer = [ScriptTransfer(userAddress, amount, outAssetId)]
972 +                                     let sendFee = if ((feeAmount > 0))
973 +                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
974 +                                         else nil
975 +                                     let $t03962239869 = {
976 +                                         let feeAmountForCalc = if ((this == feeCollectorAddress))
977 +                                             then 0
978 +                                             else feeAmount
979 +                                         if (outInAmountAsset)
980 +                                             then $Tuple2(-((amount + feeAmountForCalc)), 0)
981 +                                             else $Tuple2(0, -((amount + feeAmountForCalc)))
982 +                                         }
983 +                                     let amountAssetBalanceDelta = $t03962239869._1
984 +                                     let priceAssetBalanceDelta = $t03962239869._2
985 +                                     let $t03987239980 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
986 +                                     let refreshKLpActions = $t03987239980._1
987 +                                     let updatedKLp = $t03987239980._2
988 +                                     let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
989 +                                     if ((isUpdatedKLpValid == isUpdatedKLpValid))
990 +                                         then $Tuple2((((commonState ++ assetTransfer) ++ sendFee) ++ refreshKLpActions), amount)
991 +                                         else throw("Strict value is not equal to itself.")
992 +                                     }
993 +                                 else throw("Strict value is not equal to itself.")
863 994                              }
864 995                          else throw("Strict value is not equal to itself.")
865 996                      }
866 997                  else throw("Strict value is not equal to itself.")
867 998              }
868 999          else throw("Strict value is not equal to itself.")
869 1000      }
870 1001  
871 1002  
872 1003  
873 1004  @Callable(i)
874 1005  func getOneTknREADONLY (outAssetId,paymentAmount) = {
875 -     let $t03429234430 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
876 -     let amountEstimated = $t03429234430._1
877 -     let commonState = $t03429234430._2
878 -     let feeAmount = $t03429234430._3
879 -     let bonus = $t03429234430._4
1006 +     let $t04023740393 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
1007 +     let amountEstimated = $t04023740393._1
1008 +     let commonState = $t04023740393._2
1009 +     let feeAmount = $t04023740393._3
1010 +     let bonus = $t04023740393._4
1011 +     let outInAmountAsset = $t04023740393._5
880 1012      $Tuple2(nil, $Tuple3(amountEstimated, feeAmount, bonus))
881 1013      }
882 1014  
883 1015  
884 1016  
885 1017  @Callable(i)
886 1018  func unstakeAndGetOneTkn (unstakeAmount,outAssetIdStr,minOutAmount) = {
887 1019      let isPoolOneTokenOperationsDisabled = {
888 1020          let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
889 1021          if ($isInstanceOf(@, "Boolean"))
890 1022              then @
891 1023              else throw(($getType(@) + " couldn't be cast to Boolean"))
892 1024          }
893 1025      let isGetDisabled = if (if (isGlobalShutdown())
894 1026          then true
895 1027          else (cfgPoolStatus == PoolShutdown))
896 1028          then true
897 1029          else isPoolOneTokenOperationsDisabled
898 1030      let checks = [if (if (!(isGetDisabled))
899 1031          then true
900 1032          else isManager(i))
901 1033          then true
902 1034          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 0))
903 1035          then true
904 1036          else throwErr("no payments are expected")]
905 1037      if ((checks == checks))
906 1038          then {
907 1039              let outAssetId = parseAssetId(outAssetIdStr)
908 1040              let userAddress = i.caller
909 1041              let txId = i.transactionId
910 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
911 -             if ((unstakeInv == unstakeInv))
1042 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1043 +             if ((currentKLp == currentKLp))
912 1044                  then {
913 -                     let $t03525535388 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
914 -                     if (($t03525535388 == $t03525535388))
1045 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1046 +                     if ((unstakeInv == unstakeInv))
915 1047                          then {
916 -                             let bonus = $t03525535388._4
917 -                             let feeAmount = $t03525535388._3
918 -                             let commonState = $t03525535388._2
919 -                             let amountEstimated = $t03525535388._1
920 -                             let amount = if (if ((minOutAmount > 0))
921 -                                 then (minOutAmount > amountEstimated)
922 -                                 else false)
923 -                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
924 -                                 else amountEstimated
925 -                             let burnInv = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
926 -                             if ((burnInv == burnInv))
1048 +                             let $t04129841449 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
1049 +                             if (($t04129841449 == $t04129841449))
927 1050                                  then {
928 -                                     let assetTransfer = [ScriptTransfer(i.caller, amount, outAssetId)]
929 -                                     let sendFee = if ((feeAmount > 0))
930 -                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
931 -                                         else nil
932 -                                     $Tuple2(((commonState ++ assetTransfer) ++ sendFee), amount)
1051 +                                     let outInAmountAsset = $t04129841449._5
1052 +                                     let bonus = $t04129841449._4
1053 +                                     let feeAmount = $t04129841449._3
1054 +                                     let commonState = $t04129841449._2
1055 +                                     let amountEstimated = $t04129841449._1
1056 +                                     let amount = if (if ((minOutAmount > 0))
1057 +                                         then (minOutAmount > amountEstimated)
1058 +                                         else false)
1059 +                                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
1060 +                                         else amountEstimated
1061 +                                     let burnInv = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1062 +                                     if ((burnInv == burnInv))
1063 +                                         then {
1064 +                                             let assetTransfer = [ScriptTransfer(i.caller, amount, outAssetId)]
1065 +                                             let sendFee = if ((feeAmount > 0))
1066 +                                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
1067 +                                                 else nil
1068 +                                             let $t04194442191 = {
1069 +                                                 let feeAmountForCalc = if ((this == feeCollectorAddress))
1070 +                                                     then 0
1071 +                                                     else feeAmount
1072 +                                                 if (outInAmountAsset)
1073 +                                                     then $Tuple2(-((amount + feeAmountForCalc)), 0)
1074 +                                                     else $Tuple2(0, -((amount + feeAmountForCalc)))
1075 +                                                 }
1076 +                                             let amountAssetBalanceDelta = $t04194442191._1
1077 +                                             let priceAssetBalanceDelta = $t04194442191._2
1078 +                                             let $t04219442302 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1079 +                                             let refreshKLpActions = $t04219442302._1
1080 +                                             let updatedKLp = $t04219442302._2
1081 +                                             let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1082 +                                             if ((isUpdatedKLpValid == isUpdatedKLpValid))
1083 +                                                 then $Tuple2((((commonState ++ assetTransfer) ++ sendFee) ++ refreshKLpActions), amount)
1084 +                                                 else throw("Strict value is not equal to itself.")
1085 +                                             }
1086 +                                         else throw("Strict value is not equal to itself.")
933 1087                                      }
934 1088                                  else throw("Strict value is not equal to itself.")
935 1089                              }
936 1090                          else throw("Strict value is not equal to itself.")
937 1091                      }
938 1092                  else throw("Strict value is not equal to itself.")
939 1093              }
940 1094          else throw("Strict value is not equal to itself.")
941 1095      }
942 1096  
943 1097  
944 1098  
945 1099  @Callable(i)
946 1100  func get () = {
947 1101      let res = commonGet(i)
948 1102      let outAmtAmt = res._1
949 1103      let outPrAmt = res._2
950 1104      let pmtAmt = res._3
951 1105      let pmtAssetId = res._4
952 1106      let state = res._5
953 -     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
954 -     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
955 -         then state
1107 +     let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1108 +     if ((currentKLp == currentKLp))
1109 +         then {
1110 +             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1111 +             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1112 +                 then {
1113 +                     let $t04324843330 = refreshKLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1114 +                     let refreshKLpActions = $t04324843330._1
1115 +                     let updatedKLp = $t04324843330._2
1116 +                     let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1117 +                     if ((isUpdatedKLpValid == isUpdatedKLpValid))
1118 +                         then (state ++ refreshKLpActions)
1119 +                         else throw("Strict value is not equal to itself.")
1120 +                     }
1121 +                 else throw("Strict value is not equal to itself.")
1122 +             }
956 1123          else throw("Strict value is not equal to itself.")
957 1124      }
958 1125  
959 1126  
960 1127  
961 1128  @Callable(i)
962 1129  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
963 1130      let res = commonGet(i)
964 1131      let outAmAmt = res._1
965 1132      let outPrAmt = res._2
966 1133      let pmtAmt = res._3
967 1134      let pmtAssetId = res._4
968 1135      let state = res._5
969 1136      if ((noLessThenAmtAsset > outAmAmt))
970 1137          then throw(((("noLessThenAmtAsset failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
971 1138          else if ((noLessThenPriceAsset > outPrAmt))
972 1139              then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
973 1140              else {
974 -                 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
975 -                 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
976 -                     then state
1141 +                 let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1142 +                 if ((currentKLp == currentKLp))
1143 +                     then {
1144 +                         let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1145 +                         if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1146 +                             then {
1147 +                                 let $t04427944360 = refreshKLpInternal(-(outAmAmt), -(outPrAmt), 0)
1148 +                                 let refreshKLpActions = $t04427944360._1
1149 +                                 let updatedKLp = $t04427944360._2
1150 +                                 let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1151 +                                 if ((isUpdatedKLpValid == isUpdatedKLpValid))
1152 +                                     then (state ++ refreshKLpActions)
1153 +                                     else throw("Strict value is not equal to itself.")
1154 +                                 }
1155 +                             else throw("Strict value is not equal to itself.")
1156 +                         }
977 1157                      else throw("Strict value is not equal to itself.")
978 1158                  }
979 1159      }
980 1160  
981 1161  
982 1162  
983 1163  @Callable(i)
984 1164  func unstakeAndGet (amount) = {
985 1165      let checkPayments = if ((size(i.payments) != 0))
986 1166          then throw("No payments are expected")
987 1167          else true
988 1168      if ((checkPayments == checkPayments))
989 1169          then {
990 1170              let cfg = getPoolConfig()
991 1171              let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
992 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
993 -             if ((unstakeInv == unstakeInv))
1172 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1173 +             if ((currentKLp == currentKLp))
994 1174                  then {
995 -                     let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
996 -                     let poolStatus = parseIntValue(res._9)
997 -                     let state = res._10
998 -                     let checkPoolStatus = if (if (isGlobalShutdown())
999 -                         then true
1000 -                         else (poolStatus == PoolShutdown))
1001 -                         then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
1002 -                         else true
1003 -                     if ((checkPoolStatus == checkPoolStatus))
1175 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
1176 +                     if ((unstakeInv == unstakeInv))
1004 1177                          then {
1005 -                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1006 -                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1007 -                                 then state
1178 +                             let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1179 +                             let outAmAmt = res._1
1180 +                             let outPrAmt = res._2
1181 +                             let poolStatus = parseIntValue(res._9)
1182 +                             let state = res._10
1183 +                             let checkPoolStatus = if (if (isGlobalShutdown())
1184 +                                 then true
1185 +                                 else (poolStatus == PoolShutdown))
1186 +                                 then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
1187 +                                 else true
1188 +                             if ((checkPoolStatus == checkPoolStatus))
1189 +                                 then {
1190 +                                     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1191 +                                     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1192 +                                         then {
1193 +                                             let $t04548645567 = refreshKLpInternal(-(outAmAmt), -(outPrAmt), 0)
1194 +                                             let refreshKLpActions = $t04548645567._1
1195 +                                             let updatedKLp = $t04548645567._2
1196 +                                             let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1197 +                                             if ((isUpdatedKLpValid == isUpdatedKLpValid))
1198 +                                                 then (state ++ refreshKLpActions)
1199 +                                                 else throw("Strict value is not equal to itself.")
1200 +                                             }
1201 +                                         else throw("Strict value is not equal to itself.")
1202 +                                     }
1008 1203                                  else throw("Strict value is not equal to itself.")
1009 1204                              }
1010 1205                          else throw("Strict value is not equal to itself.")
1011 1206                      }
1012 1207                  else throw("Strict value is not equal to itself.")
1013 1208              }
1014 1209          else throw("Strict value is not equal to itself.")
1015 1210      }
1016 1211  
1017 1212  
1018 1213  
1019 1214  @Callable(i)
1020 1215  func unstakeAndGetNoLess (unstakeAmount,noLessThenAmountAsset,noLessThenPriceAsset) = {
1021 1216      let isGetDisabled = if (isGlobalShutdown())
1022 1217          then true
1023 1218          else (cfgPoolStatus == PoolShutdown)
1024 1219      let checks = [if (!(isGetDisabled))
1025 1220          then true
1026 1221          else throw("get operation is blocked by admin"), if ((size(i.payments) == 0))
1027 1222          then true
1028 1223          else throw("no payments are expected")]
1029 1224      if ((checks == checks))
1030 1225          then {
1031 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1032 -             if ((unstakeInv == unstakeInv))
1226 +             let currentKLp = calcCurrentKLp(toBigInt(0), toBigInt(0), toBigInt(0))
1227 +             if ((currentKLp == currentKLp))
1033 1228                  then {
1034 -                     let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1035 -                     let outAmAmt = res._1
1036 -                     let outPrAmt = res._2
1037 -                     let state = res._10
1038 -                     let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1039 -                         then true
1040 -                         else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1041 -                         then true
1042 -                         else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1043 -                     if ((checkAmounts == checkAmounts))
1229 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1230 +                     if ((unstakeInv == unstakeInv))
1044 1231                          then {
1045 -                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1046 -                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1047 -                                 then state
1232 +                             let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1233 +                             let outAmAmt = res._1
1234 +                             let outPrAmt = res._2
1235 +                             let state = res._10
1236 +                             let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1237 +                                 then true
1238 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1239 +                                 then true
1240 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1241 +                             if ((checkAmounts == checkAmounts))
1242 +                                 then {
1243 +                                     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1244 +                                     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1245 +                                         then {
1246 +                                             let $t04686246943 = refreshKLpInternal(-(outAmAmt), -(outPrAmt), 0)
1247 +                                             let refreshKLpActions = $t04686246943._1
1248 +                                             let updatedKLp = $t04686246943._2
1249 +                                             let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
1250 +                                             if ((isUpdatedKLpValid == isUpdatedKLpValid))
1251 +                                                 then (state ++ refreshKLpActions)
1252 +                                                 else throw("Strict value is not equal to itself.")
1253 +                                             }
1254 +                                         else throw("Strict value is not equal to itself.")
1255 +                                     }
1048 1256                                  else throw("Strict value is not equal to itself.")
1049 1257                              }
1050 1258                          else throw("Strict value is not equal to itself.")
1051 1259                      }
1052 1260                  else throw("Strict value is not equal to itself.")
1053 1261              }
1054 1262          else throw("Strict value is not equal to itself.")
1055 1263      }
1056 1264  
1057 1265  
1058 1266  
1059 1267  @Callable(i)
1060 1268  func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
1061 1269      then throw("permissions denied")
1062 1270      else $Tuple2([StringEntry(aa(), amtAssetStr), StringEntry(pa(), priceAssetStr)], "success")
1271 + 
1272 + 
1273 + 
1274 + @Callable(i)
1275 + func refreshKLp () = {
1276 +     let lastRefreshedBlockHeight = valueOrElse(getInteger(keyKLpRefreshedHeight), 0)
1277 +     let checkLastRefreshedBlockHeight = if (((height - lastRefreshedBlockHeight) >= kLpRefreshDelay))
1278 +         then unit
1279 +         else throwErr(makeString([toString(kLpRefreshDelay), " blocks have not passed since the previous call"], ""))
1280 +     if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1281 +         then {
1282 +             let kLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyKLp), "0")), fmtErr("invalid kLp"))
1283 +             let $t04813048194 = refreshKLpInternal(0, 0, 0)
1284 +             let kLpUpdateActions = $t04813048194._1
1285 +             let updatedKLp = $t04813048194._2
1286 +             let actions = if ((kLp != updatedKLp))
1287 +                 then kLpUpdateActions
1288 +                 else throwErr("nothing to refresh")
1289 +             $Tuple2(actions, toString(updatedKLp))
1290 +             }
1291 +         else throw("Strict value is not equal to itself.")
1292 +     }
1063 1293  
1064 1294  
1065 1295  
1066 1296  @Callable(i)
1067 1297  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
1068 1298  
1069 1299  
1070 1300  
1071 1301  @Callable(i)
1072 1302  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
1073 1303  
1074 1304  
1075 1305  
1076 1306  @Callable(i)
1077 1307  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
1078 1308      let prices = calcPrices(amAmt, prAmt, lpAmt)
1079 1309      $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
1080 1310      }
1081 1311  
1082 1312  
1083 1313  
1084 1314  @Callable(i)
1085 1315  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
1086 1316  
1087 1317  
1088 1318  
1089 1319  @Callable(i)
1090 1320  func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
1091 1321  
1092 1322  
1093 1323  
1094 1324  @Callable(i)
1095 1325  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
1096 1326  
1097 1327  
1098 1328  
1099 1329  @Callable(i)
1100 1330  func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp))
1101 1331  
1102 1332  
1103 1333  
1104 1334  @Callable(i)
1105 1335  func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
1106 1336      let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
1107 1337      $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
1108 1338      }
1109 1339  
1110 1340  
1111 1341  
1112 1342  @Callable(i)
1113 1343  func statsREADONLY () = {
1114 1344      let cfg = getPoolConfig()
1115 1345      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
1116 1346      let amtAssetId = cfg[idxAmtAssetId]
1117 1347      let priceAssetId = cfg[idxPriceAssetId]
1118 1348      let iAmtAssetId = cfg[idxIAmtAssetId]
1119 1349      let iPriceAssetId = cfg[idxIPriceAssetId]
1120 1350      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
1121 1351      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
1122 1352      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
1123 1353      let accAmtAssetBalance = getAccBalance(amtAssetId)
1124 1354      let accPriceAssetBalance = getAccBalance(priceAssetId)
1125 1355      let pricesList = if ((poolLPBalance == 0))
1126 1356          then [zeroBigInt, zeroBigInt, zeroBigInt]
1127 1357          else calcPrices(accAmtAssetBalance, accPriceAssetBalance, poolLPBalance)
1128 1358      let curPrice = 0
1129 1359      let lpAmtAssetShare = fromX18(pricesList[1], scale8)
1130 1360      let lpPriceAssetShare = fromX18(pricesList[2], scale8)
1131 1361      let poolWeight = value(getInteger(factoryContract, keyPoolWeight(toString(this))))
1132 1362      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
1133 1363      }
1134 1364  
1135 1365  
1136 1366  
1137 1367  @Callable(i)
1138 1368  func evaluatePutByAmountAssetREADONLY (inAmAssetAmt) = {
1139 1369      let cfg = getPoolConfig()
1140 1370      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
1141 1371      let amAssetIdStr = cfg[idxAmtAssetId]
1142 1372      let amAssetId = fromBase58String(amAssetIdStr)
1143 1373      let prAssetIdStr = cfg[idxPriceAssetId]
1144 1374      let prAssetId = fromBase58String(prAssetIdStr)
1145 1375      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
1146 1376      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
1147 1377      let poolStatus = cfg[idxPoolStatus]
1148 1378      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
1149 1379      let accAmtAssetBalance = getAccBalance(amAssetIdStr)
1150 1380      let accPriceAssetBalance = getAccBalance(prAssetIdStr)
1151 1381      let amtAssetAmtX18 = toX18(accAmtAssetBalance, amtAssetDcm)
1152 1382      let priceAssetAmtX18 = toX18(accPriceAssetBalance, priceAssetDcm)
1153 1383      let curPriceX18 = if ((poolLPBalance == 0))
1154 1384          then zeroBigInt
1155 1385          else calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
1156 1386      let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
1157 1387      let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
1158 1388      let inPrAssetAmt = fromX18(inPrAssetAmtX18, priceAssetDcm)
1159 1389      let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
1160 1390      let calcLpAmt = estPut._1
1161 1391      let curPriceCalc = estPut._3
1162 1392      let amBalance = estPut._4
1163 1393      let prBalance = estPut._5
1164 1394      let lpEmission = estPut._6
1165 1395      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
1166 1396      }
1167 1397  
1168 1398  
1169 1399  
1170 1400  @Callable(i)
1171 1401  func evaluatePutByPriceAssetREADONLY (inPrAssetAmt) = {
1172 1402      let cfg = getPoolConfig()
1173 1403      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
1174 1404      let amAssetIdStr = cfg[idxAmtAssetId]
1175 1405      let amAssetId = fromBase58String(amAssetIdStr)
1176 1406      let prAssetIdStr = cfg[idxPriceAssetId]
1177 1407      let prAssetId = fromBase58String(prAssetIdStr)
1178 1408      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
1179 1409      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
1180 1410      let poolStatus = cfg[idxPoolStatus]
1181 1411      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
1182 1412      let amBalanceRaw = getAccBalance(amAssetIdStr)
1183 1413      let prBalanceRaw = getAccBalance(prAssetIdStr)
1184 1414      let amBalanceRawX18 = toX18(amBalanceRaw, amtAssetDcm)
1185 1415      let prBalanceRawX18 = toX18(prBalanceRaw, priceAssetDcm)
1186 1416      let curPriceX18 = if ((poolLPBalance == 0))
1187 1417          then zeroBigInt
1188 1418          else calcPriceBigInt(prBalanceRawX18, amBalanceRawX18)
1189 1419      let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
1190 1420      let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
1191 1421      let inAmAssetAmt = fromX18(inAmAssetAmtX18, amtAssetDcm)
1192 1422      let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
1193 1423      let calcLpAmt = estPut._1
1194 1424      let curPriceCalc = estPut._3
1195 1425      let amBalance = estPut._4
1196 1426      let prBalance = estPut._5
1197 1427      let lpEmission = estPut._6
1198 1428      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
1199 1429      }
1200 1430  
1201 1431  
1202 1432  
1203 1433  @Callable(i)
1204 1434  func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
1205 1435      let res = estimateGetOperation("", paymentLpAssetId, paymentLpAmt, this)
1206 1436      let outAmAmt = res._1
1207 1437      let outPrAmt = res._2
1208 1438      let amBalance = res._5
1209 1439      let prBalance = res._6
1210 1440      let lpEmission = res._7
1211 1441      let curPrice = res._8
1212 1442      let poolStatus = parseIntValue(res._9)
1213 1443      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), toString(curPrice), toString(poolStatus)], SEP))
1214 1444      }
1215 1445  
1216 1446  
1217 1447  @Verifier(tx)
1218 1448  func verify () = {
1219 1449      let targetPublicKey =     match managerPublicKeyOrUnit() {
1220 1450          case pk: ByteVector => 
1221 1451              pk
1222 1452          case _: Unit => 
1223 1453              tx.senderPublicKey
1224 1454          case _ => 
1225 1455              throw("Match error")
1226 1456      }
1227 1457      match tx {
1228 1458          case order: Order => 
1229 1459              let matcherPub = getMatcherPubOrFail()
1230 -             let orderValid = validateMatcherOrderAllowed(order)
1460 +             let $t05685656925 = validateMatcherOrderAllowed(order)
1461 +             let orderValid = $t05685656925._1
1462 +             let orderValidInfo = $t05685656925._2
1231 1463              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1232 1464              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1233 1465              if (if (if (orderValid)
1234 1466                  then senderValid
1235 1467                  else false)
1236 1468                  then matcherValid
1237 1469                  else false)
1238 1470                  then true
1239 -                 else throwOrderError(orderValid, senderValid, matcherValid)
1471 +                 else throwOrderError(orderValid, orderValidInfo, senderValid, matcherValid)
1240 1472          case s: SetScriptTransaction => 
1241 1473              let newHash = blake2b256(value(s.script))
1242 1474              let allowedHash = fromBase64String(value(getString(factoryContract, keyAllowedLpScriptHash())))
1243 1475              let currentHash = scriptHash(this)
1244 1476              if (if ((allowedHash == newHash))
1245 1477                  then (currentHash != newHash)
1246 1478                  else false)
1247 1479                  then true
1248 1480                  else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1249 1481          case _ => 
1250 1482              sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1251 1483      }
1252 1484      }
1253 1485

Old	New		Differences
62	62		func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
63	63
64	64
	65	+	func toX18BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
	66	+
	67	+
65	68		func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
	69	+
	70	+
	71	+	func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
66	72
67	73
68	74		func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)

105	111		func pa () = "%s__priceAsset"
106	112
107	113
	114	+	let keyFee = "%s__fee"
	115	+
	116	+	let feeDefault = fraction(10, scale8, 10000)
	117	+
	118	+	let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
	119	+
	120	+	let keyKLp = makeString(["%s", "kLp"], SEP)
	121	+
	122	+	let keyKLpRefreshedHeight = makeString(["%s", "kLpRefreshedHeight"], SEP)
	123	+
	124	+	let keyKLpRefreshDelay = makeString(["%s", "refreshKLpDelay"], SEP)
	125	+
	126	+	let kLpRefreshDelayDefault = 30
	127	+
	128	+	let kLpRefreshDelay = valueOrElse(getInteger(this, keyKLpRefreshDelay), kLpRefreshDelayDefault)
	129	+
108	130		func keyFactoryConfig () = "%s__factoryConfig"
109	131
110	132

131	153
132	154		let keyFeeCollectorAddress = "%s__feeCollectorAddress"
133	155
134		-	func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
	156	+	func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
135	157
136	158
137	159		func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))

141	163
142	164
143	165		func throwErr (msg) = throw(makeString(["lp.ride:", msg], " "))
	166	+
	167	+
	168	+	func fmtErr (msg) = makeString(["lp.ride:", msg], " ")
144	169
145	170
146	171		let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))

191	216
192	217		let poolConfigParsed = parsePoolConfig(getPoolConfig())
193	218
194		-	let $~~t076017767~~ = poolConfigParsed
	219	+	let $t084088574 = poolConfigParsed
195	220
196		-	let cfgPoolAddress = $~~t076017767~~._1
	221	+	let cfgPoolAddress = $t084088574._1
197	222
198		-	let cfgPoolStatus = $~~t076017767~~._2
	223	+	let cfgPoolStatus = $t084088574._2
199	224
200		-	let cfgLpAssetId = $~~t076017767~~._3
	225	+	let cfgLpAssetId = $t084088574._3
201	226
202		-	let cfgAmountAssetId = $~~t076017767~~._4
	227	+	let cfgAmountAssetId = $t084088574._4
203	228
204		-	let cfgPriceAssetId = $~~t076017767~~._5
	229	+	let cfgPriceAssetId = $t084088574._5
205	230
206		-	let cfgAmountAssetDecimals = $~~t076017767~~._6
	231	+	let cfgAmountAssetDecimals = $t084088574._6
207	232
208		-	let cfgPriceAssetDecimals = $~~t076017767~~._7
	233	+	let cfgPriceAssetDecimals = $t084088574._7
209	234
210	235		func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
211	236

226	251
227	252
228	253		func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
	254	+
	255	+
	256	+	func calcPriceBigIntRound (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
229	257
230	258
231	259		func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {

277	305		let lpEmissionX18 = toX18(lpEmission, scale8)
278	306		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
279	307		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
280		-	let outAmAmt = ~~fromX18~~(outAmAmtX18, amAssetDcm)
281		-	let outPrAmt = ~~fromX18~~(outPrAmtX18, prAssetDcm)
	308	+	let outAmAmt = fromX18Round(outAmAmtX18, amAssetDcm, FLOOR)
	309	+	let outPrAmt = fromX18Round(outPrAmtX18, prAssetDcm, FLOOR)
282	310		let state = if ((txId58 == ""))
283	311		then nil
284	312		else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))

337	365		then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
338	366		else {
339	367		let lpEmissionX18 = toX18(lpEmission, scale8)
340		-	let prViaAmX18 = fraction(inAmAssetAmtX18, ~~curPriceX18~~, scale18)
341		-	let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, ~~curPriceX18~~)
	368	+	let prViaAmX18 = fraction(inAmAssetAmtX18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
	369	+	let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, FLOOR), CEILING)
342	370		let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
343	371		then $Tuple2(amViaPrX18, inPrAssetAmtX18)
344	372		else $Tuple2(inAmAssetAmtX18, prViaAmX18)
345	373		let expAmtAssetAmtX18 = expectedAmts._1
346	374		let expPriceAssetAmtX18 = expectedAmts._2
347		-	let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
348		-	$Tuple5(~~fromX18~~(lpAmtX18, scale8), ~~fromX18~~(expAmtAssetAmtX18, amtAssetDcm), ~~fromX18~~(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
	375	+	let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18, FLOOR)
	376	+	$Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtAssetDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceAssetDcm, CEILING), curPriceX18, slippageX18)
349	377		}
350	378		}
351	379		let calcLpAmt = res._1

368	396		}
369	397
370	398
	399	+	func calcKLp (amountBalance,priceBalance,lpEmission) = {
	400	+	let amountBalanceX18 = toX18BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals))
	401	+	let priceBalanceX18 = toX18BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))
	402	+	let updatedKLp = fraction(pow((amountBalanceX18 * priceBalanceX18), 0, toBigInt(5), 1, 18, DOWN), big1, lpEmission)
	403	+	if ((lpEmission == big0))
	404	+	then big0
	405	+	else updatedKLp
	406	+	}
	407	+
	408	+
	409	+	func calcCurrentKLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
	410	+	let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
	411	+	let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
	412	+	let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
	413	+	let currentKLp = calcKLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
	414	+	currentKLp
	415	+	}
	416	+
	417	+
	418	+	func refreshKLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
	419	+	let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
	420	+	let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
	421	+	let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
	422	+	let updatedKLp = calcKLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
	423	+	let actions = [IntegerEntry(keyKLpRefreshedHeight, height), StringEntry(keyKLp, toString(updatedKLp))]
	424	+	$Tuple2(actions, updatedKLp)
	425	+	}
	426	+
	427	+
	428	+	func validateUpdatedKLp (oldKLp,updatedKLp) = if ((updatedKLp >= oldKLp))
	429	+	then true
	430	+	else throwErr(makeString(["updated KLp lower than current KLp", toString(oldKLp), toString(updatedKLp)], " "))
	431	+
	432	+
371	433		func validateMatcherOrderAllowed (order) = {
372		-	let cfg = getPoolConfig()
373		-	let amtAssetId = cfg[idxAmtAssetId]
374		-	let priceAssetId = cfg[idxPriceAssetId]
375		-	let poolStatus = parseIntValue(cfg[idxPoolStatus])
376		-	let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
377		-	let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
378		-	let accAmtAssetBalance = getAccBalance(amtAssetId)
379		-	let accPriceAssetBalance = getAccBalance(priceAssetId)
380		-	let curPriceX18 = if ((order.orderType == Buy))
381		-	then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
382		-	else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
383		-	let curPrice = fromX18(curPriceX18, scale8)
	434	+	let amountAssetAmount = order.amount
	435	+	let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
	436	+	let $t02132621538 = if ((order.orderType == Buy))
	437	+	then $Tuple2(amountAssetAmount, -(priceAssetAmount))
	438	+	else $Tuple2(-(amountAssetAmount), priceAssetAmount)
	439	+	let amountAssetBalanceDelta = $t02132621538._1
	440	+	let priceAssetBalanceDelta = $t02132621538._2
384	441		if (if (if (isGlobalShutdown())
385	442		then true
386		-	else (~~poolStatus~~ == PoolMatcherDisabled))
	443	+	else (cfgPoolStatus == PoolMatcherDisabled))
387	444		then true
388		-	else (~~poolStatus~~ == PoolShutdown))
	445	+	else (cfgPoolStatus == PoolShutdown))
389	446		then throw("Exchange operations disabled")
390		-	else {
391		-	let orderAmtAsset = order.assetPair.amountAsset
392		-	let orderAmtAssetStr = if ((orderAmtAsset == unit))
393		-	then "WAVES"
394		-	else toBase58String(value(orderAmtAsset))
395		-	let orderPriceAsset = order.assetPair.priceAsset
396		-	let orderPriceAssetStr = if ((orderPriceAsset == unit))
397		-	then "WAVES"
398		-	else toBase58String(value(orderPriceAsset))
399		-	if (if ((orderAmtAssetStr != amtAssetId))
400		-	then true
401		-	else (orderPriceAssetStr != priceAssetId))
402		-	then throw("Wrong order assets.")
403		-	else {
404		-	let orderPrice = order.price
405		-	let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
406		-	let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
407		-	let isOrderPriceValid = if ((order.orderType == Buy))
408		-	then (curPrice >= castedOrderPrice)
409		-	else (castedOrderPrice >= curPrice)
410		-	true
411		-	}
412		-	}
	447	+	else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
	448	+	then true
	449	+	else (order.assetPair.priceAsset != cfgPriceAssetId))
	450	+	then throw("Wrong order assets.")
	451	+	else {
	452	+	let kLp = valueOrErrorMessage(parseBigInt(valueOrErrorMessage(getString(this, keyKLp), fmtErr("kLp is required"))), fmtErr("invalid kLp"))
	453	+	let $t02200922109 = refreshKLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	454	+	let unusedActions = $t02200922109._1
	455	+	let kLpNew = $t02200922109._2
	456	+	let isOrderValid = (kLpNew >= kLp)
	457	+	let info = makeString([toString(kLp), toString(kLpNew)], " ")
	458	+	$Tuple2(isOrderValid, info)
	459	+	}
413	460		}
414	461
415	462

484	531		else if ((paymentAssetId == cfgPriceAssetId))
485	532		then false
486	533		else throwErr("invalid asset")
487		-	let $~~t02266422957~~ = if (isEval)
	534	+	let $t02491625209 = if (isEval)
488	535		then $Tuple2(amountBalanceRaw, priceBalanceRaw)
489	536		else if (paymentInAmountAsset)
490	537		then $Tuple2((amountBalanceRaw - paymentAmountRaw), priceBalanceRaw)
491	538		else $Tuple2(amountBalanceRaw, (priceBalanceRaw - paymentAmountRaw))
492		-	let amountBalanceOld = $~~t02266422957~~._1
493		-	let priceBalanceOld = $~~t02266422957~~._2
494		-	let $~~t02296123110~~ = if (paymentInAmountAsset)
	539	+	let amountBalanceOld = $t02491625209._1
	540	+	let priceBalanceOld = $t02491625209._2
	541	+	let $t02521325362 = if (paymentInAmountAsset)
495	542		then $Tuple2(paymentAmountRaw, 0)
496	543		else $Tuple2(0, paymentAmountRaw)
497		-	let amountAssetAmountRaw = $~~t02296123110~~._1
498		-	let priceAssetAmountRaw = $~~t02296123110~~._2
	544	+	let amountAssetAmountRaw = $t02521325362._1
	545	+	let priceAssetAmountRaw = $t02521325362._2
499	546		let amountAssetAmount = takeFee(amountAssetAmountRaw, inFee)._1
500	547		let priceAssetAmount = takeFee(priceAssetAmountRaw, inFee)._1
501		-	let $~~t02324223306~~ = takeFee(paymentAmountRaw, inFee)
502		-	let paymentAmount = $~~t02324223306~~._1
503		-	let feeAmount = $~~t02324223306~~._2
	548	+	let $t02549425558 = takeFee(paymentAmountRaw, inFee)
	549	+	let paymentAmount = $t02549425558._1
	550	+	let feeAmount = $t02549425558._2
504	551		let amountBalanceNew = (amountBalanceOld + amountAssetAmount)
505	552		let priceBalanceNew = (priceBalanceOld + priceAssetAmount)
506	553		let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, cfgPriceAssetDecimals), toX18(amountBalanceNew, cfgAmountAssetDecimals))

523	570		let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, cfgPriceAssetDecimals), toX18(amountBalanceOld, cfgAmountAssetDecimals))
524	571		let priceOld = fromX18(priceOldX18, scale8)
525	572		let loss = {
526		-	let $~~t02478324950~~ = if (paymentInAmountAsset)
	573	+	let $t02723927406 = if (paymentInAmountAsset)
527	574		then $Tuple2(amountAssetAmountRaw, amountBalanceOld)
528	575		else $Tuple2(priceAssetAmountRaw, priceBalanceOld)
529		-	let amount = $~~t02478324950~~._1
530		-	let balance = $~~t02478324950~~._2
	576	+	let amount = $t02723927406._1
	577	+	let balance = $t02723927406._2
531	578		let issueAmountBoth = toInt(fraction(supplyBigInt, toBigInt((amount / 2)), toBigInt(balance)))
532	579		fraction((issueAmount - issueAmountBoth), scale8, issueAmountBoth)
533	580		}
534		-	$~~Tuple4~~(issueAmount, commonState, feeAmount, loss)
	581	+	$Tuple5(issueAmount, commonState, feeAmount, loss, paymentInAmountAsset)
535	582		}
536	583		else throw("Strict value is not equal to itself.")
537	584		}

539	586
540	587		func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
541	588		let isEval = (txId == unit)
	589	+	let cfg = getPoolConfig()
	590	+	let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
	591	+	let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
542	592		let checks = [if ((paymentAssetId == cfgLpAssetId))
543	593		then true
544	594		else throwErr("invalid lp asset")]

552	602		let balanceBigInt = if (outInAmountAsset)
553	603		then toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId)))
554	604		else toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId)))
	605	+	let outInAmountAssetDecimals = if (outInAmountAsset)
	606	+	then amtAssetDcm
	607	+	else priceAssetDcm
555	608		let amBalanceOld = getAccBalance(assetIdToString(cfgAmountAssetId))
556	609		let prBalanceOld = getAccBalance(assetIdToString(cfgPriceAssetId))
557	610		let outBalance = if (outInAmountAsset)

561	614		let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
562	615		let redeemedBigInt = toBigInt(paymentAmount)
563	616		let amountRaw = max([0, toInt(((balanceBigInt * (scale18 - pow((scale18 - ((redeemedBigInt * scale18) / supplyBigInt)), 18, big2, 0, 18, DOWN))) / scale18))])
564		-	let $~~t02653026586~~ = takeFee(amountRaw, outFee)
565		-	let totalAmount = $~~t02653026586~~._1
566		-	let feeAmount = $~~t02653026586~~._2
567		-	let $~~t02659026816~~ = if (outInAmountAsset)
	617	+	let $t02948429540 = takeFee(amountRaw, outFee)
	618	+	let totalAmount = $t02948429540._1
	619	+	let feeAmount = $t02948429540._2
	620	+	let $t02954429770 = if (outInAmountAsset)
568	621		then $Tuple4(totalAmount, 0, (amBalanceOld - amountRaw), prBalanceOld)
569	622		else $Tuple4(0, totalAmount, amBalanceOld, (prBalanceOld - amountRaw))
570		-	let outAmAmount = $~~t02659026816~~._1
571		-	let outPrAmount = $~~t02659026816~~._2
572		-	let amBalanceNew = $~~t02659026816~~._3
573		-	let prBalanceNew = $~~t02659026816~~._4
	623	+	let outAmAmount = $t02954429770._1
	624	+	let outPrAmount = $t02954429770._2
	625	+	let amBalanceNew = $t02954429770._3
	626	+	let prBalanceNew = $t02954429770._4
574	627		let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, cfgPriceAssetDecimals), toX18(amBalanceNew, cfgAmountAssetDecimals))
575	628		let priceNew = fromX18(priceNewX18, scale8)
576	629		let commonState = if (isEval)

582	635		let amountBothInPaymentAsset = (toInt(fraction(balanceBigInt, redeemedBigInt, supplyBigInt)) * 2)
583	636		fraction((totalAmount - amountBothInPaymentAsset), scale8, amountBothInPaymentAsset)
584	637		}
585		-	$~~Tuple4~~(totalAmount, commonState, feeAmount, loss)
	638	+	$Tuple5(totalAmount, commonState, feeAmount, loss, outInAmountAsset)
586	639		}
587	640		else throw("Strict value is not equal to itself.")
588	641		}

682	735		let prDiff = estPut._11
683	736		let amId = estPut._12
684	737		let prId = estPut._13
685		-	let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
686		-	if ((emitInv == emitInv))
	738	+	let amAssetPmt = toBigInt(value(i.payments[0]).amount)
	739	+	let prAssetPmt = toBigInt(value(i.payments[1]).amount)
	740	+	let currentKLp = calcCurrentKLp(amAssetPmt, prAssetPmt, toBigInt(0))
	741	+	if ((currentKLp == currentKLp))
687	742		then {
688		-	let emitInvLegacy = match emitInv {
689		-	case legacyFactoryContract: Address =>
690		-	invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
691		-	case _ =>
692		-	unit
693		-	}
694		-	if ((emitInvLegacy == emitInvLegacy))
	743	+	let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
	744	+	if ((emitInv == emitInv))
695	745		then {
696		-	let slippageAInv = if ((amDiff > 0))
697		-	then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
698		-	else nil
699		-	if ((slippageAInv == slippageAInv))
	746	+	let emitInvLegacy = match emitInv {
	747	+	case legacyFactoryContract: Address =>
	748	+	invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
	749	+	case _ =>
	750	+	unit
	751	+	}
	752	+	if ((emitInvLegacy == emitInvLegacy))
700	753		then {
701		-	let ~~slippagePInv~~ = if ((~~prDiff~~ > 0))
702		-	then invoke(slippageContract, "put", nil, [AttachedPayment(~~prId~~, ~~prDiff~~)])
	754	+	let slippageAInv = if ((amDiff > 0))
	755	+	then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
703	756		else nil
704		-	if ((~~slippagePInv~~ == ~~slippagePInv~~))
	757	+	if ((slippageAInv == slippageAInv))
705	758		then {
706		-	let lpTransfer = if (shouldAutoStake)
	759	+	let slippagePInv = if ((prDiff > 0))
	760	+	then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
	761	+	else nil
	762	+	if ((slippagePInv == slippagePInv))
707	763		then {
708		-	let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
709		-	if ((slpStakeInv == slpStakeInv))
710		-	then nil
	764	+	let lpTransfer = if (shouldAutoStake)
	765	+	then {
	766	+	let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
	767	+	if ((slpStakeInv == slpStakeInv))
	768	+	then nil
	769	+	else throw("Strict value is not equal to itself.")
	770	+	}
	771	+	else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
	772	+	let $t03429834760 = refreshKLpInternal(0, 0, 0)
	773	+	if (($t03429834760 == $t03429834760))
	774	+	then {
	775	+	let updatedKLp = $t03429834760._2
	776	+	let refreshKLpActions = $t03429834760._1
	777	+	let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
	778	+	if ((isUpdatedKLpValid == isUpdatedKLpValid))
	779	+	then ((state ++ lpTransfer) ++ refreshKLpActions)
	780	+	else throw("Strict value is not equal to itself.")
	781	+	}
711	782		else throw("Strict value is not equal to itself.")
712	783		}
713		-	else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
714		-	(state ++ lpTransfer)
	784	+	else throw("Strict value is not equal to itself.")
715	785		}
716	786		else throw("Strict value is not equal to itself.")
717	787		}

729	799		then throw("Invalid value passed")
730	800		else {
731	801		let estPut = commonPut(i, maxSlippage, false)
732		-	estPut._9
	802	+	let state = estPut._9
	803	+	let amAssetPmt = toBigInt(value(i.payments[0]).amount)
	804	+	let prAssetPmt = toBigInt(value(i.payments[1]).amount)
	805	+	let currentKLp = calcCurrentKLp(amAssetPmt, prAssetPmt, toBigInt(0))
	806	+	if ((currentKLp == currentKLp))
	807	+	then {
	808	+	let $t03532235387 = refreshKLpInternal(0, 0, 0)
	809	+	let refreshKLpActions = $t03532235387._1
	810	+	let updatedKLp = $t03532235387._2
	811	+	let isUpdatedKLpValid = validateUpdatedKLp(currentKLp, updatedKLp)
	812	+	if ((isUpdatedKLpValid == isUpdatedKLpValid))
	813	+	then (state ++ refreshKLpActions)
	814	+	else throw("Strict value is not equal to itself.")
	815	+	}
	816	+	else throw("Strict value is not equal to itself.")
733	817		}
734	818
735	819

761	845		let payment = i.payments[0]
762	846		let paymentAssetId = payment.assetId
763	847		let paymentAmountRaw = payment.amount
764		-	let userAddress = i.caller
765		-	let txId = i.transactionId
766		-	let $t03172331853 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
767		-	if (($t03172331853 == $t03172331853))
	848	+	let currentKLp = if ((paymentAssetId == cfgAmountAssetId))
	849	+	then calcCurrentKLp(toBigInt(paymentAmountRaw), toBigInt(0), toBigInt(0))
	850	+	else if ((paymentAssetId == cfgPriceAssetId))
	851	+	then calcCurrentKLp(toBigInt(0), toBigInt(paymentAmountRaw), toBigInt(0))
	852	+	else throwErr("payment asset is not supported")
	853	+	if ((currentKLp == currentKLp))
768	854		then {
769		-	let bonus = $t03172331853._4
770		-	let feeAmount = $t03172331853._3
771		-	let commonState = $t03172331853._2
772		-	let emitAmountEstimated = $t03172331853._1
773		-	let emitAmount = if (if ((minOutAmount > 0))
774		-	then (minOutAmount > emitAmountEstimated)
775		-	else false)
776		-	then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
777		-	else emitAmountEstimated
778		-	let emitInv = emit(emitAmount)
779		-	if ((emitInv == emitInv))
	855	+	let userAddress = i.caller
	856	+	let txId = i.transactionId
	857	+	let $t03657536727 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
	858	+	if (($t03657536727 == $t03657536727))
780	859		then {
781		-	let lpTransfer = if (autoStake)
	860	+	let paymentInAmountAsset = $t03657536727._5
	861	+	let bonus = $t03657536727._4
	862	+	let feeAmount = $t03657536727._3
	863	+	let commonState = $t03657536727._2
	864	+	let emitAmountEstimated = $t03657536727._1
	865	+	let emitAmount = if (if ((minOutAmount > 0))
	866	+	then (minOutAmount > emitAmountEstimated)
	867	+	else false)
	868	+	then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
	869	+	else emitAmountEstimated
	870	+	let emitInv = emit(emitAmount)
	871	+	if ((emitInv == emitInv))
782	872		then {
783		-	let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(cfgLpAssetId, emitAmount)])
784		-	if ((stakeInv == stakeInv))
785		-	then nil
	873	+	let lpTransfer = if (autoStake)
	874	+	then {
	875	+	let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(cfgLpAssetId, emitAmount)])
	876	+	if ((stakeInv == stakeInv))
	877	+	then nil
	878	+	else throw("Strict value is not equal to itself.")
	879	+	}
	880	+	else [ScriptTransfer(i.caller, emitAmount, cfgLpAssetId)]
	881	+	let sendFee = if ((feeAmount > 0))
	882	+	then [ScriptTransfer(feeCollectorAddress, feeAmount, paymentAssetId)]
	883	+	else nil
	884	+	let $t03731337510 = if ((this == feeCollectorAddress))
	885	+	then $Tuple2(0, 0)
	886	+	else if (paymentInAmountAsset)
	887	+	then $Tuple2(-(feeAmount), 0)

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
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 scale18 = toBigInt(1000000000000000000)
11	11
12	12		let zeroBigInt = toBigInt(0)
13	13
14	14		let big0 = toBigInt(0)
15	15
16	16		let big1 = toBigInt(1)
17	17
18	18		let big2 = toBigInt(2)
19	19
20	20		let wavesString = "WAVES"
21	21
22	22		let SEP = "__"
23	23
24	24		let PoolActive = 1
25	25
26	26		let PoolPutDisabled = 2
27	27
28	28		let PoolMatcherDisabled = 3
29	29
30	30		let PoolShutdown = 4
31	31
32	32		let idxPoolAddress = 1
33	33
34	34		let idxPoolStatus = 2
35	35
36	36		let idxPoolLPAssetId = 3
37	37
38	38		let idxAmtAssetId = 4
39	39
40	40		let idxPriceAssetId = 5
41	41
42	42		let idxAmtAssetDcm = 6
43	43
44	44		let idxPriceAssetDcm = 7
45	45
46	46		let idxIAmtAssetId = 8
47	47
48	48		let idxIPriceAssetId = 9
49	49
50	50		let idxLPAssetDcm = 10
51	51
52	52		let idxPoolAmtAssetAmt = 1
53	53
54	54		let idxPoolPriceAssetAmt = 2
55	55
56	56		let idxPoolLPAssetAmt = 3
57	57
58	58		let idxFactoryStakingContract = 1
59	59
60	60		let idxFactorySlippageContract = 7
61	61
62	62		func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
63	63
64	64
	65	+	func toX18BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
	66	+
	67	+
65	68		func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
	69	+
	70	+
	71	+	func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
66	72
67	73
68	74		func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
69	75
70	76
71	77		func abs (val) = if ((0 > val))
72	78		then -(val)
73	79		else val
74	80
75	81
76	82		func absBigInt (val) = if ((zeroBigInt > val))
77	83		then -(val)
78	84		else val
79	85
80	86
81	87		func fc () = "%s__factoryContract"
82	88
83	89
84	90		func mpk () = "%s__managerPublicKey"
85	91
86	92
87	93		func pmpk () = "%s__pendingManagerPublicKey"
88	94
89	95
90	96		func pl () = "%s%s__price__last"
91	97
92	98
93	99		func ph (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
94	100
95	101
96	102		func pau (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
97	103
98	104
99	105		func gau (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
100	106
101	107
102	108		func aa () = "%s__amountAsset"
103	109
104	110
105	111		func pa () = "%s__priceAsset"
106	112
107	113
	114	+	let keyFee = "%s__fee"
	115	+
	116	+	let feeDefault = fraction(10, scale8, 10000)
	117	+
	118	+	let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
	119	+
	120	+	let keyKLp = makeString(["%s", "kLp"], SEP)
	121	+
	122	+	let keyKLpRefreshedHeight = makeString(["%s", "kLpRefreshedHeight"], SEP)
	123	+
	124	+	let keyKLpRefreshDelay = makeString(["%s", "refreshKLpDelay"], SEP)
	125	+
	126	+	let kLpRefreshDelayDefault = 30
	127	+
	128	+	let kLpRefreshDelay = valueOrElse(getInteger(this, keyKLpRefreshDelay), kLpRefreshDelayDefault)
	129	+
108	130		func keyFactoryConfig () = "%s__factoryConfig"
109	131
110	132
111	133		func keyMatcherPub () = "%s%s__matcher__publicKey"
112	134
113	135
114	136		func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
115	137
116	138
117	139		func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
118	140
119	141
120	142		func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
121	143
122	144
123	145		func keyAllPoolsShutdown () = "%s__shutdown"
124	146
125	147
126	148		func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
127	149
128	150
129	151		func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
130	152
131	153
132	154		let keyFeeCollectorAddress = "%s__feeCollectorAddress"
133	155
134		-	func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
	156	+	func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
135	157
136	158
137	159		func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
138	160
139	161
140	162		func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
141	163
142	164
143	165		func throwErr (msg) = throw(makeString(["lp.ride:", msg], " "))
	166	+
	167	+
	168	+	func fmtErr (msg) = makeString(["lp.ride:", msg], " ")
144	169
145	170
146	171		let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))
147	172
148	173		let feeCollectorAddress = addressFromStringValue(getStringOrFail(factoryContract, keyFeeCollectorAddress))
149	174
150	175		let inFee = {
151	176		let @ = invoke(factoryContract, "getInFeeREADONLY", [toString(this)], nil)
152	177		if ($isInstanceOf(@, "Int"))
153	178		then @
154	179		else throw(($getType(@) + " couldn't be cast to Int"))
155	180		}
156	181
157	182		let outFee = {
158	183		let @ = invoke(factoryContract, "getOutFeeREADONLY", [toString(this)], nil)
159	184		if ($isInstanceOf(@, "Int"))
160	185		then @
161	186		else throw(($getType(@) + " couldn't be cast to Int"))
162	187		}
163	188
164	189		func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
165	190
166	191
167	192		func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
168	193
169	194
170	195		func getPoolConfig () = {
171	196		let amtAsset = getStringOrFail(this, aa())
172	197		let priceAsset = getStringOrFail(this, pa())
173	198		let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
174	199		let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
175	200		split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
176	201		}
177	202
178	203
179	204		func parseAssetId (input) = if ((input == wavesString))
180	205		then unit
181	206		else fromBase58String(input)
182	207
183	208
184	209		func assetIdToString (input) = if ((input == unit))
185	210		then wavesString
186	211		else toBase58String(value(input))
187	212
188	213
189	214		func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolStatus]), fromBase58String(poolConfig[idxPoolLPAssetId]), parseAssetId(poolConfig[idxAmtAssetId]), parseAssetId(poolConfig[idxPriceAssetId]), parseIntValue(poolConfig[idxAmtAssetDcm]), parseIntValue(poolConfig[idxPriceAssetDcm]))
190	215
191	216
192	217		let poolConfigParsed = parsePoolConfig(getPoolConfig())
193	218
194		-	let $~~t076017767~~ = poolConfigParsed
	219	+	let $t084088574 = poolConfigParsed
195	220
196		-	let cfgPoolAddress = $~~t076017767~~._1
	221	+	let cfgPoolAddress = $t084088574._1
197	222
198		-	let cfgPoolStatus = $~~t076017767~~._2
	223	+	let cfgPoolStatus = $t084088574._2
199	224
200		-	let cfgLpAssetId = $~~t076017767~~._3
	225	+	let cfgLpAssetId = $t084088574._3
201	226
202		-	let cfgAmountAssetId = $~~t076017767~~._4
	227	+	let cfgAmountAssetId = $t084088574._4
203	228
204		-	let cfgPriceAssetId = $~~t076017767~~._5
	229	+	let cfgPriceAssetId = $t084088574._5
205	230
206		-	let cfgAmountAssetDecimals = $~~t076017767~~._6
	231	+	let cfgAmountAssetDecimals = $t084088574._6
207	232
208		-	let cfgPriceAssetDecimals = $~~t076017767~~._7
	233	+	let cfgPriceAssetDecimals = $t084088574._7
209	234
210	235		func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
211	236
212	237
213	238		let stakingContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactoryStakingContract]), "incorrect staking address")
214	239
215	240		let slippageContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactorySlippageContract]), "incorrect staking address")
216	241
217	242		func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
218	243
219	244
220	245		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)
221	246
222	247
223	248		func getAccBalance (assetId) = if ((assetId == "WAVES"))
224	249		then wavesBalance(this).available
225	250		else assetBalance(this, fromBase58String(assetId))
226	251
227	252
228	253		func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
	254	+
	255	+
	256	+	func calcPriceBigIntRound (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
229	257
230	258
231	259		func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
232	260		let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
233	261		let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
234	262		calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
235	263		}
236	264
237	265
238	266		func calcPrices (amAmt,prAmt,lpAmt) = {
239	267		let cfg = getPoolConfig()
240	268		let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
241	269		let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
242	270		let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
243	271		let amAmtX18 = toX18(amAmt, amtAssetDcm)
244	272		let prAmtX18 = toX18(prAmt, priceAssetDcm)
245	273		let lpAmtX18 = toX18(lpAmt, scale8)
246	274		let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
247	275		let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
248	276		[priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
249	277		}
250	278
251	279
252	280		func calculatePrices (amAmt,prAmt,lpAmt) = {
253	281		let prices = calcPrices(amAmt, prAmt, lpAmt)
254	282		[fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
255	283		}
256	284
257	285
258	286		func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
259	287		let cfg = getPoolConfig()
260	288		let lpAssetId = cfg[idxPoolLPAssetId]
261	289		let amAssetId = cfg[idxAmtAssetId]
262	290		let prAssetId = cfg[idxPriceAssetId]
263	291		let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
264	292		let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
265	293		let poolStatus = cfg[idxPoolStatus]
266	294		let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
267	295		if ((lpAssetId != pmtAssetId))
268	296		then throw("Invalid asset passed.")
269	297		else {
270	298		let amBalance = getAccBalance(amAssetId)
271	299		let amBalanceX18 = toX18(amBalance, amAssetDcm)
272	300		let prBalance = getAccBalance(prAssetId)
273	301		let prBalanceX18 = toX18(prBalance, prAssetDcm)
274	302		let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
275	303		let curPrice = fromX18(curPriceX18, scale8)
276	304		let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
277	305		let lpEmissionX18 = toX18(lpEmission, scale8)
278	306		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
279	307		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
280		-	let outAmAmt = ~~fromX18~~(outAmAmtX18, amAssetDcm)
281		-	let outPrAmt = ~~fromX18~~(outPrAmtX18, prAssetDcm)
	308	+	let outAmAmt = fromX18Round(outAmAmtX18, amAssetDcm, FLOOR)
	309	+	let outPrAmt = fromX18Round(outPrAmtX18, prAssetDcm, FLOOR)
282	310		let state = if ((txId58 == ""))
283	311		then nil
284	312		else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
285	313		then unit
286	314		else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
287	315		then unit
288	316		else fromBase58String(prAssetId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
289	317		$Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
290	318		}
291	319		}
292	320
293	321
294	322		func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
295	323		let cfg = getPoolConfig()
296	324		let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
297	325		let amAssetIdStr = cfg[idxAmtAssetId]
298	326		let prAssetIdStr = cfg[idxPriceAssetId]
299	327		let iAmtAssetId = cfg[idxIAmtAssetId]
300	328		let iPriceAssetId = cfg[idxIPriceAssetId]
301	329		let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
302	330		let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
303	331		let poolStatus = cfg[idxPoolStatus]
304	332		let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
305	333		let inAmAssetIdStr = toBase58String(valueOrElse(inAmAssetId, fromBase58String("WAVES")))
306	334		let inPrAssetIdStr = toBase58String(valueOrElse(inPrAssetId, fromBase58String("WAVES")))
307	335		if (if ((amAssetIdStr != inAmAssetIdStr))
308	336		then true
309	337		else (prAssetIdStr != inPrAssetIdStr))
310	338		then throw("Invalid amt or price asset passed.")
311	339		else {
312	340		let amBalance = if (isEvaluate)
313	341		then getAccBalance(amAssetIdStr)
314	342		else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
315	343		let prBalance = if (isEvaluate)
316	344		then getAccBalance(prAssetIdStr)
317	345		else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
318	346		let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
319	347		let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
320	348		let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
321	349		let amBalanceX18 = toX18(amBalance, amtAssetDcm)
322	350		let prBalanceX18 = toX18(prBalance, priceAssetDcm)
323	351		let res = if ((lpEmission == 0))
324	352		then {
325	353		let curPriceX18 = zeroBigInt
326	354		let slippageX18 = zeroBigInt
327	355		let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
328	356		$Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
329	357		}
330	358		else {
331	359		let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
332	360		let slippageX18 = fraction(absBigInt((curPriceX18 - userPriceX18)), scale18, curPriceX18)
333	361		let slippageToleranceX18 = toX18(slippageTolerance, scale8)
334	362		if (if ((curPriceX18 != zeroBigInt))
335	363		then (slippageX18 > slippageToleranceX18)
336	364		else false)
337	365		then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
338	366		else {
339	367		let lpEmissionX18 = toX18(lpEmission, scale8)
340		-	let prViaAmX18 = fraction(inAmAssetAmtX18, ~~curPriceX18~~, scale18)
341		-	let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, ~~curPriceX18~~)
	368	+	let prViaAmX18 = fraction(inAmAssetAmtX18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
	369	+	let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, calcPriceBigIntRound(prBalanceX18, amBalanceX18, FLOOR), CEILING)
342	370		let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
343	371		then $Tuple2(amViaPrX18, inPrAssetAmtX18)
344	372		else $Tuple2(inAmAssetAmtX18, prViaAmX18)
345	373		let expAmtAssetAmtX18 = expectedAmts._1
346	374		let expPriceAssetAmtX18 = expectedAmts._2
347		-	let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
348		-	$Tuple5(~~fromX18~~(lpAmtX18, scale8), ~~fromX18~~(expAmtAssetAmtX18, amtAssetDcm), ~~fromX18~~(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
	375	+	let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18, FLOOR)
	376	+	$Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtAssetDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceAssetDcm, CEILING), curPriceX18, slippageX18)
349	377		}
350	378		}
351	379		let calcLpAmt = res._1
352	380		let calcAmAssetPmt = res._2
353	381		let calcPrAssetPmt = res._3
354	382		let curPrice = fromX18(res._4, scale8)
355	383		let slippageCalc = fromX18(res._5, scale8)
356	384		if ((0 >= calcLpAmt))
357	385		then throw("Invalid calculations. LP calculated is less than zero.")
358	386		else {
359	387		let emitLpAmt = if (!(emitLp))
360	388		then 0
361	389		else calcLpAmt
362	390		let amDiff = (inAmAssetAmt - calcAmAssetPmt)
363	391		let prDiff = (inPrAssetAmt - calcPrAssetPmt)
364	392		let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
365	393		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
366	394		}
367	395		}
368	396		}
369	397
370	398
	399	+	func calcKLp (amountBalance,priceBalance,lpEmission) = {
	400	+	let amountBalanceX18 = toX18BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals))
	401	+	let priceBalanceX18 = toX18BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))
	402	+	let updatedKLp = fraction(pow((amountBalanceX18 * priceBalanceX18), 0, toBigInt(5), 1, 18, DOWN), big1, lpEmission)
	403	+	if ((lpEmission == big0))
	404	+	then big0
	405	+	else updatedKLp
	406	+	}
	407	+
	408	+
	409	+	func calcCurrentKLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
	410	+	let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
	411	+	let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
	412	+	let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
	413	+	let currentKLp = calcKLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
	414	+	currentKLp
	415	+	}
	416	+
	417	+
	418	+	func refreshKLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
	419	+	let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
	420	+	let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
	421	+	let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
	422	+	let updatedKLp = calcKLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
	423	+	let actions = [IntegerEntry(keyKLpRefreshedHeight, height), StringEntry(keyKLp, toString(updatedKLp))]
	424	+	$Tuple2(actions, updatedKLp)
	425	+	}
	426	+
	427	+
	428	+	func validateUpdatedKLp (oldKLp,updatedKLp) = if ((updatedKLp >= oldKLp))
	429	+	then true
	430	+	else throwErr(makeString(["updated KLp lower than current KLp", toString(oldKLp), toString(updatedKLp)], " "))
	431	+
	432	+
371	433		func validateMatcherOrderAllowed (order) = {
372		-	let cfg = getPoolConfig()
373		-	let amtAssetId = cfg[idxAmtAssetId]
374		-	let priceAssetId = cfg[idxPriceAssetId]
375		-	let poolStatus = parseIntValue(cfg[idxPoolStatus])
376		-	let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
377		-	let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
378		-	let accAmtAssetBalance = getAccBalance(amtAssetId)
379		-	let accPriceAssetBalance = getAccBalance(priceAssetId)
380		-	let curPriceX18 = if ((order.orderType == Buy))
381		-	then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
382		-	else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
383		-	let curPrice = fromX18(curPriceX18, scale8)
	434	+	let amountAssetAmount = order.amount
	435	+	let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
	436	+	let $t02132621538 = if ((order.orderType == Buy))
	437	+	then $Tuple2(amountAssetAmount, -(priceAssetAmount))
	438	+	else $Tuple2(-(amountAssetAmount), priceAssetAmount)
	439	+	let amountAssetBalanceDelta = $t02132621538._1
	440	+	let priceAssetBalanceDelta = $t02132621538._2
384	441		if (if (if (isGlobalShutdown())
385	442		then true
386		-	else (~~poolStatus~~ == PoolMatcherDisabled))
	443	+	else (cfgPoolStatus == PoolMatcherDisabled))
387	444		then true
388		-	else (~~poolStatus~~ == PoolShutdown))
	445	+	else (cfgPoolStatus == PoolShutdown))
389	446		then throw("Exchange operations disabled")
390		-	else {
391		-	let orderAmtAsset = order.assetPair.amountAsset
392		-	let orderAmtAssetStr = if ((orderAmtAsset == unit))
393		-	then "WAVES"
394		-	else toBase58String(value(orderAmtAsset))
395		-	let orderPriceAsset = order.assetPair.priceAsset
396		-	let orderPriceAssetStr = if ((orderPriceAsset == unit))
397		-	then "WAVES"
398		-	else toBase58String(value(orderPriceAsset))
399		-	if (if ((orderAmtAssetStr != amtAssetId))
400		-	then true
401		-	else (orderPriceAssetStr != priceAssetId))
402		-	then throw("Wrong order assets.")
403		-	else {
404		-	let orderPrice = order.price
405		-	let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
406		-	let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
407		-	let isOrderPriceValid = if ((order.orderType == Buy))
408		-	then (curPrice >= castedOrderPrice)
409		-	else (castedOrderPrice >= curPrice)
410		-	true
411		-	}
412		-	}
	447	+	else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
	448	+	then true

github/deemru/w8io/786bc32 
166.88 ms ◑