w8 · tx · Axh···xMu

tx · AxhLbJVF9wXAf3YhwXkgmcJTdGfrfxmisJpW5QrkVxMu

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.03600000 Waves

2022.12.16 10:03 [2362528] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AxhLbJVF9wXAf3YhwXkgmcJTdGfrfxmisJpW5QrkVxMu",
    "fee": 3600000,
    "feeAssetId": null,
    "timestamp": 1671173916291,
    "version": 1,
    "sender": "3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT",
    "senderPublicKey": "D1BL65meykxFZTCuq7jq9HSGLLnWvQamQPUNrguW5w39",
    "proofs": [
        "37xYuro4YfJL8gqU4daf2KRkoVRoBZf9aTcAi86uY8BsjcAr8xdbf7kKTf6aAbD18moU3FzCQcxWndMKEVeYDNox"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2362528,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GPNBmRnow9dZvMb8P74Lq1G6YjGPXbSfcupTKCJvce1E
Next: H2TWnCioPkGbiEH5A5CRkDs42iPCS86sw4T96ZdbY3Kr

Diff: 
Old New Differences
71 71  
72 72  
73 73  func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
74 + 
75 + 
76 + func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
74 77  
75 78  
76 79  func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
213 216  
214 217  let poolConfigParsed = parsePoolConfig(gpc())
215 218  
216 - let $t072557441 = poolConfigParsed
219 + let $t074067592 = poolConfigParsed
217 220  
218 - let cfgPoolAddress = $t072557441._1
221 + let cfgPoolAddress = $t074067592._1
219 222  
220 - let cfgPoolStatus = $t072557441._2
223 + let cfgPoolStatus = $t074067592._2
221 224  
222 - let cfgLpAssetId = $t072557441._3
225 + let cfgLpAssetId = $t074067592._3
223 226  
224 - let cfgAmountAssetId = $t072557441._4
227 + let cfgAmountAssetId = $t074067592._4
225 228  
226 - let cfgPriceAssetId = $t072557441._5
229 + let cfgPriceAssetId = $t074067592._5
227 230  
228 - let cfgAmountAssetDecimals = $t072557441._6
231 + let cfgAmountAssetDecimals = $t074067592._6
229 232  
230 - let cfgPriceAssetDecimals = $t072557441._7
233 + let cfgPriceAssetDecimals = $t074067592._7
231 234  
232 235  func gfc () = split(strf(fca, fcfg()), SEP)
233 236  
331 334              let lpEmissX18 = t1(lpEmiss, scale8)
332 335              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
333 336              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
334 -             let outAmAmt = f1(outAmAmtX18, amDcm)
335 -             let outPrAmt = f1(outPrAmtX18, prDcm)
337 +             let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
338 +             let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
336 339              let state = if ((txId58 == ""))
337 340                  then nil
338 341                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
406 409                      let expAmtAssetAmtX18 = expectedAmts._1
407 410                      let expPriceAssetAmtX18 = expectedAmts._2
408 411                      let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
409 -                     $Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
412 +                     $Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
410 413                      }
411 414              }
412 415      let calcLpAmt = r._1
422 425                  else calcLpAmt
423 426              let amDiff = (inAmAmt - calcAmAssetPmt)
424 427              let prDiff = (inPrAmt - calcPrAssetPmt)
425 -             let $t01787218217 = if (if (isOneAsset)
428 +             let $t01811218457 = if (if (isOneAsset)
426 429                  then (pmtId == amIdStr)
427 430                  else false)
428 431                  then $Tuple2(pmtAmt, 0)
431 434                      else false)
432 435                      then $Tuple2(0, pmtAmt)
433 436                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
434 -             let writeAmAmt = $t01787218217._1
435 -             let writePrAmt = $t01787218217._2
437 +             let writeAmAmt = $t01811218457._1
438 +             let writePrAmt = $t01811218457._2
436 439              let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
437 440              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
438 441              }
474 477                      }
475 478  
476 479              let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
477 -             let $t02014520193 = {
480 +             let $t02038520433 = {
478 481                  let $l = arr
479 482                  let $s = size($l)
480 483                  let $acc0 = $Tuple2(s, false)
488 491  
489 492                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
490 493                  }
491 -             let d = $t02014520193._1
492 -             let found = $t02014520193._2
494 +             let d = $t02038520433._1
495 +             let found = $t02038520433._2
493 496              if (found)
494 497                  then d
495 498                  else throw(("D calculation error, D = " + toString(d)))
513 516              let ann_aPrecision = (ann - aPrecision)
514 517              let n1 = (n + big1)
515 518              func calc (acc,cur) =             {
516 -                 let $t02082220842 = acc
517 -                 let d = $t02082220842._1
518 -                 let found = $t02082220842._2
519 +                 let $t02106221082 = acc
520 +                 let d = $t02106221082._1
521 +                 let found = $t02106221082._2
519 522                  if ((found != unit))
520 523                      then acc
521 524                      else {
529 532                  }
530 533  
531 534              let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
532 -             let $t02126321310 = {
535 +             let $t02150321550 = {
533 536                  let $l = arr
534 537                  let $s = size($l)
535 538                  let $acc0 = $Tuple2(s, unit)
543 546  
544 547                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
545 548                  }
546 -             let d = $t02126321310._1
547 -             let found = $t02126321310._2
549 +             let d = $t02150321550._1
550 +             let found = $t02150321550._2
548 551              if ((found != unit))
549 552                  then d
550 553                  else throw(("D calculation error, D = " + toString(d)))
564 567      let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
565 568      let b = ((s + ((D * aPrecision) / ann)) - D)
566 569      func calc (acc,cur) =     {
567 -         let $t02181021830 = acc
568 -         let y = $t02181021830._1
569 -         let found = $t02181021830._2
570 +         let $t02205022070 = acc
571 +         let y = $t02205022070._1
572 +         let found = $t02205022070._2
570 573          if ((found != unit))
571 574              then acc
572 575              else {
579 582          }
580 583  
581 584      let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
582 -     let $t02213722184 = {
585 +     let $t02237722424 = {
583 586          let $l = arr
584 587          let $s = size($l)
585 588          let $acc0 = $Tuple2(D, unit)
593 596  
594 597          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
595 598          }
596 -     let y = $t02213722184._1
597 -     let found = $t02213722184._2
599 +     let y = $t02237722424._1
600 +     let found = $t02237722424._2
598 601      if ((found != unit))
599 602          then y
600 603          else throw(("Y calculation error, Y = " + toString(y)))
636 639  func validateMatcherOrderAllowed (order) = {
637 640      let amountAssetAmount = order.amount
638 641      let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
639 -     let $t02412324335 = if ((order.orderType == Buy))
642 +     let $t02436324575 = if ((order.orderType == Buy))
640 643          then $Tuple2(amountAssetAmount, -(priceAssetAmount))
641 644          else $Tuple2(-(amountAssetAmount), priceAssetAmount)
642 -     let amountAssetBalanceDelta = $t02412324335._1
643 -     let priceAssetBalanceDelta = $t02412324335._2
645 +     let amountAssetBalanceDelta = $t02436324575._1
646 +     let priceAssetBalanceDelta = $t02436324575._2
644 647      if (if (if (igs())
645 648          then true
646 649          else (cfgPoolStatus == PoolMatcherDis))
653 656              then throw("Wr assets")
654 657              else {
655 658                  let dLp = parseBigIntValue(getStringValue(this, keyDLp))
656 -                 let $t02466524765 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
657 -                 let unusedActions = $t02466524765._1
658 -                 let dLpNew = $t02466524765._2
659 +                 let $t02490525005 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
660 +                 let unusedActions = $t02490525005._1
661 +                 let dLpNew = $t02490525005._2
659 662                  let isOrderValid = (dLpNew >= dLp)
660 663                  isOrderValid
661 664                  }
709 712          then {
710 713              let amBalance = getAccBalance(amId)
711 714              let prBalance = getAccBalance(prId)
712 -             let $t02708227544 = if ((txId == ""))
715 +             let $t02732227784 = if ((txId == ""))
713 716                  then $Tuple2(amBalance, prBalance)
714 717                  else if ((pmtAssetId == amId))
715 718                      then if ((pmtAmtRaw > amBalance))
720 723                              then throw("invalid payment amount")
721 724                              else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
722 725                          else throw("wrong pmtAssetId")
723 -             let amBalanceOld = $t02708227544._1
724 -             let prBalanceOld = $t02708227544._2
725 -             let $t02755027726 = if ((pmtAssetId == amId))
726 +             let amBalanceOld = $t02732227784._1
727 +             let prBalanceOld = $t02732227784._2
728 +             let $t02779027966 = if ((pmtAssetId == amId))
726 729                  then $Tuple2(pmtAmtRaw, 0)
727 730                  else if ((pmtAssetId == prId))
728 731                      then $Tuple2(0, pmtAmtRaw)
729 732                      else throw("invalid payment")
730 -             let amAmountRaw = $t02755027726._1
731 -             let prAmountRaw = $t02755027726._2
732 -             let $t02773027969 = if (withTakeFee)
733 +             let amAmountRaw = $t02779027966._1
734 +             let prAmountRaw = $t02779027966._2
735 +             let $t02797028209 = if (withTakeFee)
733 736                  then $Tuple3(takeFee(amAmountRaw)._1, takeFee(prAmountRaw)._1, takeFee(pmtAmtRaw)._2)
734 737                  else $Tuple3(amAmountRaw, prAmountRaw, 0)
735 -             let amAmount = $t02773027969._1
736 -             let prAmount = $t02773027969._2
737 -             let feeAmount = $t02773027969._3
738 +             let amAmount = $t02797028209._1
739 +             let prAmount = $t02797028209._2
740 +             let feeAmount = $t02797028209._3
738 741              let amBalanceNew = (amBalanceOld + amAmount)
739 742              let prBalanceNew = (prBalanceOld + prAmount)
740 743              let D0 = getD([toBigInt(amBalanceOld), toBigInt(prBalanceOld)])
783 786                  else {
784 787                      let amBalance = getAccBalance(amId)
785 788                      let prBalance = getAccBalance(prId)
786 -                     let $t03003430145 = {
789 +                     let $t03027430385 = {
787 790                          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
788 791                          if ($isInstanceOf(@, "(Int, Int)"))
789 792                              then @
790 793                              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
791 794                          }
792 -                     if (($t03003430145 == $t03003430145))
795 +                     if (($t03027430385 == $t03027430385))
793 796                          then {
794 -                             let feeAmount = $t03003430145._2
795 -                             let totalGet = $t03003430145._1
797 +                             let feeAmount = $t03027430385._2
798 +                             let totalGet = $t03027430385._1
796 799                              let totalAmount = if (if ((minOutAmount > 0))
797 800                                  then (minOutAmount > totalGet)
798 801                                  else false)
799 802                                  then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
800 803                                  else totalGet
801 -                             let $t03033530642 = if ((outAssetId == amId))
804 +                             let $t03057530882 = if ((outAssetId == amId))
802 805                                  then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
803 806                                  else if ((outAssetId == prId))
804 807                                      then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
805 808                                      else throw("invalid out asset id")
806 -                             let outAm = $t03033530642._1
807 -                             let outPr = $t03033530642._2
808 -                             let amBalanceNew = $t03033530642._3
809 -                             let prBalanceNew = $t03033530642._4
809 +                             let outAm = $t03057530882._1
810 +                             let outPr = $t03057530882._2
811 +                             let amBalanceNew = $t03057530882._3
812 +                             let prBalanceNew = $t03057530882._4
810 813                              let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
811 814                              let curPr = f1(curPrX18, scale8)
812 815                              let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
821 824                                      let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
822 825                                      if ((burn == burn))
823 826                                          then {
824 -                                             let $t03142731777 = {
827 +                                             let $t03166732017 = {
825 828                                                  let feeAmountForCalc = if ((this == feeCollectorAddress))
826 829                                                      then 0
827 830                                                      else feeAmount
832 835                                                      then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
833 836                                                      else $Tuple2(0, -((totalGet + feeAmountForCalc)))
834 837                                                  }
835 -                                             let amountAssetBalanceDelta = $t03142731777._1
836 -                                             let priceAssetBalanceDelta = $t03142731777._2
837 -                                             let $t03178031888 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
838 -                                             let refreshDLpActions = $t03178031888._1
839 -                                             let updatedDLp = $t03178031888._2
838 +                                             let amountAssetBalanceDelta = $t03166732017._1
839 +                                             let priceAssetBalanceDelta = $t03166732017._2
840 +                                             let $t03202032128 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
841 +                                             let refreshDLpActions = $t03202032128._1
842 +                                             let updatedDLp = $t03202032128._2
840 843                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
841 844                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
842 845                                                  then $Tuple2((state ++ refreshDLpActions), totalAmount)
996 999                                                                      else throw("Strict value is not equal to itself.")
997 1000                                                                  }
998 1001                                                              else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
999 -                                                         let $t03574435809 = refreshDLpInternal(0, 0, 0)
1000 -                                                         let refreshDLpActions = $t03574435809._1
1001 -                                                         let updatedDLp = $t03574435809._2
1002 +                                                         let $t03598436049 = refreshDLpInternal(0, 0, 0)
1003 +                                                         let refreshDLpActions = $t03598436049._1
1004 +                                                         let updatedDLp = $t03598436049._2
1002 1005                                                          let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1003 1006                                                          if ((isUpdatedDLpValid == isUpdatedDLpValid))
1004 1007                                                              then ((state ++ lpTrnsfr) ++ refreshDLpActions)
1054 1057              let pmt = value(i.payments[0])
1055 1058              let pmtAssetId = toBase58String(value(pmt.assetId))
1056 1059              let pmtAmt = pmt.amount
1057 -             let $t03694637104 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1058 -             if (($t03694637104 == $t03694637104))
1060 +             let $t03718637344 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1061 +             if (($t03718637344 == $t03718637344))
1059 1062                  then {
1060 -                     let feeAmount = $t03694637104._3
1061 -                     let state = $t03694637104._2
1062 -                     let estimLP = $t03694637104._1
1063 +                     let feeAmount = $t03718637344._3
1064 +                     let state = $t03718637344._2
1065 +                     let estimLP = $t03718637344._1
1063 1066                      let emitLpAmt = if (if ((minOutAmount > 0))
1064 1067                          then (minOutAmount > estimLP)
1065 1068                          else false)
1087 1090                                      let sendFeeToMatcher = if ((feeAmount > 0))
1088 1091                                          then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1089 1092                                          else nil
1090 -                                     let $t03791938268 = if ((this == feeCollectorAddress))
1093 +                                     let $t03815938508 = if ((this == feeCollectorAddress))
1091 1094                                          then $Tuple2(0, 0)
1092 1095                                          else {
1093 1096                                              let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))
1097 1100                                                  then $Tuple2(-(feeAmount), 0)
1098 1101                                                  else $Tuple2(0, -(feeAmount))
1099 1102                                              }
1100 -                                     let amountAssetBalanceDelta = $t03791938268._1
1101 -                                     let priceAssetBalanceDelta = $t03791938268._2
1102 -                                     let $t03827138379 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1103 -                                     let refreshDLpActions = $t03827138379._1
1104 -                                     let updatedDLp = $t03827138379._2
1103 +                                     let amountAssetBalanceDelta = $t03815938508._1
1104 +                                     let priceAssetBalanceDelta = $t03815938508._2
1105 +                                     let $t03851138619 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1106 +                                     let refreshDLpActions = $t03851138619._1
1107 +                                     let updatedDLp = $t03851138619._2
1105 1108                                      $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)
1106 1109                                      }
1107 1110                                  else throw("Strict value is not equal to itself.")
1128 1131              let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1129 1132              if ((currentDLp == currentDLp))
1130 1133                  then {
1131 -                     let $t03933839403 = refreshDLpInternal(0, 0, 0)
1132 -                     let refreshDLpActions = $t03933839403._1
1133 -                     let updatedDLp = $t03933839403._2
1134 +                     let $t03957839643 = refreshDLpInternal(0, 0, 0)
1135 +                     let refreshDLpActions = $t03957839643._1
1136 +                     let updatedDLp = $t03957839643._2
1134 1137                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1135 1138                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1136 1139                          then (state ++ refreshDLpActions)
1153 1156      if ((b == b))
1154 1157          then {
1155 1158              let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(pmtAmt))
1156 -             let $t04019240274 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1157 -             let refreshDLpActions = $t04019240274._1
1158 -             let updatedDLp = $t04019240274._2
1159 +             let $t04043240514 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1160 +             let refreshDLpActions = $t04043240514._1
1161 +             let updatedDLp = $t04043240514._2
1159 1162              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1160 1163              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1161 1164                  then (state ++ refreshDLpActions)
1188 1191          else throwErr("exactly 1 payment are expected")]
1189 1192      if ((checks == checks))
1190 1193          then {
1191 -             let $t04089241047 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1192 -             let state = $t04089241047._1
1193 -             let totalAmount = $t04089241047._2
1194 +             let $t04113241287 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1195 +             let state = $t04113241287._1
1196 +             let totalAmount = $t04113241287._2
1194 1197              $Tuple2(state, totalAmount)
1195 1198              }
1196 1199          else throw("Strict value is not equal to itself.")
1207 1210      if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1208 1211          then {
1209 1212              let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1210 -             let $t04157141635 = refreshDLpInternal(0, 0, 0)
1211 -             let dLpUpdateActions = $t04157141635._1
1212 -             let updatedDLp = $t04157141635._2
1213 +             let $t04181141875 = refreshDLpInternal(0, 0, 0)
1214 +             let dLpUpdateActions = $t04181141875._1
1215 +             let updatedDLp = $t04181141875._2
1213 1216              let actions = if ((dLp != updatedDLp))
1214 1217                  then dLpUpdateActions
1215 1218                  else throwErr("nothing to refresh")
1238 1241      let newY = getYD(xp, index, D1)
1239 1242      let dy = (xp[index] - newY)
1240 1243      let totalGetRaw = max([0, toInt((dy - big1))])
1241 -     let $t04253542584 = takeFee(totalGetRaw)
1242 -     let totalGet = $t04253542584._1
1243 -     let feeAmount = $t04253542584._2
1244 +     let $t04277542824 = takeFee(totalGetRaw)
1245 +     let totalGet = $t04277542824._1
1246 +     let feeAmount = $t04277542824._2
1244 1247      $Tuple2(nil, $Tuple2(totalGet, feeAmount))
1245 1248      }
1246 1249  
1254 1257      let lpId = poolConfig[idxLPAsId]
1255 1258      let amBalance = getAccBalance(amId)
1256 1259      let prBalance = getAccBalance(prId)
1257 -     let $t04292943044 = {
1260 +     let $t04316943284 = {
1258 1261          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1259 1262          if ($isInstanceOf(@, "(Int, Int)"))
1260 1263              then @
1261 1264              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1262 1265          }
1263 -     let totalGet = $t04292943044._1
1264 -     let feeAmount = $t04292943044._2
1266 +     let totalGet = $t04316943284._1
1267 +     let feeAmount = $t04316943284._2
1265 1268      let r = ego("", lpId, lpAssetAmount, this)
1266 1269      let outAmAmt = r._1
1267 1270      let outPrAmt = r._2
1293 1296                  let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1294 1297                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1295 1298                      then {
1296 -                         let $t04421244293 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1297 -                         let refreshDLpActions = $t04421244293._1
1298 -                         let updatedDLp = $t04421244293._2
1299 +                         let $t04445244533 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1300 +                         let refreshDLpActions = $t04445244533._1
1301 +                         let updatedDLp = $t04445244533._2
1299 1302                          let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1300 1303                          if ((isUpdatedDLpValid == isUpdatedDLpValid))
1301 1304                              then (state ++ refreshDLpActions)
1337 1340                              let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1338 1341                              if ((burnA == burnA))
1339 1342                                  then {
1340 -                                     let $t04535645437 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1341 -                                     let refreshDLpActions = $t04535645437._1
1342 -                                     let updatedDLp = $t04535645437._2
1343 +                                     let $t04559645677 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1344 +                                     let refreshDLpActions = $t04559645677._1
1345 +                                     let updatedDLp = $t04559645677._2
1343 1346                                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1344 1347                                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1345 1348                                          then (state ++ refreshDLpActions)
1386 1389                              let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1387 1390                              if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1388 1391                                  then {
1389 -                                     let $t04668546766 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1390 -                                     let refreshDLpActions = $t04668546766._1
1391 -                                     let updatedDLp = $t04668546766._2
1392 +                                     let $t04692547006 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1393 +                                     let refreshDLpActions = $t04692547006._1
1394 +                                     let updatedDLp = $t04692547006._2
1392 1395                                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1393 1396                                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1394 1397                                          then (state ++ refreshDLpActions)
1434 1437              let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), unstakeAmount], nil)
1435 1438              if ((unstakeInv == unstakeInv))
1436 1439                  then {
1437 -                     let $t04770047888 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1438 -                     let state = $t04770047888._1
1439 -                     let totalAmount = $t04770047888._2
1440 +                     let $t04794048128 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1441 +                     let state = $t04794048128._1
1442 +                     let totalAmount = $t04794048128._2
1440 1443                      $Tuple2(state, totalAmount)
1441 1444                      }
1442 1445                  else throw("Strict value is not equal to itself.")
1452 1455      let amId = poolConfig[idxAmAsId]
1453 1456      let prId = poolConfig[idxPrAsId]
1454 1457      let lpId = poolConfig[idxLPAsId]
1455 -     let $t04814748250 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1456 -     let lpAmount = $t04814748250._1
1457 -     let state = $t04814748250._2
1458 -     let feeAmount = $t04814748250._3
1459 -     let bonus = $t04814748250._4
1458 +     let $t04838748490 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1459 +     let lpAmount = $t04838748490._1
1460 +     let state = $t04838748490._2
1461 +     let feeAmount = $t04838748490._3
1462 +     let bonus = $t04838748490._4
1460 1463      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1461 1464      }
1462 1465  
1468 1471      let amId = poolConfig[idxAmAsId]
1469 1472      let prId = poolConfig[idxPrAsId]
1470 1473      let lpId = poolConfig[idxLPAsId]
1471 -     let $t04852948633 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1472 -     let lpAmount = $t04852948633._1
1473 -     let state = $t04852948633._2
1474 -     let feeAmount = $t04852948633._3
1475 -     let bonus = $t04852948633._4
1474 +     let $t04876948873 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1475 +     let lpAmount = $t04876948873._1
1476 +     let state = $t04876948873._2
1477 +     let feeAmount = $t04876948873._3
1478 +     let bonus = $t04876948873._4
1476 1479      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1477 1480      }
1478 1481  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let scale8 = 100000000
5 5  
6 6  let scale8BigInt = toBigInt(100000000)
7 7  
8 8  let scale18 = toBigInt(1000000000000000000)
9 9  
10 10  let zeroBigInt = toBigInt(0)
11 11  
12 12  let big0 = toBigInt(0)
13 13  
14 14  let big1 = toBigInt(1)
15 15  
16 16  let big2 = toBigInt(2)
17 17  
18 18  let big3 = toBigInt(3)
19 19  
20 20  let big4 = toBigInt(4)
21 21  
22 22  let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
23 23  
24 24  let wavesString = "WAVES"
25 25  
26 26  let Amult = "100"
27 27  
28 28  let Dconv = "1"
29 29  
30 30  let SEP = "__"
31 31  
32 32  let EMPTY = ""
33 33  
34 34  let PoolActive = 1
35 35  
36 36  let PoolPutDis = 2
37 37  
38 38  let PoolMatcherDis = 3
39 39  
40 40  let PoolShutdown = 4
41 41  
42 42  let idxPoolAddress = 1
43 43  
44 44  let idxPoolSt = 2
45 45  
46 46  let idxLPAsId = 3
47 47  
48 48  let idxAmAsId = 4
49 49  
50 50  let idxPrAsId = 5
51 51  
52 52  let idxAmtAsDcm = 6
53 53  
54 54  let idxPriceAsDcm = 7
55 55  
56 56  let idxIAmtAsId = 8
57 57  
58 58  let idxIPriceAsId = 9
59 59  
60 60  let idxFactStakCntr = 1
61 61  
62 62  let idxFactoryRestCntr = 6
63 63  
64 64  let idxFactSlippCntr = 7
65 65  
66 66  let idxFactGwxRewCntr = 10
67 67  
68 68  let feeDefault = fraction(10, scale8, 10000)
69 69  
70 70  func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
71 71  
72 72  
73 73  func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
74 + 
75 + 
76 + func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
74 77  
75 78  
76 79  func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
77 80  
78 81  
79 82  func abs (val) = if ((zeroBigInt > val))
80 83      then -(val)
81 84      else val
82 85  
83 86  
84 87  func absBigInt (val) = if ((zeroBigInt > val))
85 88      then -(val)
86 89      else val
87 90  
88 91  
89 92  func fc () = "%s__factoryContract"
90 93  
91 94  
92 95  func mpk () = "%s__managerPublicKey"
93 96  
94 97  
95 98  func pmpk () = "%s__pendingManagerPublicKey"
96 99  
97 100  
98 101  func pl () = "%s%s__price__last"
99 102  
100 103  
101 104  func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
102 105  
103 106  
104 107  func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
105 108  
106 109  
107 110  func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
108 111  
109 112  
110 113  func aa () = "%s__amountAsset"
111 114  
112 115  
113 116  func pa () = "%s__priceAsset"
114 117  
115 118  
116 119  func amp () = "%s__amp"
117 120  
118 121  
119 122  func ada () = "%s__addonAddr"
120 123  
121 124  
122 125  let keyFee = "%s__fee"
123 126  
124 127  let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
125 128  
126 129  let keyDLp = makeString(["%s", "dLp"], SEP)
127 130  
128 131  let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
129 132  
130 133  let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
131 134  
132 135  let dLpRefreshDelayDefault = 1
133 136  
134 137  let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
135 138  
136 139  func fcfg () = "%s__factoryConfig"
137 140  
138 141  
139 142  func mtpk () = "%s%s__matcher__publicKey"
140 143  
141 144  
142 145  func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
143 146  
144 147  
145 148  func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
146 149  
147 150  
148 151  func aps () = "%s__shutdown"
149 152  
150 153  
151 154  func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
152 155  
153 156  
154 157  func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
155 158  
156 159  
157 160  func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
158 161  
159 162  
160 163  func str (val) = match val {
161 164      case valStr: String => 
162 165          valStr
163 166      case _ => 
164 167          throw("fail cast to String")
165 168  }
166 169  
167 170  
168 171  func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
169 172  
170 173  
171 174  func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
172 175  
173 176  
174 177  func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
175 178  
176 179  
177 180  func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
178 181  
179 182  
180 183  let fca = addressFromStringValue(strf(this, fc()))
181 184  
182 185  let A = strf(this, amp())
183 186  
184 187  func igs () = valueOrElse(getBoolean(fca, aps()), false)
185 188  
186 189  
187 190  func mp () = fromBase58String(strf(fca, mtpk()))
188 191  
189 192  
190 193  let feeCollectorAddress = addressFromStringValue(strf(fca, keyFeeCollectorAddress()))
191 194  
192 195  func gpc () = {
193 196      let amtAs = strf(this, aa())
194 197      let priceAs = strf(this, pa())
195 198      let iPriceAs = intf(fca, mba(priceAs))
196 199      let iAmtAs = intf(fca, mba(amtAs))
197 200      split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
198 201      }
199 202  
200 203  
201 204  func parseAssetId (input) = if ((input == wavesString))
202 205      then unit
203 206      else fromBase58String(input)
204 207  
205 208  
206 209  func assetIdToString (input) = if ((input == unit))
207 210      then wavesString
208 211      else toBase58String(value(input))
209 212  
210 213  
211 214  func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
212 215  
213 216  
214 217  let poolConfigParsed = parsePoolConfig(gpc())
215 218  
216 - let $t072557441 = poolConfigParsed
219 + let $t074067592 = poolConfigParsed
217 220  
218 - let cfgPoolAddress = $t072557441._1
221 + let cfgPoolAddress = $t074067592._1
219 222  
220 - let cfgPoolStatus = $t072557441._2
223 + let cfgPoolStatus = $t074067592._2
221 224  
222 - let cfgLpAssetId = $t072557441._3
225 + let cfgLpAssetId = $t074067592._3
223 226  
224 - let cfgAmountAssetId = $t072557441._4
227 + let cfgAmountAssetId = $t074067592._4
225 228  
226 - let cfgPriceAssetId = $t072557441._5
229 + let cfgPriceAssetId = $t074067592._5
227 230  
228 - let cfgAmountAssetDecimals = $t072557441._6
231 + let cfgAmountAssetDecimals = $t074067592._6
229 232  
230 - let cfgPriceAssetDecimals = $t072557441._7
233 + let cfgPriceAssetDecimals = $t074067592._7
231 234  
232 235  func gfc () = split(strf(fca, fcfg()), SEP)
233 236  
234 237  
235 238  let factoryConfig = gfc()
236 239  
237 240  let stakingContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactStakCntr]), "Invalid staking contract address")
238 241  
239 242  let slipageContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactSlippCntr]), "Invalid slipage contract address")
240 243  
241 244  let gwxContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactGwxRewCntr]), "Invalid gwx contract address")
242 245  
243 246  let restContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactoryRestCntr]), "Invalid gwx contract address")
244 247  
245 248  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
246 249  
247 250  
248 251  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)
249 252  
250 253  
251 254  func getAccBalance (assetId) = if ((assetId == "WAVES"))
252 255      then wavesBalance(this).available
253 256      else assetBalance(this, fromBase58String(assetId))
254 257  
255 258  
256 259  func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
257 260  
258 261  
259 262  func vad (A1,A2,slippage) = {
260 263      let diff = fraction((A1 - A2), scale8BigInt, A2)
261 264      let pass = ((slippage - abs(diff)) > zeroBigInt)
262 265      if (!(pass))
263 266          then throw(("Big slpg: " + toString(diff)))
264 267          else $Tuple2(pass, min([A1, A2]))
265 268      }
266 269  
267 270  
268 271  func vd (D1,D0,slpg) = {
269 272      let diff = fraction(D0, scale8BigInt, D1)
270 273      let fail = (slpg > diff)
271 274      if (if (fail)
272 275          then true
273 276          else (D0 > D1))
274 277          then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
275 278          else fail
276 279      }
277 280  
278 281  
279 282  func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
280 283      let amtAsAmtX18 = t1(amAmt, amAssetDcm)
281 284      let prAsAmtX18 = t1(prAmt, prAssetDcm)
282 285      cpbi(prAsAmtX18, amtAsAmtX18)
283 286      }
284 287  
285 288  
286 289  func calcPrices (amAmt,prAmt,lpAmt) = {
287 290      let cfg = gpc()
288 291      let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
289 292      let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
290 293      let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
291 294      let amAmtX18 = t1(amAmt, amtAsDcm)
292 295      let prAmtX18 = t1(prAmt, prAsDcm)
293 296      let lpAmtX18 = t1(lpAmt, scale8)
294 297      let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
295 298      let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
296 299  [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
297 300      }
298 301  
299 302  
300 303  func calculatePrices (amAmt,prAmt,lpAmt) = {
301 304      let p = calcPrices(amAmt, prAmt, lpAmt)
302 305  [f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
303 306      }
304 307  
305 308  
306 309  func takeFee (amount) = {
307 310      let feeAmount = fraction(amount, fee, scale8)
308 311      $Tuple2((amount - feeAmount), feeAmount)
309 312      }
310 313  
311 314  
312 315  func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
313 316      let cfg = gpc()
314 317      let lpId = cfg[idxLPAsId]
315 318      let amId = cfg[idxAmAsId]
316 319      let prId = cfg[idxPrAsId]
317 320      let amDcm = parseIntValue(cfg[idxAmtAsDcm])
318 321      let prDcm = parseIntValue(cfg[idxPriceAsDcm])
319 322      let sts = cfg[idxPoolSt]
320 323      let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
321 324      if ((lpId != pmtAssetId))
322 325          then throw("Wrong pmt asset")
323 326          else {
324 327              let amBalance = getAccBalance(amId)
325 328              let amBalanceX18 = t1(amBalance, amDcm)
326 329              let prBalance = getAccBalance(prId)
327 330              let prBalanceX18 = t1(prBalance, prDcm)
328 331              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
329 332              let curPrice = f1(curPriceX18, scale8)
330 333              let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
331 334              let lpEmissX18 = t1(lpEmiss, scale8)
332 335              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
333 336              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
334 -             let outAmAmt = f1(outAmAmtX18, amDcm)
335 -             let outPrAmt = f1(outPrAmtX18, prDcm)
337 +             let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
338 +             let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
336 339              let state = if ((txId58 == ""))
337 340                  then nil
338 341                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
339 342                      then unit
340 343                      else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
341 344                      then unit
342 345                      else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
343 346              $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
344 347              }
345 348      }
346 349  
347 350  
348 351  func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
349 352      let cfg = gpc()
350 353      let lpId = fromBase58String(cfg[idxLPAsId])
351 354      let amIdStr = cfg[idxAmAsId]
352 355      let prIdStr = cfg[idxPrAsId]
353 356      let inAmIdStr = cfg[idxIAmtAsId]
354 357      let inPrIdStr = cfg[idxIPriceAsId]
355 358      let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
356 359      let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
357 360      let sts = cfg[idxPoolSt]
358 361      let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
359 362      let amBalance = if (isEval)
360 363          then getAccBalance(amIdStr)
361 364          else if (if (isOneAsset)
362 365              then (pmtId == amIdStr)
363 366              else false)
364 367              then (getAccBalance(amIdStr) - pmtAmt)
365 368              else if (isOneAsset)
366 369                  then getAccBalance(amIdStr)
367 370                  else (getAccBalance(amIdStr) - inAmAmt)
368 371      let prBalance = if (isEval)
369 372          then getAccBalance(prIdStr)
370 373          else if (if (isOneAsset)
371 374              then (pmtId == prIdStr)
372 375              else false)
373 376              then (getAccBalance(prIdStr) - pmtAmt)
374 377              else if (isOneAsset)
375 378                  then getAccBalance(prIdStr)
376 379                  else (getAccBalance(prIdStr) - inPrAmt)
377 380      let inAmAssetAmtX18 = t1(inAmAmt, amtDcm)
378 381      let inPrAssetAmtX18 = t1(inPrAmt, priceDcm)
379 382      let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
380 383      let amBalanceX18 = t1(amBalance, amtDcm)
381 384      let prBalanceX18 = t1(prBalance, priceDcm)
382 385      let r = if ((lpEm == 0))
383 386          then {
384 387              let curPriceX18 = zeroBigInt
385 388              let slippageX18 = zeroBigInt
386 389              let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
387 390              $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
388 391              }
389 392          else {
390 393              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
391 394              let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
392 395              let slippageX18 = t1(slippage, scale8)
393 396              if (if (if (validateSlippage)
394 397                  then (curPriceX18 != zeroBigInt)
395 398                  else false)
396 399                  then (slippageRealX18 > slippageX18)
397 400                  else false)
398 401                  then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
399 402                  else {
400 403                      let lpEmissionX18 = t1(lpEm, scale8)
401 404                      let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
402 405                      let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
403 406                      let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
404 407                          then $Tuple2(amViaPrX18, inPrAssetAmtX18)
405 408                          else $Tuple2(inAmAssetAmtX18, prViaAmX18)
406 409                      let expAmtAssetAmtX18 = expectedAmts._1
407 410                      let expPriceAssetAmtX18 = expectedAmts._2
408 411                      let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
409 -                     $Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
412 +                     $Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
410 413                      }
411 414              }
412 415      let calcLpAmt = r._1
413 416      let calcAmAssetPmt = r._2
414 417      let calcPrAssetPmt = r._3
415 418      let curPrice = f1(r._4, scale8)
416 419      let slippageCalc = f1(r._5, scale8)
417 420      if ((0 >= calcLpAmt))
418 421          then throw("LP <= 0")
419 422          else {
420 423              let emitLpAmt = if (!(emitLp))
421 424                  then 0
422 425                  else calcLpAmt
423 426              let amDiff = (inAmAmt - calcAmAssetPmt)
424 427              let prDiff = (inPrAmt - calcPrAssetPmt)
425 -             let $t01787218217 = if (if (isOneAsset)
428 +             let $t01811218457 = if (if (isOneAsset)
426 429                  then (pmtId == amIdStr)
427 430                  else false)
428 431                  then $Tuple2(pmtAmt, 0)
429 432                  else if (if (isOneAsset)
430 433                      then (pmtId == prIdStr)
431 434                      else false)
432 435                      then $Tuple2(0, pmtAmt)
433 436                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
434 -             let writeAmAmt = $t01787218217._1
435 -             let writePrAmt = $t01787218217._2
437 +             let writeAmAmt = $t01811218457._1
438 +             let writePrAmt = $t01811218457._2
436 439              let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
437 440              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
438 441              }
439 442      }
440 443  
441 444  
442 445  func getD (xp) = {
443 446      let xp0 = xp[0]
444 447      let xp1 = xp[1]
445 448      let s = (xp0 + xp1)
446 449      if ((s == big0))
447 450          then big0
448 451          else {
449 452              let a = parseIntValue(A)
450 453              let ann = (a * 2)
451 454              let p = fraction(xp0, xp1, big1)
452 455              let xp0_xp1_n_n = fraction(p, big4, big1)
453 456              let ann_s = fraction(toBigInt(ann), s, big1)
454 457              let ann_1 = toBigInt((ann - 1))
455 458              func calcDNext (d) =             {
456 459                  let dd = fraction(d, d, big1)
457 460                  let ddd = fraction(dd, d, big1)
458 461                  let dp = fraction(ddd, big1, xp0_xp1_n_n)
459 462                  fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)), CEILING)
460 463                  }
461 464  
462 465              func calc (acc,i) =             if (acc._2)
463 466                  then acc
464 467                  else {
465 468                      let d = acc._1
466 469                      let dNext = calcDNext(d)
467 470                      let dDiffRaw = toInt((dNext - value(d)))
468 471                      let dDiff = if ((0 > dDiffRaw))
469 472                          then -(dDiffRaw)
470 473                          else dDiffRaw
471 474                      if ((1 >= dDiff))
472 475                          then $Tuple2(dNext, true)
473 476                          else $Tuple2(dNext, false)
474 477                      }
475 478  
476 479              let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
477 -             let $t02014520193 = {
480 +             let $t02038520433 = {
478 481                  let $l = arr
479 482                  let $s = size($l)
480 483                  let $acc0 = $Tuple2(s, false)
481 484                  func $f0_1 ($a,$i) =                 if (($i >= $s))
482 485                      then $a
483 486                      else calc($a, $l[$i])
484 487  
485 488                  func $f0_2 ($a,$i) =                 if (($i >= $s))
486 489                      then $a
487 490                      else throw("List size exceeds 15")
488 491  
489 492                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
490 493                  }
491 -             let d = $t02014520193._1
492 -             let found = $t02014520193._2
494 +             let d = $t02038520433._1
495 +             let found = $t02038520433._2
493 496              if (found)
494 497                  then d
495 498                  else throw(("D calculation error, D = " + toString(d)))
496 499              }
497 500      }
498 501  
499 502  
500 503  func getDOld (xp) = {
501 504      let n = big2
502 505      let xp0 = xp[0]
503 506      let xp1 = xp[1]
504 507      let aPrecision = parseBigIntValue(Amult)
505 508      let a = (parseBigIntValue(A) * aPrecision)
506 509      let s = (xp0 + xp1)
507 510      if ((s == big0))
508 511          then big0
509 512          else {
510 513              let ann = (a * n)
511 514              let xp0_xp1_n_n = (((xp0 * xp1) * n) * n)
512 515              let ann_s_aPrecision = ((ann * s) / aPrecision)
513 516              let ann_aPrecision = (ann - aPrecision)
514 517              let n1 = (n + big1)
515 518              func calc (acc,cur) =             {
516 -                 let $t02082220842 = acc
517 -                 let d = $t02082220842._1
518 -                 let found = $t02082220842._2
519 +                 let $t02106221082 = acc
520 +                 let d = $t02106221082._1
521 +                 let found = $t02106221082._2
519 522                  if ((found != unit))
520 523                      then acc
521 524                      else {
522 525                          let dp = (((d * d) * d) / xp0_xp1_n_n)
523 526                          let dNext = (((ann_s_aPrecision + (dp * n)) * d) / (((ann_aPrecision * d) / aPrecision) + (n1 * dp)))
524 527                          let dDiff = absBigInt((dNext - value(d)))
525 528                          if ((big1 >= dDiff))
526 529                              then $Tuple2(dNext, cur)
527 530                              else $Tuple2(dNext, unit)
528 531                          }
529 532                  }
530 533  
531 534              let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
532 -             let $t02126321310 = {
535 +             let $t02150321550 = {
533 536                  let $l = arr
534 537                  let $s = size($l)
535 538                  let $acc0 = $Tuple2(s, unit)
536 539                  func $f0_1 ($a,$i) =                 if (($i >= $s))
537 540                      then $a
538 541                      else calc($a, $l[$i])
539 542  
540 543                  func $f0_2 ($a,$i) =                 if (($i >= $s))
541 544                      then $a
542 545                      else throw("List size exceeds 15")
543 546  
544 547                  $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
545 548                  }
546 -             let d = $t02126321310._1
547 -             let found = $t02126321310._2
549 +             let d = $t02150321550._1
550 +             let found = $t02150321550._2
548 551              if ((found != unit))
549 552                  then d
550 553                  else throw(("D calculation error, D = " + toString(d)))
551 554              }
552 555      }
553 556  
554 557  
555 558  func getYD (xp,i,D) = {
556 559      let n = big2
557 560      let x = xp[if ((i == 0))
558 561          then 1
559 562          else 0]
560 563      let aPrecision = parseBigIntValue(Amult)
561 564      let a = (parseBigIntValue(A) * aPrecision)
562 565      let s = x
563 566      let ann = (a * n)
564 567      let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
565 568      let b = ((s + ((D * aPrecision) / ann)) - D)
566 569      func calc (acc,cur) =     {
567 -         let $t02181021830 = acc
568 -         let y = $t02181021830._1
569 -         let found = $t02181021830._2
570 +         let $t02205022070 = acc
571 +         let y = $t02205022070._1
572 +         let found = $t02205022070._2
570 573          if ((found != unit))
571 574              then acc
572 575              else {
573 576                  let yNext = (((y * y) + c) / ((big2 * y) + b))
574 577                  let yDiff = absBigInt((yNext - value(y)))
575 578                  if ((big1 >= yDiff))
576 579                      then $Tuple2(yNext, cur)
577 580                      else $Tuple2(yNext, unit)
578 581                  }
579 582          }
580 583  
581 584      let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
582 -     let $t02213722184 = {
585 +     let $t02237722424 = {
583 586          let $l = arr
584 587          let $s = size($l)
585 588          let $acc0 = $Tuple2(D, unit)
586 589          func $f0_1 ($a,$i) =         if (($i >= $s))
587 590              then $a
588 591              else calc($a, $l[$i])
589 592  
590 593          func $f0_2 ($a,$i) =         if (($i >= $s))
591 594              then $a
592 595              else throw("List size exceeds 15")
593 596  
594 597          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
595 598          }
596 -     let y = $t02213722184._1
597 -     let found = $t02213722184._2
599 +     let y = $t02237722424._1
600 +     let found = $t02237722424._2
598 601      if ((found != unit))
599 602          then y
600 603          else throw(("Y calculation error, Y = " + toString(y)))
601 604      }
602 605  
603 606  
604 607  func calcDLp (amountBalance,priceBalance,lpEmission) = {
605 608      let updatedDLp = fraction(getD([amountBalance, priceBalance]), scale18, lpEmission)
606 609      if ((lpEmission == big0))
607 610          then big0
608 611          else updatedDLp
609 612      }
610 613  
611 614  
612 615  func calcCurrentDLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
613 616      let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
614 617      let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
615 618      let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
616 619      let currentDLp = calcDLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
617 620      currentDLp
618 621      }
619 622  
620 623  
621 624  func refreshDLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
622 625      let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
623 626      let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
624 627      let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
625 628      let updatedDLp = calcDLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
626 629      let actions = [IntegerEntry(keyDLpRefreshedHeight, height), StringEntry(keyDLp, toString(updatedDLp))]
627 630      $Tuple2(actions, updatedDLp)
628 631      }
629 632  
630 633  
631 634  func validateUpdatedDLp (oldDLp,updatedDLp) = if ((updatedDLp >= oldDLp))
632 635      then true
633 636      else throwErr("updated DLp lower than current DLp")
634 637  
635 638  
636 639  func validateMatcherOrderAllowed (order) = {
637 640      let amountAssetAmount = order.amount
638 641      let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
639 -     let $t02412324335 = if ((order.orderType == Buy))
642 +     let $t02436324575 = if ((order.orderType == Buy))
640 643          then $Tuple2(amountAssetAmount, -(priceAssetAmount))
641 644          else $Tuple2(-(amountAssetAmount), priceAssetAmount)
642 -     let amountAssetBalanceDelta = $t02412324335._1
643 -     let priceAssetBalanceDelta = $t02412324335._2
645 +     let amountAssetBalanceDelta = $t02436324575._1
646 +     let priceAssetBalanceDelta = $t02436324575._2
644 647      if (if (if (igs())
645 648          then true
646 649          else (cfgPoolStatus == PoolMatcherDis))
647 650          then true
648 651          else (cfgPoolStatus == PoolShutdown))
649 652          then throw("Admin blocked")
650 653          else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
651 654              then true
652 655              else (order.assetPair.priceAsset != cfgPriceAssetId))
653 656              then throw("Wr assets")
654 657              else {
655 658                  let dLp = parseBigIntValue(getStringValue(this, keyDLp))
656 -                 let $t02466524765 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
657 -                 let unusedActions = $t02466524765._1
658 -                 let dLpNew = $t02466524765._2
659 +                 let $t02490525005 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
660 +                 let unusedActions = $t02490525005._1
661 +                 let dLpNew = $t02490525005._2
659 662                  let isOrderValid = (dLpNew >= dLp)
660 663                  isOrderValid
661 664                  }
662 665      }
663 666  
664 667  
665 668  func cg (i) = if ((size(i.payments) != 1))
666 669      then throw("1 pmnt exp")
667 670      else {
668 671          let pmt = value(i.payments[0])
669 672          let pmtAssetId = value(pmt.assetId)
670 673          let pmtAmt = pmt.amount
671 674          let r = ego(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
672 675          let outAmAmt = r._1
673 676          let outPrAmt = r._2
674 677          let sts = parseIntValue(r._9)
675 678          let state = r._10
676 679          if (if (igs())
677 680              then true
678 681              else (sts == PoolShutdown))
679 682              then throw(("Admin blocked: " + toString(sts)))
680 683              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
681 684          }
682 685  
683 686  
684 687  func cp (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
685 688      let r = epo(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, (txId == ""), emitLp, isOneAsset, validateSlippage, pmtAmt, pmtId)
686 689      let sts = parseIntValue(r._8)
687 690      if (if (if (igs())
688 691          then true
689 692          else (sts == PoolPutDis))
690 693          then true
691 694          else (sts == PoolShutdown))
692 695          then throw(("Blocked:" + toString(sts)))
693 696          else r
694 697      }
695 698  
696 699  
697 700  func calcPutOneTkn (pmtAmtRaw,pmtAssetId,userAddress,txId,withTakeFee) = {
698 701      let poolConfig = gpc()
699 702      let amId = poolConfig[idxAmAsId]
700 703      let prId = poolConfig[idxPrAsId]
701 704      let lpId = poolConfig[idxLPAsId]
702 705      let amtDcm = parseIntValue(poolConfig[idxAmtAsDcm])
703 706      let priceDcm = parseIntValue(poolConfig[idxPriceAsDcm])
704 707      let lpAssetEmission = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "invalid lp asset").quantity)
705 708      let chechEmission = if ((lpAssetEmission > big0))
706 709          then true
707 710          else throw("initial deposit requires all coins")
708 711      if ((chechEmission == chechEmission))
709 712          then {
710 713              let amBalance = getAccBalance(amId)
711 714              let prBalance = getAccBalance(prId)
712 -             let $t02708227544 = if ((txId == ""))
715 +             let $t02732227784 = if ((txId == ""))
713 716                  then $Tuple2(amBalance, prBalance)
714 717                  else if ((pmtAssetId == amId))
715 718                      then if ((pmtAmtRaw > amBalance))
716 719                          then throw("invalid payment amount")
717 720                          else $Tuple2((amBalance - pmtAmtRaw), prBalance)
718 721                      else if ((pmtAssetId == prId))
719 722                          then if ((pmtAmtRaw > prBalance))
720 723                              then throw("invalid payment amount")
721 724                              else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
722 725                          else throw("wrong pmtAssetId")
723 -             let amBalanceOld = $t02708227544._1
724 -             let prBalanceOld = $t02708227544._2
725 -             let $t02755027726 = if ((pmtAssetId == amId))
726 +             let amBalanceOld = $t02732227784._1
727 +             let prBalanceOld = $t02732227784._2
728 +             let $t02779027966 = if ((pmtAssetId == amId))
726 729                  then $Tuple2(pmtAmtRaw, 0)
727 730                  else if ((pmtAssetId == prId))
728 731                      then $Tuple2(0, pmtAmtRaw)
729 732                      else throw("invalid payment")
730 -             let amAmountRaw = $t02755027726._1
731 -             let prAmountRaw = $t02755027726._2
732 -             let $t02773027969 = if (withTakeFee)
733 +             let amAmountRaw = $t02779027966._1
734 +             let prAmountRaw = $t02779027966._2
735 +             let $t02797028209 = if (withTakeFee)
733 736                  then $Tuple3(takeFee(amAmountRaw)._1, takeFee(prAmountRaw)._1, takeFee(pmtAmtRaw)._2)
734 737                  else $Tuple3(amAmountRaw, prAmountRaw, 0)
735 -             let amAmount = $t02773027969._1
736 -             let prAmount = $t02773027969._2
737 -             let feeAmount = $t02773027969._3
738 +             let amAmount = $t02797028209._1
739 +             let prAmount = $t02797028209._2
740 +             let feeAmount = $t02797028209._3
738 741              let amBalanceNew = (amBalanceOld + amAmount)
739 742              let prBalanceNew = (prBalanceOld + prAmount)
740 743              let D0 = getD([toBigInt(amBalanceOld), toBigInt(prBalanceOld)])
741 744              let D1 = getD([toBigInt(amBalanceNew), toBigInt(prBalanceNew)])
742 745              let checkD = if ((D1 > D0))
743 746                  then true
744 747                  else throw()
745 748              if ((checkD == checkD))
746 749                  then {
747 750                      let lpAmount = fraction(lpAssetEmission, (D1 - D0), D0, FLOOR)
748 751                      let curPrice = f1(cpbi(t1(prBalanceNew, priceDcm), t1(amBalanceNew, amtDcm)), scale8)
749 752                      let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId), dataPutActionInfo(amAmountRaw, prAmountRaw, toInt(lpAmount), curPrice, 0, 0, height, lastBlock.timestamp, 0, 0))]
750 753                      let poolProportion = fraction(prBalanceOld, scale8, amBalanceOld)
751 754                      let amountAssetPart = fraction(pmtAmtRaw, scale8, (poolProportion + scale8))
752 755                      let priceAssetPart = (pmtAmtRaw - amountAssetPart)
753 756                      let lpAmtBoth = fraction(lpAssetEmission, toBigInt(priceAssetPart), toBigInt(prBalanceOld))
754 757                      let bonus = toInt(fraction((lpAmount - lpAmtBoth), scale8BigInt, lpAmtBoth))
755 758                      $Tuple4(toInt(lpAmount), commonState, feeAmount, bonus)
756 759                      }
757 760                  else throw("Strict value is not equal to itself.")
758 761              }
759 762          else throw("Strict value is not equal to itself.")
760 763      }
761 764  
762 765  
763 766  func getOneTknV2Internal (outAssetId,minOutAmount,payments,caller,originCaller,transactionId) = {
764 767      let poolConfig = gpc()
765 768      let lpId = poolConfig[idxLPAsId]
766 769      let amId = poolConfig[idxAmAsId]
767 770      let prId = poolConfig[idxPrAsId]
768 771      let amDecimals = parseIntValue(poolConfig[idxAmtAsDcm])
769 772      let prDecimals = parseIntValue(poolConfig[idxPriceAsDcm])
770 773      let poolStatus = poolConfig[idxPoolSt]
771 774      let userAddress = if ((caller == restContract))
772 775          then originCaller
773 776          else caller
774 777      let pmt = value(payments[0])
775 778      let pmtAssetId = value(pmt.assetId)
776 779      let pmtAmt = pmt.amount
777 780      let currentDLp = calcCurrentDLp(big0, big0, big0)
778 781      if ((currentDLp == currentDLp))
779 782          then {
780 783              let txId58 = toBase58String(transactionId)
781 784              if ((lpId != toBase58String(pmtAssetId)))
782 785                  then throw("Wrong LP")
783 786                  else {
784 787                      let amBalance = getAccBalance(amId)
785 788                      let prBalance = getAccBalance(prId)
786 -                     let $t03003430145 = {
789 +                     let $t03027430385 = {
787 790                          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
788 791                          if ($isInstanceOf(@, "(Int, Int)"))
789 792                              then @
790 793                              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
791 794                          }
792 -                     if (($t03003430145 == $t03003430145))
795 +                     if (($t03027430385 == $t03027430385))
793 796                          then {
794 -                             let feeAmount = $t03003430145._2
795 -                             let totalGet = $t03003430145._1
797 +                             let feeAmount = $t03027430385._2
798 +                             let totalGet = $t03027430385._1
796 799                              let totalAmount = if (if ((minOutAmount > 0))
797 800                                  then (minOutAmount > totalGet)
798 801                                  else false)
799 802                                  then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
800 803                                  else totalGet
801 -                             let $t03033530642 = if ((outAssetId == amId))
804 +                             let $t03057530882 = if ((outAssetId == amId))
802 805                                  then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
803 806                                  else if ((outAssetId == prId))
804 807                                      then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
805 808                                      else throw("invalid out asset id")
806 -                             let outAm = $t03033530642._1
807 -                             let outPr = $t03033530642._2
808 -                             let amBalanceNew = $t03033530642._3
809 -                             let prBalanceNew = $t03033530642._4
809 +                             let outAm = $t03057530882._1
810 +                             let outPr = $t03057530882._2
811 +                             let amBalanceNew = $t03057530882._3
812 +                             let prBalanceNew = $t03057530882._4
810 813                              let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
811 814                              let curPr = f1(curPrX18, scale8)
812 815                              let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
813 816                                  then unit
814 817                                  else fromBase58String(outAssetId)
815 818                              let sendFeeToMatcher = if ((feeAmount > 0))
816 819                                  then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetIdOrWaves)]
817 820                                  else nil
818 821                              let state = ([ScriptTransfer(userAddress, totalAmount, outAssetIdOrWaves), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)] ++ sendFeeToMatcher)
819 822                              if ((state == state))
820 823                                  then {
821 824                                      let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
822 825                                      if ((burn == burn))
823 826                                          then {
824 -                                             let $t03142731777 = {
827 +                                             let $t03166732017 = {
825 828                                                  let feeAmountForCalc = if ((this == feeCollectorAddress))
826 829                                                      then 0
827 830                                                      else feeAmount
828 831                                                  let outInAmountAsset = if ((parseAssetId(outAssetId) == cfgAmountAssetId))
829 832                                                      then true
830 833                                                      else false
831 834                                                  if (outInAmountAsset)
832 835                                                      then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
833 836                                                      else $Tuple2(0, -((totalGet + feeAmountForCalc)))
834 837                                                  }
835 -                                             let amountAssetBalanceDelta = $t03142731777._1
836 -                                             let priceAssetBalanceDelta = $t03142731777._2
837 -                                             let $t03178031888 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
838 -                                             let refreshDLpActions = $t03178031888._1
839 -                                             let updatedDLp = $t03178031888._2
838 +                                             let amountAssetBalanceDelta = $t03166732017._1
839 +                                             let priceAssetBalanceDelta = $t03166732017._2
840 +                                             let $t03202032128 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
841 +                                             let refreshDLpActions = $t03202032128._1
842 +                                             let updatedDLp = $t03202032128._2
840 843                                              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
841 844                                              if ((isUpdatedDLpValid == isUpdatedDLpValid))
842 845                                                  then $Tuple2((state ++ refreshDLpActions), totalAmount)
843 846                                                  else throw("Strict value is not equal to itself.")
844 847                                              }
845 848                                          else throw("Strict value is not equal to itself.")
846 849                                      }
847 850                                  else throw("Strict value is not equal to itself.")
848 851                              }
849 852                          else throw("Strict value is not equal to itself.")
850 853                      }
851 854              }
852 855          else throw("Strict value is not equal to itself.")
853 856      }
854 857  
855 858  
856 859  func m () = match getString(mpk()) {
857 860      case s: String => 
858 861          fromBase58String(s)
859 862      case _: Unit => 
860 863          unit
861 864      case _ => 
862 865          throw("Match error")
863 866  }
864 867  
865 868  
866 869  func pm () = match getString(pmpk()) {
867 870      case s: String => 
868 871          fromBase58String(s)
869 872      case _: Unit => 
870 873          unit
871 874      case _ => 
872 875          throw("Match error")
873 876  }
874 877  
875 878  
876 879  let pd = throw("Permission denied")
877 880  
878 881  func isManager (i) = match m() {
879 882      case pk: ByteVector => 
880 883          (i.callerPublicKey == pk)
881 884      case _: Unit => 
882 885          (i.caller == this)
883 886      case _ => 
884 887          throw("Match error")
885 888  }
886 889  
887 890  
888 891  func mm (i) = match m() {
889 892      case pk: ByteVector => 
890 893          if ((i.callerPublicKey == pk))
891 894              then true
892 895              else pd
893 896      case _: Unit => 
894 897          if ((i.caller == this))
895 898              then true
896 899              else pd
897 900      case _ => 
898 901          throw("Match error")
899 902  }
900 903  
901 904  
902 905  @Callable(i)
903 906  func constructor (fc) = {
904 907      let c = mm(i)
905 908      if ((c == c))
906 909          then [StringEntry(fc(), fc)]
907 910          else throw("Strict value is not equal to itself.")
908 911      }
909 912  
910 913  
911 914  
912 915  @Callable(i)
913 916  func setManager (pendingManagerPublicKey) = {
914 917      let c = mm(i)
915 918      if ((c == c))
916 919          then {
917 920              let cm = fromBase58String(pendingManagerPublicKey)
918 921              if ((cm == cm))
919 922                  then [StringEntry(pmpk(), pendingManagerPublicKey)]
920 923                  else throw("Strict value is not equal to itself.")
921 924              }
922 925          else throw("Strict value is not equal to itself.")
923 926      }
924 927  
925 928  
926 929  
927 930  @Callable(i)
928 931  func confirmManager () = {
929 932      let p = pm()
930 933      let hpm = if (isDefined(p))
931 934          then true
932 935          else throw("No pending manager")
933 936      if ((hpm == hpm))
934 937          then {
935 938              let cpm = if ((i.callerPublicKey == value(p)))
936 939                  then true
937 940                  else throw("You are not pending manager")
938 941              if ((cpm == cpm))
939 942                  then [StringEntry(mpk(), toBase58String(value(p))), DeleteEntry(pmpk())]
940 943                  else throw("Strict value is not equal to itself.")
941 944              }
942 945          else throw("Strict value is not equal to itself.")
943 946      }
944 947  
945 948  
946 949  
947 950  @Callable(i)
948 951  func put (slip,autoStake) = {
949 952      let factCfg = gfc()
950 953      let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
951 954      let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
952 955      if ((0 > slip))
953 956          then throw("Wrong slippage")
954 957          else if ((size(i.payments) != 2))
955 958              then throw("2 pmnts expd")
956 959              else {
957 960                  let amAssetPmt = toBigInt(value(i.payments[0]).amount)
958 961                  let prAssetPmt = toBigInt(value(i.payments[1]).amount)
959 962                  let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
960 963                  if ((currentDLp == currentDLp))
961 964                      then {
962 965                          let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, true, 0, "")
963 966                          let emitLpAmt = e._2
964 967                          let lpAssetId = e._7
965 968                          let state = e._9
966 969                          let amDiff = e._10
967 970                          let prDiff = e._11
968 971                          let amId = e._12
969 972                          let prId = e._13
970 973                          let r = invoke(fca, "emit", [emitLpAmt], nil)
971 974                          if ((r == r))
972 975                              then {
973 976                                  let el =                                 match r {
974 977                                      case legacy: Address => 
975 978                                          invoke(legacy, "emit", [emitLpAmt], nil)
976 979                                      case _ => 
977 980                                          unit
978 981                                  }
979 982                                  if ((el == el))
980 983                                      then {
981 984                                          let sa = if ((amDiff > 0))
982 985                                              then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
983 986                                              else nil
984 987                                          if ((sa == sa))
985 988                                              then {
986 989                                                  let sp = if ((prDiff > 0))
987 990                                                      then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
988 991                                                      else nil
989 992                                                  if ((sp == sp))
990 993                                                      then {
991 994                                                          let lpTrnsfr = if (autoStake)
992 995                                                              then {
993 996                                                                  let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
994 997                                                                  if ((ss == ss))
995 998                                                                      then nil
996 999                                                                      else throw("Strict value is not equal to itself.")
997 1000                                                                  }
998 1001                                                              else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
999 -                                                         let $t03574435809 = refreshDLpInternal(0, 0, 0)
1000 -                                                         let refreshDLpActions = $t03574435809._1
1001 -                                                         let updatedDLp = $t03574435809._2
1002 +                                                         let $t03598436049 = refreshDLpInternal(0, 0, 0)
1003 +                                                         let refreshDLpActions = $t03598436049._1
1004 +                                                         let updatedDLp = $t03598436049._2
1002 1005                                                          let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1003 1006                                                          if ((isUpdatedDLpValid == isUpdatedDLpValid))
1004 1007                                                              then ((state ++ lpTrnsfr) ++ refreshDLpActions)
1005 1008                                                              else throw("Strict value is not equal to itself.")
1006 1009                                                          }
1007 1010                                                      else throw("Strict value is not equal to itself.")
1008 1011                                                  }
1009 1012                                              else throw("Strict value is not equal to itself.")
1010 1013                                          }
1011 1014                                      else throw("Strict value is not equal to itself.")
1012 1015                                  }
1013 1016                              else throw("Strict value is not equal to itself.")
1014 1017                          }
1015 1018                      else throw("Strict value is not equal to itself.")
1016 1019                  }
1017 1020      }
1018 1021  
1019 1022  
1020 1023  
1021 1024  @Callable(i)
1022 1025  func putOneTknV2 (minOutAmount,autoStake) = {
1023 1026      let isPoolOneTokenOperationsDisabled = {
1024 1027          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1025 1028          if ($isInstanceOf(@, "Boolean"))
1026 1029              then @
1027 1030              else throw(($getType(@) + " couldn't be cast to Boolean"))
1028 1031          }
1029 1032      let isPutDisabled = if (if (if (igs())
1030 1033          then true
1031 1034          else (cfgPoolStatus == PoolPutDis))
1032 1035          then true
1033 1036          else (cfgPoolStatus == PoolShutdown))
1034 1037          then true
1035 1038          else isPoolOneTokenOperationsDisabled
1036 1039      let checks = [if (if (!(isPutDisabled))
1037 1040          then true
1038 1041          else isManager(i))
1039 1042          then true
1040 1043          else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
1041 1044          then true
1042 1045          else throwErr("exactly 1 payment are expected")]
1043 1046      if ((checks == checks))
1044 1047          then {
1045 1048              let poolConfig = gpc()
1046 1049              let amId = poolConfig[idxAmAsId]
1047 1050              let prId = poolConfig[idxPrAsId]
1048 1051              let lpId = fromBase58String(poolConfig[idxLPAsId])
1049 1052              let amDecimals = parseIntValue(poolConfig[idxAmtAsDcm])
1050 1053              let prDecimals = parseIntValue(poolConfig[idxPriceAsDcm])
1051 1054              let userAddress = if ((i.caller == this))
1052 1055                  then i.originCaller
1053 1056                  else i.caller
1054 1057              let pmt = value(i.payments[0])
1055 1058              let pmtAssetId = toBase58String(value(pmt.assetId))
1056 1059              let pmtAmt = pmt.amount
1057 -             let $t03694637104 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1058 -             if (($t03694637104 == $t03694637104))
1060 +             let $t03718637344 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1061 +             if (($t03718637344 == $t03718637344))
1059 1062                  then {
1060 -                     let feeAmount = $t03694637104._3
1061 -                     let state = $t03694637104._2
1062 -                     let estimLP = $t03694637104._1
1063 +                     let feeAmount = $t03718637344._3
1064 +                     let state = $t03718637344._2
1065 +                     let estimLP = $t03718637344._1
1063 1066                      let emitLpAmt = if (if ((minOutAmount > 0))
1064 1067                          then (minOutAmount > estimLP)
1065 1068                          else false)
1066 1069                          then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
1067 1070                          else estimLP
1068 1071                      let e = invoke(fca, "emit", [emitLpAmt], nil)
1069 1072                      if ((e == e))
1070 1073                          then {
1071 1074                              let el =                             match e {
1072 1075                                  case legacy: Address => 
1073 1076                                      invoke(legacy, "emit", [emitLpAmt], nil)
1074 1077                                  case _ => 
1075 1078                                      unit
1076 1079                              }
1077 1080                              if ((el == el))
1078 1081                                  then {
1079 1082                                      let lpTrnsfr = if (autoStake)
1080 1083                                          then {
1081 1084                                              let ss = invoke(stakingContract, "stake", nil, [AttachedPayment(lpId, emitLpAmt)])
1082 1085                                              if ((ss == ss))
1083 1086                                                  then nil
1084 1087                                                  else throw("Strict value is not equal to itself.")
1085 1088                                              }
1086 1089                                          else [ScriptTransfer(i.caller, emitLpAmt, lpId)]
1087 1090                                      let sendFeeToMatcher = if ((feeAmount > 0))
1088 1091                                          then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1089 1092                                          else nil
1090 -                                     let $t03791938268 = if ((this == feeCollectorAddress))
1093 +                                     let $t03815938508 = if ((this == feeCollectorAddress))
1091 1094                                          then $Tuple2(0, 0)
1092 1095                                          else {
1093 1096                                              let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))
1094 1097                                                  then true
1095 1098                                                  else false
1096 1099                                              if (paymentInAmountAsset)
1097 1100                                                  then $Tuple2(-(feeAmount), 0)
1098 1101                                                  else $Tuple2(0, -(feeAmount))
1099 1102                                              }
1100 -                                     let amountAssetBalanceDelta = $t03791938268._1
1101 -                                     let priceAssetBalanceDelta = $t03791938268._2
1102 -                                     let $t03827138379 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1103 -                                     let refreshDLpActions = $t03827138379._1
1104 -                                     let updatedDLp = $t03827138379._2
1103 +                                     let amountAssetBalanceDelta = $t03815938508._1
1104 +                                     let priceAssetBalanceDelta = $t03815938508._2
1105 +                                     let $t03851138619 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1106 +                                     let refreshDLpActions = $t03851138619._1
1107 +                                     let updatedDLp = $t03851138619._2
1105 1108                                      $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)
1106 1109                                      }
1107 1110                                  else throw("Strict value is not equal to itself.")
1108 1111                              }
1109 1112                          else throw("Strict value is not equal to itself.")
1110 1113                      }
1111 1114                  else throw("Strict value is not equal to itself.")
1112 1115              }
1113 1116          else throw("Strict value is not equal to itself.")
1114 1117      }
1115 1118  
1116 1119  
1117 1120  
1118 1121  @Callable(i)
1119 1122  func putForFree (maxSlpg) = if ((0 > maxSlpg))
1120 1123      then throw("Wrong slpg")
1121 1124      else if ((size(i.payments) != 2))
1122 1125          then throw("2 pmnts expd")
1123 1126          else {
1124 1127              let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, true, 0, "")
1125 1128              let state = estPut._9
1126 1129              let amAssetPmt = toBigInt(value(i.payments[0]).amount)
1127 1130              let prAssetPmt = toBigInt(value(i.payments[1]).amount)
1128 1131              let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1129 1132              if ((currentDLp == currentDLp))
1130 1133                  then {
1131 -                     let $t03933839403 = refreshDLpInternal(0, 0, 0)
1132 -                     let refreshDLpActions = $t03933839403._1
1133 -                     let updatedDLp = $t03933839403._2
1134 +                     let $t03957839643 = refreshDLpInternal(0, 0, 0)
1135 +                     let refreshDLpActions = $t03957839643._1
1136 +                     let updatedDLp = $t03957839643._2
1134 1137                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1135 1138                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1136 1139                          then (state ++ refreshDLpActions)
1137 1140                          else throw("Strict value is not equal to itself.")
1138 1141                      }
1139 1142                  else throw("Strict value is not equal to itself.")
1140 1143              }
1141 1144  
1142 1145  
1143 1146  
1144 1147  @Callable(i)
1145 1148  func get () = {
1146 1149      let r = cg(i)
1147 1150      let outAmtAmt = r._1
1148 1151      let outPrAmt = r._2
1149 1152      let pmtAmt = r._3
1150 1153      let pmtAssetId = r._4
1151 1154      let state = r._5
1152 1155      let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1153 1156      if ((b == b))
1154 1157          then {
1155 1158              let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(pmtAmt))
1156 -             let $t04019240274 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1157 -             let refreshDLpActions = $t04019240274._1
1158 -             let updatedDLp = $t04019240274._2
1159 +             let $t04043240514 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1160 +             let refreshDLpActions = $t04043240514._1
1161 +             let updatedDLp = $t04043240514._2
1159 1162              let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1160 1163              if ((isUpdatedDLpValid == isUpdatedDLpValid))
1161 1164                  then (state ++ refreshDLpActions)
1162 1165                  else throw("Strict value is not equal to itself.")
1163 1166              }
1164 1167          else throw("Strict value is not equal to itself.")
1165 1168      }
1166 1169  
1167 1170  
1168 1171  
1169 1172  @Callable(i)
1170 1173  func getOneTknV2 (outAssetId,minOutAmount) = {
1171 1174      let isPoolOneTokenOperationsDisabled = {
1172 1175          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1173 1176          if ($isInstanceOf(@, "Boolean"))
1174 1177              then @
1175 1178              else throw(($getType(@) + " couldn't be cast to Boolean"))
1176 1179          }
1177 1180      let isGetDisabled = if (if (igs())
1178 1181          then true
1179 1182          else (cfgPoolStatus == PoolShutdown))
1180 1183          then true
1181 1184          else isPoolOneTokenOperationsDisabled
1182 1185      let checks = [if (if (!(isGetDisabled))
1183 1186          then true
1184 1187          else isManager(i))
1185 1188          then true
1186 1189          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
1187 1190          then true
1188 1191          else throwErr("exactly 1 payment are expected")]
1189 1192      if ((checks == checks))
1190 1193          then {
1191 -             let $t04089241047 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1192 -             let state = $t04089241047._1
1193 -             let totalAmount = $t04089241047._2
1194 +             let $t04113241287 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1195 +             let state = $t04113241287._1
1196 +             let totalAmount = $t04113241287._2
1194 1197              $Tuple2(state, totalAmount)
1195 1198              }
1196 1199          else throw("Strict value is not equal to itself.")
1197 1200      }
1198 1201  
1199 1202  
1200 1203  
1201 1204  @Callable(i)
1202 1205  func refreshDLp () = {
1203 1206      let lastRefreshedBlockHeight = valueOrElse(getInteger(keyDLpRefreshedHeight), 0)
1204 1207      let checkLastRefreshedBlockHeight = if (((height - lastRefreshedBlockHeight) >= dLpRefreshDelay))
1205 1208          then unit
1206 1209          else throwErr(makeString([toString(dLpRefreshDelay), " blocks have not passed since the previous call"], ""))
1207 1210      if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1208 1211          then {
1209 1212              let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1210 -             let $t04157141635 = refreshDLpInternal(0, 0, 0)
1211 -             let dLpUpdateActions = $t04157141635._1
1212 -             let updatedDLp = $t04157141635._2
1213 +             let $t04181141875 = refreshDLpInternal(0, 0, 0)
1214 +             let dLpUpdateActions = $t04181141875._1
1215 +             let updatedDLp = $t04181141875._2
1213 1216              let actions = if ((dLp != updatedDLp))
1214 1217                  then dLpUpdateActions
1215 1218                  else throwErr("nothing to refresh")
1216 1219              $Tuple2(actions, toString(updatedDLp))
1217 1220              }
1218 1221          else throw("Strict value is not equal to itself.")
1219 1222      }
1220 1223  
1221 1224  
1222 1225  
1223 1226  @Callable(i)
1224 1227  func getOneTknV2READONLY (outAssetId,lpAssetAmount) = {
1225 1228      let poolConfig = gpc()
1226 1229      let amId = poolConfig[idxAmAsId]
1227 1230      let prId = poolConfig[idxPrAsId]
1228 1231      let lpId = poolConfig[idxLPAsId]
1229 1232      let xp = [toBigInt(getAccBalance(amId)), toBigInt(getAccBalance(prId))]
1230 1233      let lpEmission = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "invalid lp asset").quantity)
1231 1234      let D0 = getD(xp)
1232 1235      let D1 = (D0 - fraction(toBigInt(lpAssetAmount), D0, lpEmission))
1233 1236      let index = if ((outAssetId == amId))
1234 1237          then 0
1235 1238          else if ((outAssetId == prId))
1236 1239              then 1
1237 1240              else throw("invalid out asset id")
1238 1241      let newY = getYD(xp, index, D1)
1239 1242      let dy = (xp[index] - newY)
1240 1243      let totalGetRaw = max([0, toInt((dy - big1))])
1241 -     let $t04253542584 = takeFee(totalGetRaw)
1242 -     let totalGet = $t04253542584._1
1243 -     let feeAmount = $t04253542584._2
1244 +     let $t04277542824 = takeFee(totalGetRaw)
1245 +     let totalGet = $t04277542824._1
1246 +     let feeAmount = $t04277542824._2
1244 1247      $Tuple2(nil, $Tuple2(totalGet, feeAmount))
1245 1248      }
1246 1249  
1247 1250  
1248 1251  
1249 1252  @Callable(i)
1250 1253  func getOneTknV2WithBonusREADONLY (outAssetId,lpAssetAmount) = {
1251 1254      let poolConfig = gpc()
1252 1255      let amId = poolConfig[idxAmAsId]
1253 1256      let prId = poolConfig[idxPrAsId]
1254 1257      let lpId = poolConfig[idxLPAsId]
1255 1258      let amBalance = getAccBalance(amId)
1256 1259      let prBalance = getAccBalance(prId)
1257 -     let $t04292943044 = {
1260 +     let $t04316943284 = {
1258 1261          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1259 1262          if ($isInstanceOf(@, "(Int, Int)"))
1260 1263              then @
1261 1264              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1262 1265          }
1263 -     let totalGet = $t04292943044._1
1264 -     let feeAmount = $t04292943044._2
1266 +     let totalGet = $t04316943284._1
1267 +     let feeAmount = $t04316943284._2
1265 1268      let r = ego("", lpId, lpAssetAmount, this)
1266 1269      let outAmAmt = r._1
1267 1270      let outPrAmt = r._2
1268 1271      let sumOfGetAssets = (outAmAmt + outPrAmt)
1269 1272      let bonus = if ((sumOfGetAssets == 0))
1270 1273          then if ((totalGet == 0))
1271 1274              then 0
1272 1275              else throw("bonus calculation error")
1273 1276          else fraction((totalGet - sumOfGetAssets), scale8, sumOfGetAssets)
1274 1277      $Tuple2(nil, $Tuple3(totalGet, feeAmount, bonus))
1275 1278      }
1276 1279  
1277 1280  
1278 1281  
1279 1282  @Callable(i)
1280 1283  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
1281 1284      let r = cg(i)
1282 1285      let outAmAmt = r._1
1283 1286      let outPrAmt = r._2
1284 1287      let pmtAmt = r._3
1285 1288      let pmtAssetId = r._4
1286 1289      let state = r._5
1287 1290      if ((noLessThenAmtAsset > outAmAmt))
1288 1291          then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
1289 1292          else if ((noLessThenPriceAsset > outPrAmt))
1290 1293              then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
1291 1294              else {
1292 1295                  let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(pmtAmt))
1293 1296                  let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1294 1297                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1295 1298                      then {
1296 -                         let $t04421244293 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1297 -                         let refreshDLpActions = $t04421244293._1
1298 -                         let updatedDLp = $t04421244293._2
1299 +                         let $t04445244533 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1300 +                         let refreshDLpActions = $t04445244533._1
1301 +                         let updatedDLp = $t04445244533._2
1299 1302                          let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1300 1303                          if ((isUpdatedDLpValid == isUpdatedDLpValid))
1301 1304                              then (state ++ refreshDLpActions)
1302 1305                              else throw("Strict value is not equal to itself.")
1303 1306                          }
1304 1307                      else throw("Strict value is not equal to itself.")
1305 1308                  }
1306 1309      }
1307 1310  
1308 1311  
1309 1312  
1310 1313  @Callable(i)
1311 1314  func unstakeAndGet (amount) = {
1312 1315      let checkPayments = if ((size(i.payments) != 0))
1313 1316          then throw("No pmnts expd")
1314 1317          else true
1315 1318      if ((checkPayments == checkPayments))
1316 1319          then {
1317 1320              let cfg = gpc()
1318 1321              let factoryCfg = gfc()
1319 1322              let lpAssetId = fromBase58String(cfg[idxLPAsId])
1320 1323              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1321 1324              let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1322 1325              let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
1323 1326              if ((unstakeInv == unstakeInv))
1324 1327                  then {
1325 1328                      let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1326 1329                      let outAmAmt = r._1
1327 1330                      let outPrAmt = r._2
1328 1331                      let sts = parseIntValue(r._9)
1329 1332                      let state = r._10
1330 1333                      let v = if (if (igs())
1331 1334                          then true
1332 1335                          else (sts == PoolShutdown))
1333 1336                          then throw(("Blocked: " + toString(sts)))
1334 1337                          else true
1335 1338                      if ((v == v))
1336 1339                          then {
1337 1340                              let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1338 1341                              if ((burnA == burnA))
1339 1342                                  then {
1340 -                                     let $t04535645437 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1341 -                                     let refreshDLpActions = $t04535645437._1
1342 -                                     let updatedDLp = $t04535645437._2
1343 +                                     let $t04559645677 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1344 +                                     let refreshDLpActions = $t04559645677._1
1345 +                                     let updatedDLp = $t04559645677._2
1343 1346                                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1344 1347                                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1345 1348                                          then (state ++ refreshDLpActions)
1346 1349                                          else throw("Strict value is not equal to itself.")
1347 1350                                      }
1348 1351                                  else throw("Strict value is not equal to itself.")
1349 1352                              }
1350 1353                          else throw("Strict value is not equal to itself.")
1351 1354                      }
1352 1355                  else throw("Strict value is not equal to itself.")
1353 1356              }
1354 1357          else throw("Strict value is not equal to itself.")
1355 1358      }
1356 1359  
1357 1360  
1358 1361  
1359 1362  @Callable(i)
1360 1363  func unstakeAndGetNoLess (unstakeAmount,noLessThenAmountAsset,noLessThenPriceAsset) = {
1361 1364      let isGetDisabled = if (igs())
1362 1365          then true
1363 1366          else (cfgPoolStatus == PoolShutdown)
1364 1367      let checks = [if (!(isGetDisabled))
1365 1368          then true
1366 1369          else throw("get operation is blocked by admin"), if ((size(i.payments) == 0))
1367 1370          then true
1368 1371          else throw("no payments are expected")]
1369 1372      if ((checks == checks))
1370 1373          then {
1371 1374              let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1372 1375              let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1373 1376              if ((unstakeInv == unstakeInv))
1374 1377                  then {
1375 1378                      let res = ego(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1376 1379                      let outAmAmt = res._1
1377 1380                      let outPrAmt = res._2
1378 1381                      let state = res._10
1379 1382                      let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1380 1383                          then true
1381 1384                          else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1382 1385                          then true
1383 1386                          else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1384 1387                      if ((checkAmounts == checkAmounts))
1385 1388                          then {
1386 1389                              let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1387 1390                              if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1388 1391                                  then {
1389 -                                     let $t04668546766 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1390 -                                     let refreshDLpActions = $t04668546766._1
1391 -                                     let updatedDLp = $t04668546766._2
1392 +                                     let $t04692547006 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1393 +                                     let refreshDLpActions = $t04692547006._1
1394 +                                     let updatedDLp = $t04692547006._2
1392 1395                                      let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1393 1396                                      if ((isUpdatedDLpValid == isUpdatedDLpValid))
1394 1397                                          then (state ++ refreshDLpActions)
1395 1398                                          else throw("Strict value is not equal to itself.")
1396 1399                                      }
1397 1400                                  else throw("Strict value is not equal to itself.")
1398 1401                              }
1399 1402                          else throw("Strict value is not equal to itself.")
1400 1403                      }
1401 1404                  else throw("Strict value is not equal to itself.")
1402 1405              }
1403 1406          else throw("Strict value is not equal to itself.")
1404 1407      }
1405 1408  
1406 1409  
1407 1410  
1408 1411  @Callable(i)
1409 1412  func unstakeAndGetOneTknV2 (unstakeAmount,outAssetId,minOutAmount) = {
1410 1413      let isPoolOneTokenOperationsDisabled = {
1411 1414          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1412 1415          if ($isInstanceOf(@, "Boolean"))
1413 1416              then @
1414 1417              else throw(($getType(@) + " couldn't be cast to Boolean"))
1415 1418          }
1416 1419      let isGetDisabled = if (if (igs())
1417 1420          then true
1418 1421          else (cfgPoolStatus == PoolShutdown))
1419 1422          then true
1420 1423          else isPoolOneTokenOperationsDisabled
1421 1424      let checks = [if (if (!(isGetDisabled))
1422 1425          then true
1423 1426          else isManager(i))
1424 1427          then true
1425 1428          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 0))
1426 1429          then true
1427 1430          else throwErr("no payments are expected")]
1428 1431      if ((checks == checks))
1429 1432          then {
1430 1433              let cfg = gpc()
1431 1434              let factoryCfg = gfc()
1432 1435              let lpAssetId = fromBase58String(cfg[idxLPAsId])
1433 1436              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1434 1437              let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), unstakeAmount], nil)
1435 1438              if ((unstakeInv == unstakeInv))
1436 1439                  then {
1437 -                     let $t04770047888 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1438 -                     let state = $t04770047888._1
1439 -                     let totalAmount = $t04770047888._2
1440 +                     let $t04794048128 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1441 +                     let state = $t04794048128._1
1442 +                     let totalAmount = $t04794048128._2
1440 1443                      $Tuple2(state, totalAmount)
1441 1444                      }
1442 1445                  else throw("Strict value is not equal to itself.")
1443 1446              }
1444 1447          else throw("Strict value is not equal to itself.")
1445 1448      }
1446 1449  
1447 1450  
1448 1451  
1449 1452  @Callable(i)
1450 1453  func putOneTknV2WithBonusREADONLY (paymentAmountRaw,paymentAssetId) = {
1451 1454      let poolConfig = gpc()
1452 1455      let amId = poolConfig[idxAmAsId]
1453 1456      let prId = poolConfig[idxPrAsId]
1454 1457      let lpId = poolConfig[idxLPAsId]
1455 -     let $t04814748250 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1456 -     let lpAmount = $t04814748250._1
1457 -     let state = $t04814748250._2
1458 -     let feeAmount = $t04814748250._3
1459 -     let bonus = $t04814748250._4
1458 +     let $t04838748490 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1459 +     let lpAmount = $t04838748490._1
1460 +     let state = $t04838748490._2
1461 +     let feeAmount = $t04838748490._3
1462 +     let bonus = $t04838748490._4
1460 1463      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1461 1464      }
1462 1465  
1463 1466  
1464 1467  
1465 1468  @Callable(i)
1466 1469  func putOneTknV2WithoutTakeFeeREADONLY (paymentAmountRaw,paymentAssetId) = {
1467 1470      let poolConfig = gpc()
1468 1471      let amId = poolConfig[idxAmAsId]
1469 1472      let prId = poolConfig[idxPrAsId]
1470 1473      let lpId = poolConfig[idxLPAsId]
1471 -     let $t04852948633 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1472 -     let lpAmount = $t04852948633._1
1473 -     let state = $t04852948633._2
1474 -     let feeAmount = $t04852948633._3
1475 -     let bonus = $t04852948633._4
1474 +     let $t04876948873 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1475 +     let lpAmount = $t04876948873._1
1476 +     let state = $t04876948873._2
1477 +     let feeAmount = $t04876948873._3
1478 +     let bonus = $t04876948873._4
1476 1479      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1477 1480      }
1478 1481  
1479 1482  
1480 1483  
1481 1484  @Callable(i)
1482 1485  func activate (amtAsStr,prAsStr) = if ((toString(i.caller) != toString(fca)))
1483 1486      then throw("denied")
1484 1487      else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr)], "success")
1485 1488  
1486 1489  
1487 1490  
1488 1491  @Callable(i)
1489 1492  func setS (k,v) = if ((toString(i.caller) != strf(this, ada())))
1490 1493      then pd
1491 1494      else [StringEntry(k, v)]
1492 1495  
1493 1496  
1494 1497  
1495 1498  @Callable(i)
1496 1499  func setI (k,v) = if ((toString(i.caller) != strf(this, ada())))
1497 1500      then pd
1498 1501      else [IntegerEntry(k, v)]
1499 1502  
1500 1503  
1501 1504  
1502 1505  @Callable(i)
1503 1506  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, gpc())
1504 1507  
1505 1508  
1506 1509  
1507 1510  @Callable(i)
1508 1511  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
1509 1512  
1510 1513  
1511 1514  
1512 1515  @Callable(i)
1513 1516  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
1514 1517      let pr = calcPrices(amAmt, prAmt, lpAmt)
1515 1518      $Tuple2(nil, [toString(pr[0]), toString(pr[1]), toString(pr[2])])
1516 1519      }
1517 1520  
1518 1521  
1519 1522  
1520 1523  @Callable(i)
1521 1524  func fromX18WrapperREADONLY (val,resScaleMult) = $Tuple2(nil, f1(parseBigIntValue(val), resScaleMult))
1522 1525  
1523 1526  
1524 1527  
1525 1528  @Callable(i)
1526 1529  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(t1(origVal, origScaleMult)))
1527 1530  
1528 1531  
1529 1532  
1530 1533  @Callable(i)
1531 1534  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(cpbi(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
1532 1535  
1533 1536  
1534 1537  
1535 1538  @Callable(i)
1536 1539  func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,usrAddr,isEval,emitLp) = $Tuple2(nil, epo(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, usrAddr, isEval, emitLp, true, false, 0, ""))
1537 1540  
1538 1541  
1539 1542  
1540 1543  @Callable(i)
1541 1544  func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
1542 1545      let r = ego(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
1543 1546      $Tuple2(nil, $Tuple10(r._1, r._2, r._3, r._4, r._5, r._6, r._7, toString(r._8), r._9, r._10))
1544 1547      }
1545 1548  
1546 1549  
1547 1550  
1548 1551  @Callable(i)
1549 1552  func getFeeREADONLY () = $Tuple2(nil, fee)
1550 1553  
1551 1554  
1552 1555  @Verifier(tx)
1553 1556  func verify () = {
1554 1557      let targetPublicKey =     match m() {
1555 1558          case pk: ByteVector => 
1556 1559              pk
1557 1560          case _: Unit => 
1558 1561              tx.senderPublicKey
1559 1562          case _ => 
1560 1563              throw("Match error")
1561 1564      }
1562 1565      match tx {
1563 1566          case order: Order => 
1564 1567              let matcherPub = mp()
1565 1568              let orderValid = validateMatcherOrderAllowed(order)
1566 1569              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1567 1570              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1568 1571              if (if (if (orderValid)
1569 1572                  then senderValid
1570 1573                  else false)
1571 1574                  then matcherValid
1572 1575                  else false)
1573 1576                  then true
1574 1577                  else toe(orderValid, senderValid, matcherValid)
1575 1578          case s: SetScriptTransaction => 
1576 1579              let newHash = blake2b256(value(s.script))
1577 1580              let allowedHash = fromBase64String(value(getString(fca, keyAllowedLpStableScriptHash())))
1578 1581              let currentHash = scriptHash(this)
1579 1582              if (if ((allowedHash == newHash))
1580 1583                  then (currentHash != newHash)
1581 1584                  else false)
1582 1585                  then true
1583 1586                  else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1584 1587          case _ => 
1585 1588              sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1586 1589      }
1587 1590      }
1588 1591

Old	New		Differences
71	71
72	72
73	73		func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
	74	+
	75	+
	76	+	func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
74	77
75	78
76	79		func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)

