w8 · tx · 4NL···NSq

tx · 4NLcA3oeRiKPnhYjWAupGhstGp4CtsGsvUX6bcv2gNSq

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.04100000 Waves

2023.05.10 14:12 [2571711] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4NLcA3oeRiKPnhYjWAupGhstGp4CtsGsvUX6bcv2gNSq",
    "fee": 4100000,
    "feeAssetId": null,
    "timestamp": 1683717122302,
    "version": 2,
    "chainId": 84,
    "sender": "3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT",
    "senderPublicKey": "D1BL65meykxFZTCuq7jq9HSGLLnWvQamQPUNrguW5w39",
    "proofs": [
        "26wyZNzMr58TFEk5a5uU7nGCbuMxRiBKruKnnTrh8BU4JX8h3Jk3kiLgqjkRjm15efbEYxazejWyRGXw86JDNHno"
    ],
    "script": "base64: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",
    "height": 2571711,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 7BJiHH1qQiA4gD1dkNzJsk8Pavkw6FnSDgPHVhNoX5Mx
Next: 6M83SbtA3zqQtFyUkYp84rEcE5XJHKaE1zgvEcAe9n7m

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

Old	New		Differences
184	184
185	185
186	186		func getManagerVaultAddressOrThis () = {
187		-	let factoryAddress = match ~~addressFromStringOrThis~~(fc()) {
188		-	case fca: ~~Address~~ =>
189		-	fca
	187	+	let factoryAddress = match getString(fc()) {
	188	+	case fca: String =>
	189	+	addressFromStringOrThis(fca)
190	190		case _ =>
191	191		this
192	192		}

261	261
262	262		let poolConfigParsed = parsePoolConfig(gpc())
263	263
264		-	let $~~t086768905~~ = poolConfigParsed
	264	+	let $t086868915 = poolConfigParsed
265	265
266		-	let cfgPoolAddress = $~~t086768905~~._1
	266	+	let cfgPoolAddress = $t086868915._1
267	267
268		-	let cfgPoolStatus = $~~t086768905~~._2
	268	+	let cfgPoolStatus = $t086868915._2
269	269
270		-	let cfgLpAssetId = $~~t086768905~~._3
	270	+	let cfgLpAssetId = $t086868915._3
271	271
272		-	let cfgAmountAssetId = $~~t086768905~~._4
	272	+	let cfgAmountAssetId = $t086868915._4
273	273
274		-	let cfgPriceAssetId = $~~t086768905~~._5
	274	+	let cfgPriceAssetId = $t086868915._5
275	275
276		-	let cfgAmountAssetDecimals = $~~t086768905~~._6
	276	+	let cfgAmountAssetDecimals = $t086868915._6
277	277
278		-	let cfgPriceAssetDecimals = $~~t086768905~~._7
	278	+	let cfgPriceAssetDecimals = $t086868915._7
279	279
280		-	let cfgInAmountAssedId = $~~t086768905~~._8
	280	+	let cfgInAmountAssedId = $t086868915._8
281	281
282		-	let cfgInPriceAssetId = $~~t086768905~~._9
	282	+	let cfgInPriceAssetId = $t086868915._9
283	283
284	284		func gfc () = split(strf(fca, fcfg()), SEP)
285	285

400	400		}
401	401
402	402		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
403		-	let $~~t01341013458~~ = {
	403	+	let $t01342013468 = {
404	404		let $l = arr
405	405		let $s = size($l)
406	406		let $acc0 = $Tuple2(s, false)

414	414
415	415		$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($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
416	416		}
417		-	let d = $~~t01341013458~~._1
418		-	let found = $~~t01341013458~~._2
	417	+	let d = $t01342013468._1
	418	+	let found = $t01342013468._2
419	419		if (found)
420	420		then d
421	421		else throw(("D calculation error, D = " + toString(d)))

551	551		else calcLpAmt
552	552		let amDiff = (inAmAmt - calcAmAssetPmt)
553	553		let prDiff = (inPrAmt - calcPrAssetPmt)
554		-	let $~~t02129721642~~ = if (if (isOneAsset)
	554	+	let $t02130721652 = if (if (isOneAsset)
555	555		then (pmtId == amIdStr)
556	556		else false)
557	557		then $Tuple2(pmtAmt, 0)

560	560		else false)
561	561		then $Tuple2(0, pmtAmt)
562	562		else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
563		-	let writeAmAmt = $~~t02129721642~~._1
564		-	let writePrAmt = $~~t02129721642~~._2
	563	+	let writeAmAmt = $t02130721652._1
	564	+	let writePrAmt = $t02130721652._2
565	565		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))]
566	566		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
567	567		}