213	216
214	217		let poolConfigParsed = parsePoolConfig(gpc())
215	218
216		-	let $~~t072557441~~ = poolConfigParsed
	219	+	let $t074067592 = poolConfigParsed
217	220
218		-	let cfgPoolAddress = $~~t072557441~~._1
	221	+	let cfgPoolAddress = $t074067592._1
219	222
220		-	let cfgPoolStatus = $~~t072557441~~._2
	223	+	let cfgPoolStatus = $t074067592._2
221	224
222		-	let cfgLpAssetId = $~~t072557441~~._3
	225	+	let cfgLpAssetId = $t074067592._3
223	226
224		-	let cfgAmountAssetId = $~~t072557441~~._4
	227	+	let cfgAmountAssetId = $t074067592._4
225	228
226		-	let cfgPriceAssetId = $~~t072557441~~._5
	229	+	let cfgPriceAssetId = $t074067592._5
227	230
228		-	let cfgAmountAssetDecimals = $~~t072557441~~._6
	231	+	let cfgAmountAssetDecimals = $t074067592._6
229	232
230		-	let cfgPriceAssetDecimals = $~~t072557441~~._7
	233	+	let cfgPriceAssetDecimals = $t074067592._7
231	234
232	235		func gfc () = split(strf(fca, fcfg()), SEP)
233	236

331	334		let lpEmissX18 = t1(lpEmiss, scale8)
332	335		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
333	336		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
334		-	let outAmAmt = f1(outAmAmtX18, amDcm)
335		-	let outPrAmt = f1(outPrAmtX18, prDcm)
	337	+	let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
	338	+	let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
336	339		let state = if ((txId58 == ""))
337	340		then nil
338	341		else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))

406	409		let expAmtAssetAmtX18 = expectedAmts._1
407	410		let expPriceAssetAmtX18 = expectedAmts._2
408	411		let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
409		-	$Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
	412	+	$Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
410	413		}
411	414		}
412	415		let calcLpAmt = r._1

422	425		else calcLpAmt
423	426		let amDiff = (inAmAmt - calcAmAssetPmt)
424	427		let prDiff = (inPrAmt - calcPrAssetPmt)
425		-	let $~~t01787218217~~ = if (if (isOneAsset)
	428	+	let $t01811218457 = if (if (isOneAsset)
426	429		then (pmtId == amIdStr)
427	430		else false)
428	431		then $Tuple2(pmtAmt, 0)

431	434		else false)
432	435		then $Tuple2(0, pmtAmt)
433	436		else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
434		-	let writeAmAmt = $~~t01787218217~~._1
435		-	let writePrAmt = $~~t01787218217~~._2
	437	+	let writeAmAmt = $t01811218457._1
	438	+	let writePrAmt = $t01811218457._2