580	580		let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
581	581		let b = ((s + ((D * aPrecision) / ann)) - D)
582	582		func calc (acc,cur) = {
583		-	let $~~t02283722857~~ = acc
584		-	let y = $~~t02283722857~~._1
585		-	let found = $~~t02283722857~~._2
	583	+	let $t02284722867 = acc
	584	+	let y = $t02284722867._1
	585	+	let found = $t02284722867._2
586	586		if ((found != unit))
587	587		then acc
588	588		else {

595	595		}
596	596
597	597		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
598		-	let $~~t02316423211~~ = {
	598	+	let $t02317423221 = {
599	599		let $l = arr
600	600		let $s = size($l)
601	601		let $acc0 = $Tuple2(D, unit)

609	609
610	610		$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)
611	611		}
612		-	let y = $~~t02316423211~~._1
613		-	let found = $~~t02316423211~~._2
	612	+	let y = $t02317423221._1
	613	+	let found = $t02317423221._2
614	614		if ((found != unit))
615	615		then y
616	616		else throw(("Y calculation error, Y = " + toString(y)))

654	654		let priceAssetBalance = getAccBalance(assetIdToString(cfgPriceAssetId))
655	655		let amountAssetAmount = order.amount
656	656		let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
657		-	let $~~t02540925621~~ = if ((order.orderType == Buy))
	657	+	let $t02541925631 = if ((order.orderType == Buy))
658	658		then $Tuple2(amountAssetAmount, -(priceAssetAmount))
659	659		else $Tuple2(-(amountAssetAmount), priceAssetAmount)
660		-	let amountAssetBalanceDelta = $~~t02540925621~~._1
661		-	let priceAssetBalanceDelta = $~~t02540925621~~._2
	660	+	let amountAssetBalanceDelta = $t02541925631._1
	661	+	let priceAssetBalanceDelta = $t02541925631._2
662	662		if (if (if (igs())
663	663		then true
664	664		else (cfgPoolStatus == PoolMatcherDis))

671	671		then throw("Wr assets")
672	672		else {
673	673		let dLp = parseBigIntValue(valueOrElse(getString(this, keyDLp), "0"))
674		-	let $~~t02596326063~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
675		-	let unusedActions = $~~t02596326063~~._1
676		-	let dLpNew = $~~t02596326063~~._2
	674	+	let $t02597326073 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	675	+	let unusedActions = $t02597326073._1
	676	+	let dLpNew = $t02597326073._2
677	677		let isOrderValid = (dLpNew >= dLp)
678	678		let info = makeString(["dLp=", toString(dLp), " dLpNew=", toString(dLpNew), " amountAssetBalance=", toString(amountAssetBalance), " priceAssetBalance=", toString(priceAssetBalance), " amountAssetBalanceDelta=", toString(amountAssetBalanceDelta), " priceAssetBalanceDelta=", toString(priceAssetBalanceDelta), " height=", toString(height)], "")
679	679		$Tuple2(isOrderValid, info)

727	727		then {
728	728		let amBalance = getAccBalance(amId)
729	729		let prBalance = getAccBalance(prId)
730		-	let $~~t02871929181~~ = if ((txId == ""))
	730	+	let $t02872929191 = if ((txId == ""))
731	731		then $Tuple2(amBalance, prBalance)
732	732		else if ((pmtAssetId == amId))
733	733		then if ((pmtAmtRaw > amBalance))

738	738		then throw("invalid payment amount")
739	739		else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
740	740		else throw("wrong pmtAssetId")
741		-	let amBalanceOld = $~~t02871929181~~._1
742		-	let prBalanceOld = $~~t02871929181~~._2
743		-	let $~~t02918729363~~ = if ((pmtAssetId == amId))
	741	+	let amBalanceOld = $t02872929191._1
	742	+	let prBalanceOld = $t02872929191._2
	743	+	let $t02919729373 = if ((pmtAssetId == amId))
744	744		then $Tuple2(pmtAmtRaw, 0)
745	745		else if ((pmtAssetId == prId))
746	746		then $Tuple2(0, pmtAmtRaw)
747	747		else throw("invalid payment")
748		-	let amAmountRaw = $~~t02918729363~~._1
749		-	let prAmountRaw = $~~t02918729363~~._2
750		-	let $~~t02936729621~~ = if (withTakeFee)
	748	+	let amAmountRaw = $t02919729373._1
	749	+	let prAmountRaw = $t02919729373._2
	750	+	let $t02937729631 = if (withTakeFee)
751	751		then $Tuple3(takeFee(amAmountRaw, inFee)._1, takeFee(prAmountRaw, inFee)._1, takeFee(pmtAmtRaw, inFee)._2)
752	752		else $Tuple3(amAmountRaw, prAmountRaw, 0)
753		-	let amAmount = $~~t02936729621~~._1
754		-	let prAmount = $~~t02936729621~~._2
755		-	let feeAmount = $~~t02936729621~~._3
	753	+	let amAmount = $t02937729631._1
	754	+	let prAmount = $t02937729631._2
	755	+	let feeAmount = $t02937729631._3
756	756		let amBalanceNew = (amBalanceOld + amAmount)
757	757		let prBalanceNew = (prBalanceOld + prAmount)
758	758		let D0 = getD([t1(amBalanceOld, cfgAmountAssetDecimals), t1(prBalanceOld, cfgPriceAssetDecimals)])

800	800		else {
801	801		let amBalance = getAccBalance(amId)
802	802		let prBalance = getAccBalance(prId)
803		-	let $~~t03173331844~~ = {
	803	+	let $t03174331854 = {
804	804		let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
805	805		if ($isInstanceOf(@, "(Int, Int)"))
806	806		then @
807	807		else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
808	808		}
809		-	if (($~~t03173331844~~ == $~~t03173331844~~))
	809	+	if (($t03174331854 == $t03174331854))
810	810		then {
811		-	let feeAmount = $~~t03173331844~~._2
812		-	let totalGet = $~~t03173331844~~._1
	811	+	let feeAmount = $t03174331854._2
	812	+	let totalGet = $t03174331854._1
813	813		let totalAmount = if (if ((minOutAmount > 0))
814	814		then (minOutAmount > totalGet)
815	815		else false)
816	816		then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
817	817		else totalGet
818		-	let $~~t03203432341~~ = if ((outAssetId == amId))
	818	+	let $t03204432351 = if ((outAssetId == amId))
819	819		then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
820	820		else if ((outAssetId == prId))
821	821		then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
822	822		else throw("invalid out asset id")
823		-	let outAm = $~~t03203432341~~._1
824		-	let outPr = $~~t03203432341~~._2
825		-	let amBalanceNew = $~~t03203432341~~._3
826		-	let prBalanceNew = $~~t03203432341~~._4
	823	+	let outAm = $t03204432351._1
	824	+	let outPr = $t03204432351._2
	825	+	let amBalanceNew = $t03204432351._3
	826	+	let prBalanceNew = $t03204432351._4
827	827		let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
828	828		let curPr = f1(curPrX18, scale8)
829	829		let outAssetIdOrWaves = if ((outAssetId == "WAVES"))

838	838		let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
839	839		if ((burn == burn))
840	840		then {
841		-	let $~~t03312633476~~ = {
	841	+	let $t03313633486 = {
842	842		let feeAmountForCalc = if ((this == feeCollectorAddress))
843	843		then 0
844	844		else feeAmount

849	849		then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
850	850		else $Tuple2(0, -((totalGet + feeAmountForCalc)))
851	851		}
852		-	let amountAssetBalanceDelta = $~~t03312633476~~._1
853		-	let priceAssetBalanceDelta = $~~t03312633476~~._2
854		-	let $~~t03347933587~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
855		-	let refreshDLpActions = $~~t03347933587~~._1
856		-	let updatedDLp = $~~t03347933587~~._2
	852	+	let amountAssetBalanceDelta = $t03313633486._1
	853	+	let priceAssetBalanceDelta = $t03313633486._2
	854	+	let $t03348933597 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	855	+	let refreshDLpActions = $t03348933597._1
	856	+	let updatedDLp = $t03348933597._2
857	857		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
858	858		if ((isUpdatedDLpValid == isUpdatedDLpValid))
859	859		then $Tuple2((state ++ refreshDLpActions), totalAmount)

925	925		let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
926	926		let b = ((s + ((D * aPrecision) / ann)) - D)
927	927		func calc (acc,cur) = {
928		-	let $~~t03507435094~~ = acc
929		-	let y = $~~t03507435094~~._1
930		-	let found = $~~t03507435094~~._2
	928	+	let $t03508435104 = acc
	929	+	let y = $t03508435104._1
	930	+	let found = $t03508435104._2
931	931		if ((found != unit))
932	932		then acc
933	933		else {

940	940		}
941	941
942	942		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
943		-	let $~~t03542535472~~ = {
	943	+	let $t03543535482 = {
944	944		let $l = arr
945	945		let $s = size($l)
946	946		let $acc0 = $Tuple2(D, unit)

954	954
955	955		$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)
956	956		}
957		-	let y = $~~t03542535472~~._1
958		-	let found = $~~t03542535472~~._2
	957	+	let y = $t03543535482._1
	958	+	let found = $t03543535482._2
959	959		if ((found != unit))
960	960		then y
961	961		else throw(("Y calculation error, Y = " + toString(y)))

967	967
968	968		@Callable(i)
969	969		func calculateAmountOutForSwapREADONLY (cleanAmountIn,isReverse,feePoolAmount) = {
970		-	let $~~t03582436248~~ = if ((isReverse == false))
	970	+	let $t03583436258 = if ((isReverse == false))
971	971		then {
972	972		let assetOut = strf(this, pa())
973	973		let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, aa()))) + toBigInt(cleanAmountIn))

978	978		let poolAmountInBalance = (toBigInt(getAccBalance(strf(this, pa()))) + toBigInt(cleanAmountIn))
979	979		$Tuple2(assetOut, poolAmountInBalance)
980	980		}
981		-	let assetOut = $~~t03582436248~~._1
982		-	let poolAmountInBalance = $~~t03582436248~~._2
	981	+	let assetOut = $t03583436258._1
	982	+	let poolAmountInBalance = $t03583436258._2
983	983		let poolConfig = gpc()
984	984		let amId = poolConfig[idxAmAsId]
985	985		let prId = poolConfig[idxPrAsId]

1019	1019		then {
1020	1020		let pmt = value(i.payments[0])
1021	1021		let assetIn = assetIdToString(pmt.assetId)
1022		-	let $~~t03768438078~~ = if ((isReverse == false))
	1022	+	let $t03769438088 = if ((isReverse == false))
1023	1023		then {
1024	1024		let assetOut = strf(this, pa())
1025	1025		let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)

1030	1030		let poolAmountInBalance = (getAccBalance(assetIn) - value(i.payments[0]).amount)
1031	1031		$Tuple2(assetOut, poolAmountInBalance)
1032	1032		}
1033		-	let assetOut = $~~t03768438078~~._1
1034		-	let poolAmountInBalance = $~~t03768438078~~._2
	1033	+	let assetOut = $t03769438088._1
	1034	+	let poolAmountInBalance = $t03769438088._2
1035	1035		let poolConfig = gpc()
1036	1036		let amId = poolConfig[idxAmAsId]
1037	1037		let prId = poolConfig[idxPrAsId]

1136	1136		else throw("Strict value is not equal to itself.")
1137	1137		}
1138	1138		else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
1139		-	let $~~t04222242364~~ = refreshDLpInternal(0, 0, 0)
1140		-	let refreshDLpActions = $~~t04222242364~~._1
1141		-	let updatedDLp = $~~t04222242364~~._2
	1139	+	let $t04223242374 = refreshDLpInternal(0, 0, 0)
	1140	+	let refreshDLpActions = $t04223242374._1
	1141	+	let updatedDLp = $t04223242374._2
1142	1142		let check = if ((updatedDLp >= currentDLp))
1143	1143		then true
1144	1144		else throwErr(makeString(["updated DLp lower than current DLp", toString(amountAssetBalance), toString(priceAssetBalance), toString(lpAssetEmission), toString(currentDLp), toString(updatedDLp), toString(amDiff), toString(prDiff)], " "))

1211	1211		else calcCurrentDLp(toBigInt(0), toBigInt(pmtAmt), toBigInt(0))
1212	1212		if ((currentDLp == currentDLp))
1213	1213		then {
1214		-	let $~~t04400544163~~ = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1215		-	if (($~~t04400544163~~ == $~~t04400544163~~))
	1214	+	let $t04401544173 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
	1215	+	if (($t04401544173 == $t04401544173))
1216	1216		then {
1217		-	let feeAmount = $~~t04400544163~~._3
1218		-	let state = $~~t04400544163~~._2
1219		-	let estimLP = $~~t04400544163~~._1
	1217	+	let feeAmount = $t04401544173._3
	1218	+	let state = $t04401544173._2
	1219	+	let estimLP = $t04401544173._1
1220	1220		let emitLpAmt = if (if ((minOutAmount > 0))
1221	1221		then (minOutAmount > estimLP)
1222	1222		else false)

1244	1244		let sendFeeToMatcher = if ((feeAmount > 0))
1245	1245		then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1246	1246		else nil
1247		-	let $~~t04504845397~~ = if ((this == feeCollectorAddress))
	1247	+	let $t04505845407 = if ((this == feeCollectorAddress))
1248	1248		then $Tuple2(0, 0)
1249	1249		else {
1250	1250		let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))

1254	1254		then $Tuple2(-(feeAmount), 0)
1255	1255		else $Tuple2(0, -(feeAmount))
1256	1256		}
1257		-	let amountAssetBalanceDelta = $~~t04504845397~~._1
1258		-	let priceAssetBalanceDelta = $~~t04504845397~~._2
1259		-	let $~~t04540045508~~ = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1260		-	let refreshDLpActions = $~~t04540045508~~._1
1261		-	let updatedDLp = $~~t04540045508~~._2
	1257	+	let amountAssetBalanceDelta = $t04505845407._1
	1258	+	let priceAssetBalanceDelta = $t04505845407._2
	1259	+	let $t04541045518 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	1260	+	let refreshDLpActions = $t04541045518._1
	1261	+	let updatedDLp = $t04541045518._2
1262	1262		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1263	1263		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1264	1264		then $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)

1290	1290		let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1291	1291		if ((currentDLp == currentDLp))
1292	1292		then {
1293		-	let $~~t04653846603~~ = refreshDLpInternal(0, 0, 0)
1294		-	let refreshDLpActions = $~~t04653846603~~._1
1295		-	let updatedDLp = $~~t04653846603~~._2
	1293	+	let $t04654846613 = refreshDLpInternal(0, 0, 0)
	1294	+	let refreshDLpActions = $t04654846613._1
	1295	+	let updatedDLp = $t04654846613._2
1296	1296		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1297	1297		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1298	1298		then (state ++ refreshDLpActions)

1317	1317		let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1318	1318		if ((b == b))
1319	1319		then {
1320		-	let $~~t04777647858~~ = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1321		-	let refreshDLpActions = $~~t04777647858~~._1
1322		-	let updatedDLp = $~~t04777647858~~._2
	1320	+	let $t04778647868 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
	1321	+	let refreshDLpActions = $t04778647868._1
	1322	+	let updatedDLp = $t04778647868._2
1323	1323		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1324	1324		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1325	1325		then (state ++ refreshDLpActions)

1354	1354		else throwErr("exactly 1 payment are expected")]
1355	1355		if ((checks == checks))
1356	1356		then {
1357		-	let $~~t04847648631~~ = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1358		-	let state = $~~t04847648631~~._1
1359		-	let totalAmount = $~~t04847648631~~._2
	1357	+	let $t04848648641 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
	1358	+	let state = $t04848648641._1
	1359	+	let totalAmount = $t04848648641._2
1360	1360		$Tuple2(state, totalAmount)
1361	1361		}
1362	1362		else throw("Strict value is not equal to itself.")

1373	1373		if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1374	1374		then {
1375	1375		let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1376		-	let $~~t04915549219~~ = refreshDLpInternal(0, 0, 0)
1377		-	let dLpUpdateActions = $~~t04915549219~~._1
1378		-	let updatedDLp = $~~t04915549219~~._2
	1376	+	let $t04916549229 = refreshDLpInternal(0, 0, 0)
	1377	+	let dLpUpdateActions = $t04916549229._1
	1378	+	let updatedDLp = $t04916549229._2
1379	1379		let actions = if ((dLp != updatedDLp))
1380	1380		then dLpUpdateActions
1381	1381		else throwErr("nothing to refresh")

1403	1403		let newY = getYD(xp, index, D1)
1404	1404		let dy = (xp[index] - newY)
1405	1405		let totalGetRaw = max([0, toInt((dy - big1))])
1406		-	let $~~t05022950284~~ = takeFee(totalGetRaw, outFee)
1407		-	let totalGet = $~~t05022950284~~._1
1408		-	let feeAmount = $~~t05022950284~~._2
	1406	+	let $t05023950294 = takeFee(totalGetRaw, outFee)
	1407	+	let totalGet = $t05023950294._1
	1408	+	let feeAmount = $t05023950294._2
1409	1409		$Tuple2(nil, $Tuple2(totalGet, feeAmount))
1410	1410		}
1411	1411

1418	1418		let lpId = toBase58String(value(cfgLpAssetId))
1419	1419		let amBalance = getAccBalance(amId)
1420	1420		let prBalance = getAccBalance(prId)
1421		-	let $~~t05065950774~~ = {
	1421	+	let $t05066950784 = {
1422	1422		let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1423	1423		if ($isInstanceOf(@, "(Int, Int)"))
1424	1424		then @
1425	1425		else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1426	1426		}
1427		-	let totalGet = $~~t05065950774~~._1
1428		-	let feeAmount = $~~t05065950774~~._2
	1427	+	let totalGet = $t05066950784._1
	1428	+	let feeAmount = $t05066950784._2
1429	1429		let r = ego("", lpId, lpAssetAmount, this)
1430	1430		let outAmAmt = r._1
1431	1431		let outPrAmt = r._2

1459	1459		let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1460	1460		if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1461	1461		then {
1462		-	let $~~t05194052021~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1463		-	let refreshDLpActions = $~~t05194052021~~._1
1464		-	let updatedDLp = $~~t05194052021~~._2
	1462	+	let $t05195052031 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
	1463	+	let refreshDLpActions = $t05195052031._1
	1464	+	let updatedDLp = $t05195052031._2
1465	1465		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1466	1466		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1467	1467		then (state ++ refreshDLpActions)

1506	1506		let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1507	1507		if ((burnA == burnA))
1508	1508		then {
1509		-	let $~~t05304853129~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1510		-	let refreshDLpActions = $~~t05304853129~~._1
1511		-	let updatedDLp = $~~t05304853129~~._2
	1509	+	let $t05305853139 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
	1510	+	let refreshDLpActions = $t05305853139._1
	1511	+	let updatedDLp = $t05305853139._2
1512	1512		let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1513	1513		if ((isUpdatedDLpValid == isUpdatedDLpValid))
1514	1514		then (state ++ refreshDLpActions)

1559	1559		let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1560	1560		if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1561	1561		then {
1562		-	let $~~t05438054461~~ = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1563		-	let refreshDLpActions = $~~t05438054461~~._1

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 t1BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
74	74
75	75
76	76		func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
77	77
78	78
79	79		func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
80	80
81	81
82	82		func t2 (origVal,origScaleMult) = fraction(origVal, scale18, toBigInt(origScaleMult))
83	83
84	84
85	85		func f2 (val,resultScaleMult) = fraction(val, toBigInt(resultScaleMult), scale18)
86	86
87	87
88	88		func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
89	89
90	90
91	91		func abs (val) = if ((zeroBigInt > val))
92	92		then -(val)
93	93		else val
94	94
95	95
96	96		func absBigInt (val) = if ((zeroBigInt > val))
97	97		then -(val)
98	98		else val
99	99
100	100
101	101		func fc () = "%s__factoryContract"
102	102
103	103
104	104		func keyManagerPublicKey () = "%s__managerPublicKey"
105	105
106	106
107	107		func keyManagerVaultAddress () = "%s__managerVaultAddress"
108	108
109	109
110	110		func pl () = "%s%s__price__last"
111	111
112	112
113	113		func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
114	114
115	115
116	116		func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
117	117
118	118
119	119		func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
120	120
121	121
122	122		func aa () = "%s__amountAsset"
123	123
124	124
125	125		func pa () = "%s__priceAsset"
126	126
127	127
128	128		func amp () = "%s__amp"
129	129
130	130
131	131		func keyAmpHistory (heightBlocks) = ("%s%d__amp__" + toString(heightBlocks))
132	132
133	133
134	134		func keyChangeAmpLastCall () = "%s__changeAmpLastCall"
135	135
136	136
137	137		let keyFee = "%s__fee"
138	138
139	139		let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
140	140
141	141		let keyDLp = makeString(["%s", "dLp"], SEP)
142	142
143	143		let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
144	144
145	145		let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
146	146
147	147		let dLpRefreshDelayDefault = 30
148	148
149	149		let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
150	150
151	151		func fcfg () = "%s__factoryConfig"
152	152
153	153
154	154		func mtpk () = "%s%s__matcher__publicKey"
155	155
156	156
157	157		func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
158	158
159	159
160	160		func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
161	161
162	162
163	163		func aps () = "%s__shutdown"
164	164
165	165
166	166		func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
167	167
168	168
169	169		func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
170	170
171	171
172	172		func keySkipOrderValidation (poolAddress) = ("%s%s__skipOrderValidation__" + poolAddress)
173	173
174	174
175	175		func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
176	176
177	177
178	178		func addressFromStringOrThis (addressString) = match addressFromString(addressString) {
179	179		case a: Address =>
180	180		a
181	181		case _ =>
182	182		this
183	183		}
184	184
185	185
186	186		func getManagerVaultAddressOrThis () = {
187		-	let factoryAddress = match ~~addressFromStringOrThis~~(fc()) {
188		-	case fca: ~~Address~~ =>
189		-	fca
	187	+	let factoryAddress = match getString(fc()) {
	188	+	case fca: String =>
	189	+	addressFromStringOrThis(fca)
190	190		case _ =>
191	191		this
192	192		}
193	193		match getString(factoryAddress, keyManagerVaultAddress()) {
194	194		case s: String =>
195	195		addressFromStringOrThis(s)
196	196		case _ =>
197	197		this
198	198		}
199	199		}
200	200
201	201
202	202		func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
203	203
204	204
205	205		func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
206	206
207	207
208	208		func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
209	209
210	210
211	211		func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
212	212
213	213
214	214		let fca = addressFromStringValue(strf(this, fc()))
215	215
216	216		let inFee = {
217	217		let @ = invoke(fca, "getInFeeREADONLY", [toString(this)], nil)
218	218		if ($isInstanceOf(@, "Int"))
219	219		then @
220	220		else throw(($getType(@) + " couldn't be cast to Int"))
221	221		}
222	222
223	223		let outFee = {
224	224		let @ = invoke(fca, "getOutFeeREADONLY", [toString(this)], nil)
225	225		if ($isInstanceOf(@, "Int"))
226	226		then @
227	227		else throw(($getType(@) + " couldn't be cast to Int"))
228	228		}
229	229
230	230		let A = strf(this, amp())
231	231
232	232		func igs () = valueOrElse(getBoolean(fca, aps()), false)
233	233
234	234
235	235		func mp () = fromBase58String(strf(fca, mtpk()))
236	236
237	237
238	238		let feeCollectorAddress = addressFromStringValue(strf(fca, keyFeeCollectorAddress()))
239	239
240	240		func gpc () = {
241	241		let amtAs = strf(this, aa())
242	242		let priceAs = strf(this, pa())
243	243		let iPriceAs = intf(fca, mba(priceAs))
244	244		let iAmtAs = intf(fca, mba(amtAs))
245	245		split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
246	246		}
247	247
248	248
249	249		func parseAssetId (input) = if ((input == wavesString))
250	250		then unit
251	251		else fromBase58String(input)
252	252
253	253
254	254		func assetIdToString (input) = if ((input == unit))
255	255		then wavesString
256	256		else toBase58String(value(input))
257	257
258	258
259	259		func parsePoolConfig (poolConfig) = $Tuple9(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]), fromBase58String(poolConfig[idxIAmtAsId]), fromBase58String(poolConfig[idxIPriceAsId]))
260	260
261	261
262	262		let poolConfigParsed = parsePoolConfig(gpc())
263	263
264		-	let $~~t086768905~~ = poolConfigParsed
	264	+	let $t086868915 = poolConfigParsed
265	265
266		-	let cfgPoolAddress = $~~t086768905~~._1
	266	+	let cfgPoolAddress = $t086868915._1
267	267
268		-	let cfgPoolStatus = $~~t086768905~~._2
	268	+	let cfgPoolStatus = $t086868915._2
269	269
270		-	let cfgLpAssetId = $~~t086768905~~._3
	270	+	let cfgLpAssetId = $t086868915._3
271	271
272		-	let cfgAmountAssetId = $~~t086768905~~._4
	272	+	let cfgAmountAssetId = $t086868915._4
273	273
274		-	let cfgPriceAssetId = $~~t086768905~~._5
	274	+	let cfgPriceAssetId = $t086868915._5
275	275
276		-	let cfgAmountAssetDecimals = $~~t086768905~~._6
	276	+	let cfgAmountAssetDecimals = $t086868915._6
277	277
278		-	let cfgPriceAssetDecimals = $~~t086768905~~._7
	278	+	let cfgPriceAssetDecimals = $t086868915._7
279	279
280		-	let cfgInAmountAssedId = $~~t086768905~~._8
	280	+	let cfgInAmountAssedId = $t086868915._8
281	281
282		-	let cfgInPriceAssetId = $~~t086768905~~._9
	282	+	let cfgInPriceAssetId = $t086868915._9
283	283
284	284		func gfc () = split(strf(fca, fcfg()), SEP)
285	285
286	286
287	287		let factoryConfig = gfc()
288	288
289	289		let stakingContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactStakCntr]), "Invalid staking contract address")
290	290
291	291		let slipageContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactSlippCntr]), "Invalid slipage contract address")
292	292
293	293		let gwxContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactGwxRewCntr]), "Invalid gwx contract address")
294	294
295	295		let restContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactoryRestCntr]), "Invalid gwx contract address")
296	296
297	297		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)
298	298
299	299
300	300		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)
301	301
302	302
303	303		func getAccBalance (assetId) = if ((assetId == "WAVES"))
304	304		then wavesBalance(this).available
305	305		else assetBalance(this, fromBase58String(assetId))
306	306
307	307
308	308		func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
309	309
310	310
311	311		func cpbir (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
312	312
313	313
314	314		func vad (A1,A2,slippage) = {
315	315		let diff = fraction((A1 - A2), scale8BigInt, A2)
316	316		let pass = ((slippage - abs(diff)) > zeroBigInt)
317	317		if (!(pass))
318	318		then throw(("Big slpg: " + toString(diff)))
319	319		else $Tuple2(pass, min([A1, A2]))
320	320		}
321	321
322	322
323	323		func vd (D1,D0,slpg) = {
324	324		let diff = fraction(D0, scale8BigInt, D1)
325	325		let fail = (slpg > diff)
326	326		if (if (fail)
327	327		then true
328	328		else (D0 > D1))
329	329		then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
330	330		else fail
331	331		}
332	332
333	333
334	334		func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
335	335		let amtAsAmtX18 = t1(amAmt, amAssetDcm)
336	336		let prAsAmtX18 = t1(prAmt, prAssetDcm)
337	337		cpbi(prAsAmtX18, amtAsAmtX18)
338	338		}
339	339
340	340
341	341		func calcPrices (amAmt,prAmt,lpAmt) = {
342	342		let amtAsDcm = cfgAmountAssetDecimals
343	343		let prAsDcm = cfgPriceAssetDecimals
344	344		let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
345	345		let amAmtX18 = t1(amAmt, amtAsDcm)
346	346		let prAmtX18 = t1(prAmt, prAsDcm)
347	347		let lpAmtX18 = t1(lpAmt, scale8)
348	348		let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
349	349		let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
350	350		[priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
351	351		}
352	352
353	353
354	354		func calculatePrices (amAmt,prAmt,lpAmt) = {
355	355		let p = calcPrices(amAmt, prAmt, lpAmt)
356	356		[f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
357	357		}
358	358
359	359
360	360		func takeFee (amount,fee) = {
361	361		let feeAmount = if ((fee == 0))
362	362		then 0
363	363		else fraction(amount, fee, scale8)
364	364		$Tuple2((amount - feeAmount), feeAmount)
365	365		}
366	366
367	367
368	368		func getD (xp) = {
369	369		let xp0 = xp[0]
370	370		let xp1 = xp[1]
371	371		let s = (xp0 + xp1)
372	372		if ((s == big0))
373	373		then big0
374	374		else {
375	375		let a = parseIntValue(A)
376	376		let ann = (a * 2)
377	377		let p = fraction(xp0, xp1, big1)
378	378		let xp0_xp1_n_n = fraction(p, big4, big1)
379	379		let ann_s = fraction(toBigInt(ann), s, big1)
380	380		let ann_1 = toBigInt((ann - 1))
381	381		func calcDNext (d) = {
382	382		let dd = fraction(d, d, big1)
383	383		let ddd = fraction(dd, d, big1)
384	384		let dp = fraction(ddd, big1, xp0_xp1_n_n)
385	385		fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)))
386	386		}
387	387
388	388		func calc (acc,i) = if (acc._2)
389	389		then acc
390	390		else {
391	391		let d = acc._1
392	392		let dNext = calcDNext(d)
393	393		let dDiffRaw = (dNext - value(d))
394	394		let dDiff = if ((big0 > dDiffRaw))
395	395		then -(dDiffRaw)
396	396		else dDiffRaw
397	397		if ((big1 >= dDiff))
398	398		then $Tuple2(dNext, true)
399	399		else $Tuple2(dNext, false)
400	400		}
401	401
402	402		let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
403		-	let $~~t01341013458~~ = {
	403	+	let $t01342013468 = {
404	404		let $l = arr
405	405		let $s = size($l)
406	406		let $acc0 = $Tuple2(s, false)
407	407		func $f0_1 ($a,$i) = if (($i >= $s))
408	408		then $a
409	409		else calc($a, $l[$i])
410	410
411	411		func $f0_2 ($a,$i) = if (($i >= $s))
412	412		then $a
413	413		else throw("List size exceeds 17")
414	414
415	415		$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($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17)
416	416		}
417		-	let d = $~~t01341013458~~._1
418		-	let found = $~~t01341013458~~._2
	417	+	let d = $t01342013468._1
	418	+	let found = $t01342013468._2
419	419		if (found)
420	420		then d
421	421		else throw(("D calculation error, D = " + toString(d)))
422	422		}
423	423		}
424	424
425	425
426	426		func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
427	427		let lpId = cfgLpAssetId
428	428		let amId = toBase58String(value(cfgAmountAssetId))
429	429		let prId = toBase58String(value(cfgPriceAssetId))
430	430		let amDcm = cfgAmountAssetDecimals
431	431		let prDcm = cfgPriceAssetDecimals
432	432		let sts = toString(cfgPoolStatus)
433	433		let lpEmiss = valueOrErrorMessage(assetInfo(lpId), "Wrong LP id").quantity
434	434		if ((toBase58String(lpId) != pmtAssetId))
435	435		then throw("Wrong pmt asset")
436	436		else {
437	437		let amBalance = getAccBalance(amId)
438	438		let amBalanceX18 = t1(amBalance, amDcm)
439	439		let prBalance = getAccBalance(prId)
440	440		let prBalanceX18 = t1(prBalance, prDcm)
441	441		let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
442	442		let curPrice = f1(curPriceX18, scale8)
443	443		let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
444	444		let lpEmissX18 = t1(lpEmiss, scale8)
445	445		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
446	446		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
447	447		let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
448	448		let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
449	449		let state = if ((txId58 == ""))
450	450		then nil
451	451		else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
452	452		then unit
453	453		else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
454	454		then unit
455	455		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)]
456	456		$Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
457	457		}
458	458		}
459	459
460	460
461	461		func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
462	462		let lpId = cfgLpAssetId
463	463		let amIdStr = toBase58String(value(cfgAmountAssetId))
464	464		let prIdStr = toBase58String(value(cfgPriceAssetId))
465	465		let inAmIdStr = cfgInAmountAssedId
466	466		let inPrIdStr = cfgInPriceAssetId
467	467		let amtDcm = cfgAmountAssetDecimals
468	468		let priceDcm = cfgPriceAssetDecimals
469	469		let sts = toString(cfgPoolStatus)
470	470		let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
471	471		let amBalance = if (isEval)
472	472		then getAccBalance(amIdStr)
473	473		else if (if (isOneAsset)
474	474		then (pmtId == amIdStr)
475	475		else false)
476	476		then (getAccBalance(amIdStr) - pmtAmt)
477	477		else if (isOneAsset)
478	478		then getAccBalance(amIdStr)
479	479		else (getAccBalance(amIdStr) - inAmAmt)
480	480		let prBalance = if (isEval)
481	481		then getAccBalance(prIdStr)
482	482		else if (if (isOneAsset)
483	483		then (pmtId == prIdStr)
484	484		else false)

github/deemru/w8io/026f985 
262.96 ms ◑