436	439		let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
437	440		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
438	441		}

474	477		}
475	478
476	479		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
477		-	let $~~t02014520193~~ = {
	480	+	let $t02038520433 = {
478	481		let $l = arr
479	482		let $s = size($l)
480	483		let $acc0 = $Tuple2(s, false)

488	491
489	492		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
490	493		}
491		-	let d = $~~t02014520193~~._1
492		-	let found = $~~t02014520193~~._2
	494	+	let d = $t02038520433._1
	495	+	let found = $t02038520433._2
493	496		if (found)
494	497		then d
495	498		else throw(("D calculation error, D = " + toString(d)))

513	516		let ann_aPrecision = (ann - aPrecision)
514	517		let n1 = (n + big1)
515	518		func calc (acc,cur) = {
516		-	let $~~t02082220842~~ = acc
517		-	let d = $~~t02082220842~~._1
518		-	let found = $~~t02082220842~~._2
	519	+	let $t02106221082 = acc
	520	+	let d = $t02106221082._1
	521	+	let found = $t02106221082._2
519	522		if ((found != unit))
520	523		then acc
521	524		else {

529	532		}
530	533
531	534		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
532		-	let $~~t02126321310~~ = {
	535	+	let $t02150321550 = {
533	536		let $l = arr
534	537		let $s = size($l)
535	538		let $acc0 = $Tuple2(s, unit)

543	546
544	547		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
545	548		}
546		-	let d = $~~t02126321310~~._1
547		-	let found = $~~t02126321310~~._2
	549	+	let d = $t02150321550._1
	550	+	let found = $t02150321550._2
548	551		if ((found != unit))
549	552		then d
550	553		else throw(("D calculation error, D = " + toString(d)))

564	567		let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
565	568		let b = ((s + ((D * aPrecision) / ann)) - D)
566	569		func calc (acc,cur) = {
567		-	let $~~t02181021830~~ = acc
568		-	let y = $~~t02181021830~~._1
569		-	let found = $~~t02181021830~~._2
	570	+	let $t02205022070 = acc
	571	+	let y = $t02205022070._1
	572	+	let found = $t02205022070._2
570	573		if ((found != unit))
571	574		then acc
572	575		else {

579	582		}
580	583
581	584		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
582		-	let $~~t02213722184~~ = {
	585	+	let $t02237722424 = {
583	586		let $l = arr
584	587		let $s = size($l)
585	588		let $acc0 = $Tuple2(D, unit)

593	596
594	597		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
595	598		}
596		-	let y = $~~t02213722184~~._1
597		-	let found = $~~t02213722184~~._2
	599	+	let y = $t02237722424._1
	600	+	let found = $t02237722424._2
598	601		if ((found != unit))
599	602		then y
600	603		else throw(("Y calculation error, Y = " + toString(y)))

636	639		func validateMatcherOrderAllowed (order) = {
637	640		let amountAssetAmount = order.amount
638	641		let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
639		-	let $~~t02412324335~~ = if ((order.orderType == Buy))
	642	+	let $t02436324575 = if ((order.orderType == Buy))
640	643		then $Tuple2(amountAssetAmount, -(priceAssetAmount))
641	644		else $Tuple2(-(amountAssetAmount), priceAssetAmount)
642		-	let amountAssetBalanceDelta = $~~t02412324335~~._1
643		-	let priceAssetBalanceDelta = $~~t02412324335~~._2
	645	+	let amountAssetBalanceDelta = $t02436324575._1
	646	+	let priceAssetBalanceDelta = $t02436324575._2
644	647		if (if (if (igs())
645	648		then true
646	649		else (cfgPoolStatus == PoolMatcherDis))

653	656		then throw("Wr assets")
654	657		else {
655	658		let dLp = parseBigIntValue(getStringValue(this, keyDLp))
656		-	let $~~t02466524765~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
657		-	let unusedActions = $~~t02466524765~~._1
658		-	let dLpNew = $~~t02466524765~~._2
	659	+	let $t02490525005 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	660	+	let unusedActions = $t02490525005._1
	661	+	let dLpNew = $t02490525005._2
659	662		let isOrderValid = (dLpNew >= dLp)
660	663		isOrderValid
661	664		}

709	712		then {
710	713		let amBalance = getAccBalance(amId)
711	714		let prBalance = getAccBalance(prId)
712		-	let $~~t02708227544~~ = if ((txId == ""))
	715	+	let $t02732227784 = if ((txId == ""))
713	716		then $Tuple2(amBalance, prBalance)
714	717		else if ((pmtAssetId == amId))
715	718		then if ((pmtAmtRaw > amBalance))

720	723		then throw("invalid payment amount")
721	724		else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
722	725		else throw("wrong pmtAssetId")
723		-	let amBalanceOld = $~~t02708227544~~._1
724		-	let prBalanceOld = $~~t02708227544~~._2
725		-	let $~~t02755027726~~ = if ((pmtAssetId == amId))
	726	+	let amBalanceOld = $t02732227784._1
	727	+	let prBalanceOld = $t02732227784._2
	728	+	let $t02779027966 = if ((pmtAssetId == amId))
726	729		then $Tuple2(pmtAmtRaw, 0)
727	730		else if ((pmtAssetId == prId))
728	731		then $Tuple2(0, pmtAmtRaw)
729	732		else throw("invalid payment")
730		-	let amAmountRaw = $~~t02755027726~~._1
731		-	let prAmountRaw = $~~t02755027726~~._2
732		-	let $~~t02773027969~~ = if (withTakeFee)
	733	+	let amAmountRaw = $t02779027966._1
	734	+	let prAmountRaw = $t02779027966._2
	735	+	let $t02797028209 = if (withTakeFee)
733	736		then $Tuple3(takeFee(amAmountRaw)._1, takeFee(prAmountRaw)._1, takeFee(pmtAmtRaw)._2)
734	737		else $Tuple3(amAmountRaw, prAmountRaw, 0)
735		-	let amAmount = $~~t02773027969~~._1
736		-	let prAmount = $~~t02773027969~~._2
737		-	let feeAmount = $~~t02773027969~~._3
	738	+	let amAmount = $t02797028209._1
	739	+	let prAmount = $t02797028209._2
	740	+	let feeAmount = $t02797028209._3
738	741		let amBalanceNew = (amBalanceOld + amAmount)
739	742		let prBalanceNew = (prBalanceOld + prAmount)
740	743		let D0 = getD([toBigInt(amBalanceOld), toBigInt(prBalanceOld)])

783	786		else {
784	787		let amBalance = getAccBalance(amId)
785	788		let prBalance = getAccBalance(prId)
786		-	let $~~t03003430145~~ = {
	789	+	let $t03027430385 = {
787	790		let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
788	791		if ($isInstanceOf(@, "(Int, Int)"))
789	792		then @
790	793		else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
791	794		}
792		-	if (($~~t03003430145~~ == $~~t03003430145~~))
	795	+	if (($t03027430385 == $t03027430385))
793	796		then {
794		-	let feeAmount = $~~t03003430145~~._2
795		-	let totalGet = $~~t03003430145~~._1
	797	+	let feeAmount = $t03027430385._2
	798	+	let totalGet = $t03027430385._1
796	799		let totalAmount = if (if ((minOutAmount > 0))
797	800		then (minOutAmount > totalGet)
798	801		else false)
799	802		then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
800	803		else totalGet
801		-	let $~~t03033530642~~ = if ((outAssetId == amId))
	804	+	let $t03057530882 = if ((outAssetId == amId))
802	805		then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
803	806		else if ((outAssetId == prId))
804	807		then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
805	808		else throw("invalid out asset id")
806		-	let outAm = $~~t03033530642~~._1
807		-	let outPr = $~~t03033530642~~._2
808		-	let amBalanceNew = $~~t03033530642~~._3
809		-	let prBalanceNew = $~~t03033530642~~._4
	809	+	let outAm = $t03057530882._1
	810	+	let outPr = $t03057530882._2
	811	+	let amBalanceNew = $t03057530882._3
	812	+	let prBalanceNew = $t03057530882._4
810	813		let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
811	814		let curPr = f1(curPrX18, scale8)
812	815		let outAssetIdOrWaves = if ((outAssetId == "WAVES"))

821	824		let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
822	825		if ((burn == burn))
823	826		then {
824		-	let $~~t03142731777~~ = {
	827	+	let $t03166732017 = {
825	828		let feeAmountForCalc = if ((this == feeCollectorAddress))
826	829		then 0
827	830		else feeAmount

832	835		then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
833	836		else $Tuple2(0, -((totalGet + feeAmountForCalc)))
834	837		}
835		-	let amountAssetBalanceDelta = $~~t03142731777~~._1
836		-	let priceAssetBalanceDelta = $~~t03142731777~~._2
837		-	let $~~t03178031888~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
838		-	let refreshDLpActions = $~~t03178031888~~._1
839		-	let updatedDLp = $~~t03178031888~~._2
	838	+	let amountAssetBalanceDelta = $t03166732017._1
	839	+	let priceAssetBalanceDelta = $t03166732017._2
	840	+	let $t03202032128 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	841	+	let refreshDLpActions = $t03202032128._1
	842	+	let updatedDLp = $t03202032128._2
840	843		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
841	844		if ((isUpdatedDLpValid == isUpdatedDLpValid))
842	845		then $Tuple2((state ++ refreshDLpActions), totalAmount)

996	999		else throw("Strict value is not equal to itself.")
997	1000		}
998	1001		else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
999		-	let $~~t03574435809~~ = refreshDLpInternal(0, 0, 0)
1000		-	let refreshDLpActions = $~~t03574435809~~._1
1001		-	let updatedDLp = $~~t03574435809~~._2
	1002	+	let $t03598436049 = refreshDLpInternal(0, 0, 0)
	1003	+	let refreshDLpActions = $t03598436049._1
	1004	+	let updatedDLp = $t03598436049._2
1002	1005		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1003	1006		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1004	1007		then ((state ++ lpTrnsfr) ++ refreshDLpActions)

1054	1057		let pmt = value(i.payments[0])
1055	1058		let pmtAssetId = toBase58String(value(pmt.assetId))
1056	1059		let pmtAmt = pmt.amount
1057		-	let $~~t03694637104~~ = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1058		-	if (($~~t03694637104~~ == $~~t03694637104~~))
	1060	+	let $t03718637344 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
	1061	+	if (($t03718637344 == $t03718637344))
1059	1062		then {
1060		-	let feeAmount = $~~t03694637104~~._3
1061		-	let state = $~~t03694637104~~._2
1062		-	let estimLP = $~~t03694637104~~._1
	1063	+	let feeAmount = $t03718637344._3
	1064	+	let state = $t03718637344._2
	1065	+	let estimLP = $t03718637344._1
1063	1066		let emitLpAmt = if (if ((minOutAmount > 0))
1064	1067		then (minOutAmount > estimLP)
1065	1068		else false)

1087	1090		let sendFeeToMatcher = if ((feeAmount > 0))
1088	1091		then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1089	1092		else nil
1090		-	let $~~t03791938268~~ = if ((this == feeCollectorAddress))
	1093	+	let $t03815938508 = if ((this == feeCollectorAddress))
1091	1094		then $Tuple2(0, 0)
1092	1095		else {
1093	1096		let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))

1097	1100		then $Tuple2(-(feeAmount), 0)
1098	1101		else $Tuple2(0, -(feeAmount))
1099	1102		}
1100		-	let amountAssetBalanceDelta = $~~t03791938268~~._1
1101		-	let priceAssetBalanceDelta = $~~t03791938268~~._2
1102		-	let $~~t03827138379~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1103		-	let refreshDLpActions = $~~t03827138379~~._1
1104		-	let updatedDLp = $~~t03827138379~~._2
	1103	+	let amountAssetBalanceDelta = $t03815938508._1
	1104	+	let priceAssetBalanceDelta = $t03815938508._2
	1105	+	let $t03851138619 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	1106	+	let refreshDLpActions = $t03851138619._1
	1107	+	let updatedDLp = $t03851138619._2
1105	1108		$Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)
1106	1109		}
1107	1110		else throw("Strict value is not equal to itself.")

1128	1131		let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1129	1132		if ((currentDLp == currentDLp))
1130	1133		then {
1131		-	let $~~t03933839403~~ = refreshDLpInternal(0, 0, 0)
1132		-	let refreshDLpActions = $~~t03933839403~~._1
1133		-	let updatedDLp = $~~t03933839403~~._2
	1134	+	let $t03957839643 = refreshDLpInternal(0, 0, 0)
	1135	+	let refreshDLpActions = $t03957839643._1
	1136	+	let updatedDLp = $t03957839643._2
1134	1137		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1135	1138		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1136	1139		then (state ++ refreshDLpActions)

1153	1156		if ((b == b))
1154	1157		then {
1155	1158		let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(pmtAmt))
1156		-	let $~~t04019240274~~ = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1157		-	let refreshDLpActions = $~~t04019240274~~._1
1158		-	let updatedDLp = $~~t04019240274~~._2
	1159	+	let $t04043240514 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
	1160	+	let refreshDLpActions = $t04043240514._1
	1161	+	let updatedDLp = $t04043240514._2
1159	1162		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1160	1163		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1161	1164		then (state ++ refreshDLpActions)

1188	1191		else throwErr("exactly 1 payment are expected")]
1189	1192		if ((checks == checks))
1190	1193		then {
1191		-	let $~~t04089241047~~ = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1192		-	let state = $~~t04089241047~~._1
1193		-	let totalAmount = $~~t04089241047~~._2
	1194	+	let $t04113241287 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
	1195	+	let state = $t04113241287._1
	1196	+	let totalAmount = $t04113241287._2
1194	1197		$Tuple2(state, totalAmount)
1195	1198		}
1196	1199		else throw("Strict value is not equal to itself.")

1207	1210		if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1208	1211		then {
1209	1212		let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1210		-	let $~~t04157141635~~ = refreshDLpInternal(0, 0, 0)
1211		-	let dLpUpdateActions = $~~t04157141635~~._1
1212		-	let updatedDLp = $~~t04157141635~~._2
	1213	+	let $t04181141875 = refreshDLpInternal(0, 0, 0)
	1214	+	let dLpUpdateActions = $t04181141875._1
	1215	+	let updatedDLp = $t04181141875._2
1213	1216		let actions = if ((dLp != updatedDLp))
1214	1217		then dLpUpdateActions
1215	1218		else throwErr("nothing to refresh")

1238	1241		let newY = getYD(xp, index, D1)
1239	1242		let dy = (xp[index] - newY)
1240	1243		let totalGetRaw = max([0, toInt((dy - big1))])
1241		-	let $~~t04253542584~~ = takeFee(totalGetRaw)
1242		-	let totalGet = $~~t04253542584~~._1
1243		-	let feeAmount = $~~t04253542584~~._2
	1244	+	let $t04277542824 = takeFee(totalGetRaw)
	1245	+	let totalGet = $t04277542824._1
	1246	+	let feeAmount = $t04277542824._2
1244	1247		$Tuple2(nil, $Tuple2(totalGet, feeAmount))
1245	1248		}
1246	1249

1254	1257		let lpId = poolConfig[idxLPAsId]
1255	1258		let amBalance = getAccBalance(amId)
1256	1259		let prBalance = getAccBalance(prId)
1257		-	let $~~t04292943044~~ = {
	1260	+	let $t04316943284 = {
1258	1261		let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1259	1262		if ($isInstanceOf(@, "(Int, Int)"))
1260	1263		then @
1261	1264		else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1262	1265		}
1263		-	let totalGet = $~~t04292943044~~._1
1264		-	let feeAmount = $~~t04292943044~~._2
	1266	+	let totalGet = $t04316943284._1
	1267	+	let feeAmount = $t04316943284._2
1265	1268		let r = ego("", lpId, lpAssetAmount, this)
1266	1269		let outAmAmt = r._1
1267	1270		let outPrAmt = r._2

1293	1296		let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1294	1297		if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1295	1298		then {
1296		-	let $~~t04421244293~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1297		-	let refreshDLpActions = $~~t04421244293~~._1
1298		-	let updatedDLp = $~~t04421244293~~._2
	1299	+	let $t04445244533 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
	1300	+	let refreshDLpActions = $t04445244533._1
	1301	+	let updatedDLp = $t04445244533._2
1299	1302		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1300	1303		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1301	1304		then (state ++ refreshDLpActions)

1337	1340		let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1338	1341		if ((burnA == burnA))
1339	1342		then {
1340		-	let $~~t04535645437~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1341		-	let refreshDLpActions = $~~t04535645437~~._1
1342		-	let updatedDLp = $~~t04535645437~~._2
	1343	+	let $t04559645677 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
	1344	+	let refreshDLpActions = $t04559645677._1
	1345	+	let updatedDLp = $t04559645677._2
1343	1346		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1344	1347		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1345	1348		then (state ++ refreshDLpActions)

1386	1389		let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1387	1390		if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1388	1391		then {
1389		-	let $~~t04668546766~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1390		-	let refreshDLpActions = $~~t04668546766~~._1
1391		-	let updatedDLp = $~~t04668546766~~._2
	1392	+	let $t04692547006 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
	1393	+	let refreshDLpActions = $t04692547006._1
	1394	+	let updatedDLp = $t04692547006._2
1392	1395		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1393	1396		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1394	1397		then (state ++ refreshDLpActions)

1434	1437		let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), unstakeAmount], nil)
1435	1438		if ((unstakeInv == unstakeInv))
1436	1439		then {
1437		-	let $~~t04770047888~~ = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1438		-	let state = $~~t04770047888~~._1
1439		-	let totalAmount = $~~t04770047888~~._2
	1440	+	let $t04794048128 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
	1441	+	let state = $t04794048128._1
	1442	+	let totalAmount = $t04794048128._2
1440	1443		$Tuple2(state, totalAmount)
1441	1444		}
1442	1445		else throw("Strict value is not equal to itself.")

1452	1455		let amId = poolConfig[idxAmAsId]
1453	1456		let prId = poolConfig[idxPrAsId]
1454	1457		let lpId = poolConfig[idxLPAsId]
1455		-	let $~~t04814748250~~ = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1456		-	let lpAmount = $~~t04814748250~~._1
1457		-	let state = $~~t04814748250~~._2
1458		-	let feeAmount = $~~t04814748250~~._3
1459		-	let bonus = $~~t04814748250~~._4

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let scale8 = 100000000
5	5
6	6		let scale8BigInt = toBigInt(100000000)
7	7
8	8		let scale18 = toBigInt(1000000000000000000)
9	9
10	10		let zeroBigInt = toBigInt(0)
11	11
12	12		let big0 = toBigInt(0)
13	13
14	14		let big1 = toBigInt(1)
15	15
16	16		let big2 = toBigInt(2)
17	17
18	18		let big3 = toBigInt(3)
19	19
20	20		let big4 = toBigInt(4)
21	21
22	22		let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
23	23
24	24		let wavesString = "WAVES"
25	25
26	26		let Amult = "100"
27	27
28	28		let Dconv = "1"
29	29
30	30		let SEP = "__"
31	31
32	32		let EMPTY = ""
33	33
34	34		let PoolActive = 1
35	35
36	36		let PoolPutDis = 2
37	37
38	38		let PoolMatcherDis = 3
39	39
40	40		let PoolShutdown = 4
41	41
42	42		let idxPoolAddress = 1
43	43
44	44		let idxPoolSt = 2
45	45
46	46		let idxLPAsId = 3
47	47
48	48		let idxAmAsId = 4
49	49
50	50		let idxPrAsId = 5
51	51
52	52		let idxAmtAsDcm = 6
53	53
54	54		let idxPriceAsDcm = 7
55	55
56	56		let idxIAmtAsId = 8
57	57
58	58		let idxIPriceAsId = 9
59	59
60	60		let idxFactStakCntr = 1
61	61
62	62		let idxFactoryRestCntr = 6
63	63
64	64		let idxFactSlippCntr = 7
65	65
66	66		let idxFactGwxRewCntr = 10
67	67
68	68		let feeDefault = fraction(10, scale8, 10000)
69	69
70	70		func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
71	71
72	72
73	73		func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
	74	+
	75	+
	76	+	func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
74	77
75	78
76	79		func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
77	80
78	81
79	82		func abs (val) = if ((zeroBigInt > val))
80	83		then -(val)
81	84		else val
82	85
83	86
84	87		func absBigInt (val) = if ((zeroBigInt > val))
85	88		then -(val)
86	89		else val
87	90
88	91
89	92		func fc () = "%s__factoryContract"
90	93
91	94
92	95		func mpk () = "%s__managerPublicKey"
93	96
94	97
95	98		func pmpk () = "%s__pendingManagerPublicKey"
96	99
97	100
98	101		func pl () = "%s%s__price__last"
99	102
100	103
101	104		func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
102	105
103	106
104	107		func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
105	108
106	109
107	110		func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
108	111
109	112
110	113		func aa () = "%s__amountAsset"
111	114
112	115
113	116		func pa () = "%s__priceAsset"
114	117
115	118
116	119		func amp () = "%s__amp"
117	120
118	121
119	122		func ada () = "%s__addonAddr"
120	123
121	124
122	125		let keyFee = "%s__fee"
123	126
124	127		let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
125	128
126	129		let keyDLp = makeString(["%s", "dLp"], SEP)
127	130
128	131		let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
129	132
130	133		let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
131	134
132	135		let dLpRefreshDelayDefault = 1
133	136
134	137		let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
135	138
136	139		func fcfg () = "%s__factoryConfig"
137	140
138	141
139	142		func mtpk () = "%s%s__matcher__publicKey"
140	143
141	144
142	145		func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
143	146
144	147
145	148		func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
146	149
147	150
148	151		func aps () = "%s__shutdown"
149	152
150	153
151	154		func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
152	155
153	156
154	157		func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
155	158
156	159
157	160		func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
158	161
159	162
160	163		func str (val) = match val {
161	164		case valStr: String =>
162	165		valStr
163	166		case _ =>
164	167		throw("fail cast to String")
165	168		}
166	169
167	170
168	171		func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
169	172
170	173
171	174		func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
172	175
173	176
174	177		func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
175	178
176	179
177	180		func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
178	181
179	182
180	183		let fca = addressFromStringValue(strf(this, fc()))
181	184
182	185		let A = strf(this, amp())
183	186
184	187		func igs () = valueOrElse(getBoolean(fca, aps()), false)
185	188
186	189
187	190		func mp () = fromBase58String(strf(fca, mtpk()))
188	191
189	192
190	193		let feeCollectorAddress = addressFromStringValue(strf(fca, keyFeeCollectorAddress()))
191	194
192	195		func gpc () = {
193	196		let amtAs = strf(this, aa())
194	197		let priceAs = strf(this, pa())
195	198		let iPriceAs = intf(fca, mba(priceAs))
196	199		let iAmtAs = intf(fca, mba(amtAs))
197	200		split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
198	201		}
199	202
200	203
201	204		func parseAssetId (input) = if ((input == wavesString))
202	205		then unit
203	206		else fromBase58String(input)
204	207
205	208
206	209		func assetIdToString (input) = if ((input == unit))
207	210		then wavesString
208	211		else toBase58String(value(input))
209	212
210	213
211	214		func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
212	215
213	216
214	217		let poolConfigParsed = parsePoolConfig(gpc())
215	218
216		-	let $~~t072557441~~ = poolConfigParsed
	219	+	let $t074067592 = poolConfigParsed
217	220
218		-	let cfgPoolAddress = $~~t072557441~~._1
	221	+	let cfgPoolAddress = $t074067592._1
219	222
220		-	let cfgPoolStatus = $~~t072557441~~._2
	223	+	let cfgPoolStatus = $t074067592._2
221	224
222		-	let cfgLpAssetId = $~~t072557441~~._3
	225	+	let cfgLpAssetId = $t074067592._3
223	226
224		-	let cfgAmountAssetId = $~~t072557441~~._4
	227	+	let cfgAmountAssetId = $t074067592._4
225	228
226		-	let cfgPriceAssetId = $~~t072557441~~._5
	229	+	let cfgPriceAssetId = $t074067592._5
227	230
228		-	let cfgAmountAssetDecimals = $~~t072557441~~._6
	231	+	let cfgAmountAssetDecimals = $t074067592._6
229	232
230		-	let cfgPriceAssetDecimals = $~~t072557441~~._7
	233	+	let cfgPriceAssetDecimals = $t074067592._7
231	234
232	235		func gfc () = split(strf(fca, fcfg()), SEP)
233	236
234	237
235	238		let factoryConfig = gfc()
236	239
237	240		let stakingContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactStakCntr]), "Invalid staking contract address")
238	241
239	242		let slipageContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactSlippCntr]), "Invalid slipage contract address")
240	243
241	244		let gwxContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactGwxRewCntr]), "Invalid gwx contract address")
242	245
243	246		let restContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactoryRestCntr]), "Invalid gwx contract address")
244	247
245	248		func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
246	249
247	250
248	251		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)
249	252
250	253
251	254		func getAccBalance (assetId) = if ((assetId == "WAVES"))
252	255		then wavesBalance(this).available
253	256		else assetBalance(this, fromBase58String(assetId))
254	257
255	258
256	259		func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
257	260
258	261
259	262		func vad (A1,A2,slippage) = {
260	263		let diff = fraction((A1 - A2), scale8BigInt, A2)
261	264		let pass = ((slippage - abs(diff)) > zeroBigInt)
262	265		if (!(pass))
263	266		then throw(("Big slpg: " + toString(diff)))
264	267		else $Tuple2(pass, min([A1, A2]))
265	268		}
266	269
267	270
268	271		func vd (D1,D0,slpg) = {
269	272		let diff = fraction(D0, scale8BigInt, D1)
270	273		let fail = (slpg > diff)
271	274		if (if (fail)
272	275		then true
273	276		else (D0 > D1))
274	277		then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
275	278		else fail
276	279		}
277	280
278	281
279	282		func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
280	283		let amtAsAmtX18 = t1(amAmt, amAssetDcm)
281	284		let prAsAmtX18 = t1(prAmt, prAssetDcm)
282	285		cpbi(prAsAmtX18, amtAsAmtX18)
283	286		}
284	287
285	288
286	289		func calcPrices (amAmt,prAmt,lpAmt) = {
287	290		let cfg = gpc()
288	291		let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
289	292		let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
290	293		let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
291	294		let amAmtX18 = t1(amAmt, amtAsDcm)
292	295		let prAmtX18 = t1(prAmt, prAsDcm)
293	296		let lpAmtX18 = t1(lpAmt, scale8)
294	297		let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
295	298		let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
296	299		[priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
297	300		}
298	301
299	302
300	303		func calculatePrices (amAmt,prAmt,lpAmt) = {
301	304		let p = calcPrices(amAmt, prAmt, lpAmt)
302	305		[f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
303	306		}
304	307
305	308
306	309		func takeFee (amount) = {
307	310		let feeAmount = fraction(amount, fee, scale8)
308	311		$Tuple2((amount - feeAmount), feeAmount)
309	312		}
310	313
311	314
312	315		func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
313	316		let cfg = gpc()
314	317		let lpId = cfg[idxLPAsId]
315	318		let amId = cfg[idxAmAsId]
316	319		let prId = cfg[idxPrAsId]
317	320		let amDcm = parseIntValue(cfg[idxAmtAsDcm])
318	321		let prDcm = parseIntValue(cfg[idxPriceAsDcm])
319	322		let sts = cfg[idxPoolSt]
320	323		let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
321	324		if ((lpId != pmtAssetId))
322	325		then throw("Wrong pmt asset")
323	326		else {
324	327		let amBalance = getAccBalance(amId)
325	328		let amBalanceX18 = t1(amBalance, amDcm)
326	329		let prBalance = getAccBalance(prId)
327	330		let prBalanceX18 = t1(prBalance, prDcm)
328	331		let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
329	332		let curPrice = f1(curPriceX18, scale8)
330	333		let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
331	334		let lpEmissX18 = t1(lpEmiss, scale8)
332	335		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
333	336		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
334		-	let outAmAmt = f1(outAmAmtX18, amDcm)
335		-	let outPrAmt = f1(outPrAmtX18, prDcm)
	337	+	let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
	338	+	let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
336	339		let state = if ((txId58 == ""))
337	340		then nil
338	341		else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
339	342		then unit
340	343		else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
341	344		then unit
342	345		else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
343	346		$Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
344	347		}
345	348		}
346	349
347	350
348	351		func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
349	352		let cfg = gpc()
350	353		let lpId = fromBase58String(cfg[idxLPAsId])
351	354		let amIdStr = cfg[idxAmAsId]
352	355		let prIdStr = cfg[idxPrAsId]
353	356		let inAmIdStr = cfg[idxIAmtAsId]
354	357		let inPrIdStr = cfg[idxIPriceAsId]
355	358		let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
356	359		let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
357	360		let sts = cfg[idxPoolSt]
358	361		let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
359	362		let amBalance = if (isEval)
360	363		then getAccBalance(amIdStr)
361	364		else if (if (isOneAsset)
362	365		then (pmtId == amIdStr)
363	366		else false)
364	367		then (getAccBalance(amIdStr) - pmtAmt)
365	368		else if (isOneAsset)
366	369		then getAccBalance(amIdStr)
367	370		else (getAccBalance(amIdStr) - inAmAmt)
368	371		let prBalance = if (isEval)
369	372		then getAccBalance(prIdStr)
370	373		else if (if (isOneAsset)
371	374		then (pmtId == prIdStr)
372	375		else false)
373	376		then (getAccBalance(prIdStr) - pmtAmt)
374	377		else if (isOneAsset)
375	378		then getAccBalance(prIdStr)
376	379		else (getAccBalance(prIdStr) - inPrAmt)
377	380		let inAmAssetAmtX18 = t1(inAmAmt, amtDcm)
378	381		let inPrAssetAmtX18 = t1(inPrAmt, priceDcm)
379	382		let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
380	383		let amBalanceX18 = t1(amBalance, amtDcm)
381	384		let prBalanceX18 = t1(prBalance, priceDcm)
382	385		let r = if ((lpEm == 0))
383	386		then {
384	387		let curPriceX18 = zeroBigInt
385	388		let slippageX18 = zeroBigInt
386	389		let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
387	390		$Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
388	391		}
389	392		else {
390	393		let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
391	394		let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
392	395		let slippageX18 = t1(slippage, scale8)
393	396		if (if (if (validateSlippage)
394	397		then (curPriceX18 != zeroBigInt)
395	398		else false)
396	399		then (slippageRealX18 > slippageX18)
397	400		else false)
398	401		then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
399	402		else {
400	403		let lpEmissionX18 = t1(lpEm, scale8)
401	404		let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
402	405		let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
403	406		let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
404	407		then $Tuple2(amViaPrX18, inPrAssetAmtX18)
405	408		else $Tuple2(inAmAssetAmtX18, prViaAmX18)
406	409		let expAmtAssetAmtX18 = expectedAmts._1
407	410		let expPriceAssetAmtX18 = expectedAmts._2
408	411		let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
409		-	$Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
	412	+	$Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
410	413		}
411	414		}
412	415		let calcLpAmt = r._1
413	416		let calcAmAssetPmt = r._2
414	417		let calcPrAssetPmt = r._3
415	418		let curPrice = f1(r._4, scale8)
416	419		let slippageCalc = f1(r._5, scale8)
417	420		if ((0 >= calcLpAmt))
418	421		then throw("LP <= 0")
419	422		else {
420	423		let emitLpAmt = if (!(emitLp))
421	424		then 0
422	425		else calcLpAmt
423	426		let amDiff = (inAmAmt - calcAmAssetPmt)
424	427		let prDiff = (inPrAmt - calcPrAssetPmt)
425		-	let $~~t01787218217~~ = if (if (isOneAsset)
	428	+	let $t01811218457 = if (if (isOneAsset)
426	429		then (pmtId == amIdStr)
427	430		else false)
428	431		then $Tuple2(pmtAmt, 0)
429	432		else if (if (isOneAsset)
430	433		then (pmtId == prIdStr)
431	434		else false)
432	435		then $Tuple2(0, pmtAmt)
433	436		else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
434		-	let writeAmAmt = $~~t01787218217~~._1
435		-	let writePrAmt = $~~t01787218217~~._2
	437	+	let writeAmAmt = $t01811218457._1
	438	+	let writePrAmt = $t01811218457._2
436	439		let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
437	440		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
438	441		}
439	442		}
440	443
441	444
442	445		func getD (xp) = {
443	446		let xp0 = xp[0]
444	447		let xp1 = xp[1]
445	448		let s = (xp0 + xp1)
446	449		if ((s == big0))
447	450		then big0
448	451		else {
449	452		let a = parseIntValue(A)
450	453		let ann = (a * 2)
451	454		let p = fraction(xp0, xp1, big1)
452	455		let xp0_xp1_n_n = fraction(p, big4, big1)
453	456		let ann_s = fraction(toBigInt(ann), s, big1)
454	457		let ann_1 = toBigInt((ann - 1))
455	458		func calcDNext (d) = {
456	459		let dd = fraction(d, d, big1)
457	460		let ddd = fraction(dd, d, big1)
458	461		let dp = fraction(ddd, big1, xp0_xp1_n_n)
459	462		fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)), CEILING)
460	463		}
461	464
462	465		func calc (acc,i) = if (acc._2)
463	466		then acc
464	467		else {
465	468		let d = acc._1
466	469		let dNext = calcDNext(d)
467	470		let dDiffRaw = toInt((dNext - value(d)))
468	471		let dDiff = if ((0 > dDiffRaw))
469	472		then -(dDiffRaw)
470	473		else dDiffRaw
471	474		if ((1 >= dDiff))
472	475		then $Tuple2(dNext, true)
473	476		else $Tuple2(dNext, false)
474	477		}
475	478
476	479		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
477		-	let $~~t02014520193~~ = {
	480	+	let $t02038520433 = {
478	481		let $l = arr
479	482		let $s = size($l)
480	483		let $acc0 = $Tuple2(s, false)
481	484		func $f0_1 ($a,$i) = if (($i >= $s))
482	485		then $a

github/deemru/w8io/c3f4982 
205.28 ms ◑