w8 · tx · 7mW···8Mw

tx · 7mWrv7pbxVCnpUWfzKF62feDfZyuHpHSVWK9jYSZA8Mw

3N1dMZiRHyPfV3HE1UP73tMqZyrajT8s7Gd:  -0.02900000 Waves

2022.10.26 12:57 [2289239] smart account 3N1dMZiRHyPfV3HE1UP73tMqZyrajT8s7Gd > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7mWrv7pbxVCnpUWfzKF62feDfZyuHpHSVWK9jYSZA8Mw",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1666778221147,
    "version": 1,
    "sender": "3N1dMZiRHyPfV3HE1UP73tMqZyrajT8s7Gd",
    "senderPublicKey": "5nXNn4nUrku3ormf7LVLKqY9doTY1LZWZ3uDiDHre72C",
    "proofs": [
        "5wn5Cy4LD1pEGh75qzCNqxhELuycrPmsdEBp2Xpv8YQqZs6o8w9q8hdtHjmQnGDXoVaXxFcxY6hnp4eY6uSTNVh2"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2289239,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8Jo5rkDhssdckkq8A4qofY1JqirT1PnHsq5AdiLVeY7D
Next: FrFqyvkNdEafzrTHjG72U8WKMV69JVX3UoRagofFD1Gi

Diff: 
Old New Differences
467 467  
468 468  func calcPutOneToken (paymentAmountRaw,paymentAssetId,userAddress,txId) = {
469 469      let isEval = (txId == unit)
470 -     let $t02223222410 = parsePoolConfig(getPoolConfig())
471 -     let poolAddress = $t02223222410._1
472 -     let poolStatus = $t02223222410._2
473 -     let lpAssetId = $t02223222410._3
474 -     let amountAssetId = $t02223222410._4
475 -     let priceAssetId = $t02223222410._5
476 -     let amountAssetDecimals = $t02223222410._6
477 -     let priceAssetDecimals = $t02223222410._7
478 -     let amountBalanceRaw = getAccBalance(assetIdToString(amountAssetId))
479 -     let priceBalanceRaw = getAccBalance(assetIdToString(priceAssetId))
480 -     let paymentInAmountAsset = if ((paymentAssetId == amountAssetId))
470 +     let amountBalanceRaw = getAccBalance(assetIdToString(cfgAmountAssetId))
471 +     let priceBalanceRaw = getAccBalance(assetIdToString(cfgPriceAssetId))
472 +     let paymentInAmountAsset = if ((paymentAssetId == cfgAmountAssetId))
481 473          then true
482 -         else if ((paymentAssetId == priceAssetId))
474 +         else if ((paymentAssetId == cfgPriceAssetId))
483 475              then false
484 476              else throwErr("invalid asset")
485 -     let $t02274023033 = if (isEval)
477 +     let $t02257022863 = if (isEval)
486 478          then $Tuple2(amountBalanceRaw, priceBalanceRaw)
487 479          else if (paymentInAmountAsset)
488 480              then $Tuple2((amountBalanceRaw - paymentAmountRaw), priceBalanceRaw)
489 481              else $Tuple2(amountBalanceRaw, (priceBalanceRaw - paymentAmountRaw))
490 -     let amountBalanceOld = $t02274023033._1
491 -     let priceBalanceOld = $t02274023033._2
492 -     let $t02303723186 = if (paymentInAmountAsset)
482 +     let amountBalanceOld = $t02257022863._1
483 +     let priceBalanceOld = $t02257022863._2
484 +     let $t02286723016 = if (paymentInAmountAsset)
493 485          then $Tuple2(paymentAmountRaw, 0)
494 486          else $Tuple2(0, paymentAmountRaw)
495 -     let amountAssetAmountRaw = $t02303723186._1
496 -     let priceAssetAmountRaw = $t02303723186._2
487 +     let amountAssetAmountRaw = $t02286723016._1
488 +     let priceAssetAmountRaw = $t02286723016._2
497 489      let amountAssetAmount = takeFee(amountAssetAmountRaw)._1
498 490      let priceAssetAmount = takeFee(priceAssetAmountRaw)._1
499 -     let $t02330823367 = takeFee(paymentAmountRaw)
500 -     let paymentAmount = $t02330823367._1
501 -     let feeAmount = $t02330823367._2
491 +     let $t02313823197 = takeFee(paymentAmountRaw)
492 +     let paymentAmount = $t02313823197._1
493 +     let feeAmount = $t02313823197._2
502 494      let amountBalanceNew = (amountBalanceOld + amountAssetAmount)
503 495      let priceBalanceNew = (priceBalanceOld + priceAssetAmount)
504 -     let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, priceAssetDecimals), toX18(amountBalanceNew, amountAssetDecimals))
496 +     let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, cfgPriceAssetDecimals), toX18(amountBalanceNew, cfgAmountAssetDecimals))
505 497      let priceNew = fromX18(priceNewX18, scale8)
506 498      let paymentBalance = if (paymentInAmountAsset)
507 499          then amountBalanceOld
508 500          else priceBalanceOld
509 501      let paymentBalanceBigInt = toBigInt(paymentBalance)
510 -     let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
502 +     let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
511 503      let chechSupply = if ((supplyBigInt > big0))
512 504          then true
513 505          else throwErr("initial deposit requires all coins")
518 510              let commonState = if (isEval)
519 511                  then nil
520 512                  else [IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew), StringEntry(pau(toString(value(userAddress)), toBase58String(value(txId))), dataPutActionInfo(amountAssetAmountRaw, priceAssetAmountRaw, issueAmount, priceNew, 0, 0, height, lastBlock.timestamp, 0, 0))]
521 -             let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, priceAssetDecimals), toX18(amountBalanceOld, amountAssetDecimals))
513 +             let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, cfgPriceAssetDecimals), toX18(amountBalanceOld, cfgAmountAssetDecimals))
522 514              let priceOld = fromX18(priceOldX18, scale8)
523 515              let priceImpact = abs((((priceNew - priceOld) * scale8) / priceOld))
524 516              $Tuple4(issueAmount, commonState, feeAmount, priceImpact)
529 521  
530 522  func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
531 523      let isEval = (txId == unit)
532 -     let $t02518925350 = parsePoolConfig(getPoolConfig())
533 -     let poolAddress = $t02518925350._1
534 -     let poolStatus = $t02518925350._2
535 -     let lpAssetId = $t02518925350._3
536 -     let amountAssetId = $t02518925350._4
537 -     let priceAssetId = $t02518925350._5
538 -     let amDecimals = $t02518925350._6
539 -     let prDecimals = $t02518925350._7
540 -     let checks = [if ((paymentAssetId == lpAssetId))
524 +     let checks = [if ((paymentAssetId == cfgLpAssetId))
541 525          then true
542 526          else throwErr("invalid lp asset")]
543 527      if ((checks == checks))
544 528          then {
545 -             let outInAmountAsset = if ((outAssetId == amountAssetId))
529 +             let outInAmountAsset = if ((outAssetId == cfgAmountAssetId))
546 530                  then true
547 -                 else if ((outAssetId == priceAssetId))
531 +                 else if ((outAssetId == cfgPriceAssetId))
548 532                      then false
549 533                      else throwErr("invalid asset")
550 534              let balanceBigInt = if (outInAmountAsset)
551 -                 then toBigInt(getAccBalance(assetIdToString(amountAssetId)))
552 -                 else toBigInt(getAccBalance(assetIdToString(priceAssetId)))
553 -             let amBalanceOld = getAccBalance(assetIdToString(amountAssetId))
554 -             let prBalanceOld = getAccBalance(assetIdToString(priceAssetId))
535 +                 then toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId)))
536 +                 else toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId)))
537 +             let amBalanceOld = getAccBalance(assetIdToString(cfgAmountAssetId))
538 +             let prBalanceOld = getAccBalance(assetIdToString(cfgPriceAssetId))
555 539              let outBalance = if (outInAmountAsset)
556 540                  then amBalanceOld
557 541                  else prBalanceOld
558 542              let outBalanceBigInt = toBigInt(outBalance)
559 -             let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
543 +             let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
560 544              let redeemedBigInt = toBigInt(paymentAmount)
561 545              let amountRaw = max([0, toInt(((balanceBigInt * (scale18 - pow((scale18 - ((redeemedBigInt * scale18) / supplyBigInt)), 18, big2, 0, 18, DOWN))) / scale18))])
562 -             let $t02642526475 = takeFee(amountRaw)
563 -             let totalAmount = $t02642526475._1
564 -             let feeAmount = $t02642526475._2
565 -             let $t02647926705 = if (outInAmountAsset)
546 +             let $t02613526185 = takeFee(amountRaw)
547 +             let totalAmount = $t02613526185._1
548 +             let feeAmount = $t02613526185._2
549 +             let $t02618926415 = if (outInAmountAsset)
566 550                  then $Tuple4(totalAmount, 0, (amBalanceOld - amountRaw), prBalanceOld)
567 551                  else $Tuple4(0, totalAmount, amBalanceOld, (prBalanceOld - amountRaw))
568 -             let outAmAmount = $t02647926705._1
569 -             let outPrAmount = $t02647926705._2
570 -             let amBalanceNew = $t02647926705._3
571 -             let prBalanceNew = $t02647926705._4
572 -             let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, prDecimals), toX18(amBalanceNew, amDecimals))
552 +             let outAmAmount = $t02618926415._1
553 +             let outPrAmount = $t02618926415._2
554 +             let amBalanceNew = $t02618926415._3
555 +             let prBalanceNew = $t02618926415._4
556 +             let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, cfgPriceAssetDecimals), toX18(amBalanceNew, cfgAmountAssetDecimals))
573 557              let priceNew = fromX18(priceNewX18, scale8)
574 558              let commonState = if (isEval)
575 559                  then nil
576 560                  else [StringEntry(gau(toString(value(userAddress)), toBase58String(value(txId))), dataGetActionInfo(outAmAmount, outPrAmount, paymentAmount, priceNew, height, lastBlock.timestamp)), IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew)]
577 -             let priceOldX18 = calcPriceBigInt(toX18(prBalanceOld, prDecimals), toX18(amBalanceOld, amDecimals))
561 +             let priceOldX18 = calcPriceBigInt(toX18(prBalanceOld, cfgPriceAssetDecimals), toX18(amBalanceOld, cfgAmountAssetDecimals))
578 562              let priceOld = fromX18(priceOldX18, scale8)
579 563              let priceImpact = abs((((priceNew - priceOld) * scale8) / priceOld))
580 564              $Tuple4(totalAmount, commonState, feeAmount, priceImpact)
721 705  
722 706  @Callable(i)
723 707  func putOneTkn (minOutAmount,autoStake) = {
724 -     let isPutDisabled = if (if (isGlobalShutdown())
708 +     let isPoolOneTokenOperationsDisabled = {
709 +         let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
710 +         if ($isInstanceOf(@, "Boolean"))
711 +             then @
712 +             else throw(($getType(@) + " couldn't be cast to Boolean"))
713 +         }
714 +     let isPutDisabled = if (if (if (isGlobalShutdown())
725 715          then true
726 716          else (cfgPoolStatus == PoolPutDisabled))
727 717          then true
728 -         else (cfgPoolStatus == PoolShutdown)
718 +         else (cfgPoolStatus == PoolShutdown))
719 +         then true
720 +         else isPoolOneTokenOperationsDisabled
729 721      let checks = [if (!(isPutDisabled))
730 722          then true
731 723          else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
738 730              let paymentAmountRaw = payment.amount
739 731              let userAddress = i.caller
740 732              let txId = i.transactionId
741 -             let $t03105731184 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
742 -             let emitAmountEstimated = $t03105731184._1
743 -             let commonState = $t03105731184._2
744 -             let feeAmount = $t03105731184._3
745 -             let bonus = $t03105731184._4
733 +             let $t03099731124 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
734 +             let emitAmountEstimated = $t03099731124._1
735 +             let commonState = $t03099731124._2
736 +             let feeAmount = $t03099731124._3
737 +             let bonus = $t03099731124._4
746 738              let emitAmount = if (if ((minOutAmount > 0))
747 739                  then (minOutAmount > emitAmountEstimated)
748 740                  else false)
773 765  
774 766  @Callable(i)
775 767  func putOneTknREADONLY (paymentAssetId,paymentAmountRaw) = {
776 -     let $t03191332048 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
777 -     let emitAmountEstimated = $t03191332048._1
778 -     let commonState = $t03191332048._2
779 -     let feeAmount = $t03191332048._3
780 -     let bonus = $t03191332048._4
768 +     let $t03185331988 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
769 +     let emitAmountEstimated = $t03185331988._1
770 +     let commonState = $t03185331988._2
771 +     let feeAmount = $t03185331988._3
772 +     let bonus = $t03185331988._4
781 773      $Tuple2(nil, $Tuple3(emitAmountEstimated, feeAmount, bonus))
782 774      }
783 775  
785 777  
786 778  @Callable(i)
787 779  func getOneTkn (outAssetIdStr,minOutAmount) = {
788 -     let isGetDisabled = if (isGlobalShutdown())
780 +     let isPoolOneTokenOperationsDisabled = {
781 +         let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
782 +         if ($isInstanceOf(@, "Boolean"))
783 +             then @
784 +             else throw(($getType(@) + " couldn't be cast to Boolean"))
785 +         }
786 +     let isGetDisabled = if (if (isGlobalShutdown())
789 787          then true
790 -         else (cfgPoolStatus == PoolShutdown)
788 +         else (cfgPoolStatus == PoolShutdown))
789 +         then true
790 +         else isPoolOneTokenOperationsDisabled
791 791      let checks = [if (!(isGetDisabled))
792 792          then true
793 793          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
801 801              let paymentAmount = payment.amount
802 802              let userAddress = i.caller
803 803              let txId = i.transactionId
804 -             let $t03263632768 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
805 -             let amountEstimated = $t03263632768._1
806 -             let commonState = $t03263632768._2
807 -             let feeAmount = $t03263632768._3
808 -             let bonus = $t03263632768._4
804 +             let $t03276032892 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
805 +             let amountEstimated = $t03276032892._1
806 +             let commonState = $t03276032892._2
807 +             let feeAmount = $t03276032892._3
808 +             let bonus = $t03276032892._4
809 809              let amount = if (if ((minOutAmount > 0))
810 810                  then (minOutAmount > amountEstimated)
811 811                  else false)
829 829  
830 830  @Callable(i)
831 831  func getOneTknREADONLY (outAssetId,paymentAmount) = {
832 -     let $t03340333541 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
833 -     let amountEstimated = $t03340333541._1
834 -     let commonState = $t03340333541._2
835 -     let feeAmount = $t03340333541._3
836 -     let bonus = $t03340333541._4
832 +     let $t03352733665 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
833 +     let amountEstimated = $t03352733665._1
834 +     let commonState = $t03352733665._2
835 +     let feeAmount = $t03352733665._3
836 +     let bonus = $t03352733665._4
837 837      $Tuple2(nil, $Tuple3(amountEstimated, feeAmount, bonus))
838 838      }
839 839  
841 841  
842 842  @Callable(i)
843 843  func unstakeAndGetOneTkn (unstakeAmount,outAssetIdStr,minOutAmount) = {
844 -     let isGetDisabled = if (isGlobalShutdown())
844 +     let isPoolOneTokenOperationsDisabled = {
845 +         let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
846 +         if ($isInstanceOf(@, "Boolean"))
847 +             then @
848 +             else throw(($getType(@) + " couldn't be cast to Boolean"))
849 +         }
850 +     let isGetDisabled = if (if (isGlobalShutdown())
845 851          then true
846 -         else (cfgPoolStatus == PoolShutdown)
852 +         else (cfgPoolStatus == PoolShutdown))
853 +         then true
854 +         else isPoolOneTokenOperationsDisabled
847 855      let checks = [if (!(isGetDisabled))
848 856          then true
849 857          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 0))
857 865              let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
858 866              if ((unstakeInv == unstakeInv))
859 867                  then {
860 -                     let $t03414934279 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
861 -                     let amountEstimated = $t03414934279._1
862 -                     let commonState = $t03414934279._2
863 -                     let feeAmount = $t03414934279._3
864 -                     let bonus = $t03414934279._4
868 +                     let $t03445734587 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
869 +                     let amountEstimated = $t03445734587._1
870 +                     let commonState = $t03445734587._2
871 +                     let feeAmount = $t03445734587._3
872 +                     let bonus = $t03445734587._4
865 873                      let amount = if (if ((minOutAmount > 0))
866 874                          then (minOutAmount > amountEstimated)
867 875                          else false)
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let lPdecimals = 8
5 5  
6 6  let scale8 = 100000000
7 7  
8 8  let scale8BigInt = toBigInt(100000000)
9 9  
10 10  let scale18 = toBigInt(1000000000000000000)
11 11  
12 12  let zeroBigInt = toBigInt(0)
13 13  
14 14  let big0 = toBigInt(0)
15 15  
16 16  let big1 = toBigInt(1)
17 17  
18 18  let big2 = toBigInt(2)
19 19  
20 20  let wavesString = "WAVES"
21 21  
22 22  let SEP = "__"
23 23  
24 24  let PoolActive = 1
25 25  
26 26  let PoolPutDisabled = 2
27 27  
28 28  let PoolMatcherDisabled = 3
29 29  
30 30  let PoolShutdown = 4
31 31  
32 32  let idxPoolAddress = 1
33 33  
34 34  let idxPoolStatus = 2
35 35  
36 36  let idxPoolLPAssetId = 3
37 37  
38 38  let idxAmtAssetId = 4
39 39  
40 40  let idxPriceAssetId = 5
41 41  
42 42  let idxAmtAssetDcm = 6
43 43  
44 44  let idxPriceAssetDcm = 7
45 45  
46 46  let idxIAmtAssetId = 8
47 47  
48 48  let idxIPriceAssetId = 9
49 49  
50 50  let idxLPAssetDcm = 10
51 51  
52 52  let idxPoolAmtAssetAmt = 1
53 53  
54 54  let idxPoolPriceAssetAmt = 2
55 55  
56 56  let idxPoolLPAssetAmt = 3
57 57  
58 58  let idxFactoryStakingContract = 1
59 59  
60 60  let idxFactorySlippageContract = 7
61 61  
62 62  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
63 63  
64 64  
65 65  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
66 66  
67 67  
68 68  func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
69 69  
70 70  
71 71  func abs (val) = if ((0 > val))
72 72      then -(val)
73 73      else val
74 74  
75 75  
76 76  func absBigInt (val) = if ((zeroBigInt > val))
77 77      then -(val)
78 78      else val
79 79  
80 80  
81 81  func fc () = "%s__factoryContract"
82 82  
83 83  
84 84  func mpk () = "%s__managerPublicKey"
85 85  
86 86  
87 87  func pmpk () = "%s__pendingManagerPublicKey"
88 88  
89 89  
90 90  func pl () = "%s%s__price__last"
91 91  
92 92  
93 93  func ph (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
94 94  
95 95  
96 96  func pau (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
97 97  
98 98  
99 99  func gau (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
100 100  
101 101  
102 102  func aa () = "%s__amountAsset"
103 103  
104 104  
105 105  func pa () = "%s__priceAsset"
106 106  
107 107  
108 108  let keyFee = "%s__fee"
109 109  
110 110  let feeDefault = fraction(5, scale8, 10000)
111 111  
112 112  let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
113 113  
114 114  func keyFactoryConfig () = "%s__factoryConfig"
115 115  
116 116  
117 117  func keyMatcherPub () = "%s%s__matcher__publicKey"
118 118  
119 119  
120 120  func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
121 121  
122 122  
123 123  func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
124 124  
125 125  
126 126  func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
127 127  
128 128  
129 129  func keyAllPoolsShutdown () = "%s__shutdown"
130 130  
131 131  
132 132  func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
133 133  
134 134  
135 135  func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
136 136  
137 137  
138 138  let keyFeeCollectorAddress = "%s__feeCollectorAddress"
139 139  
140 140  func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
141 141  
142 142  
143 143  func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
144 144  
145 145  
146 146  func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
147 147  
148 148  
149 149  func throwErr (msg) = throw(makeString(["lp.ride:", msg], " "))
150 150  
151 151  
152 152  let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))
153 153  
154 154  let feeCollectorAddress = addressFromStringValue(getStringOrFail(factoryContract, keyFeeCollectorAddress))
155 155  
156 156  func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
157 157  
158 158  
159 159  func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
160 160  
161 161  
162 162  func getPoolConfig () = {
163 163      let amtAsset = getStringOrFail(this, aa())
164 164      let priceAsset = getStringOrFail(this, pa())
165 165      let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
166 166      let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
167 167      split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
168 168      }
169 169  
170 170  
171 171  func parseAssetId (input) = if ((input == wavesString))
172 172      then unit
173 173      else fromBase58String(input)
174 174  
175 175  
176 176  func assetIdToString (input) = if ((input == unit))
177 177      then wavesString
178 178      else toBase58String(value(input))
179 179  
180 180  
181 181  func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolStatus]), fromBase58String(poolConfig[idxPoolLPAssetId]), parseAssetId(poolConfig[idxAmtAssetId]), parseAssetId(poolConfig[idxPriceAssetId]), parseIntValue(poolConfig[idxAmtAssetDcm]), parseIntValue(poolConfig[idxPriceAssetDcm]))
182 182  
183 183  
184 184  let poolConfigParsed = parsePoolConfig(getPoolConfig())
185 185  
186 186  let $t075437709 = poolConfigParsed
187 187  
188 188  let cfgPoolAddress = $t075437709._1
189 189  
190 190  let cfgPoolStatus = $t075437709._2
191 191  
192 192  let cfgLpAssetId = $t075437709._3
193 193  
194 194  let cfgAmountAssetId = $t075437709._4
195 195  
196 196  let cfgPriceAssetId = $t075437709._5
197 197  
198 198  let cfgAmountAssetDecimals = $t075437709._6
199 199  
200 200  let cfgPriceAssetDecimals = $t075437709._7
201 201  
202 202  func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
203 203  
204 204  
205 205  let stakingContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactoryStakingContract]), "incorrect staking address")
206 206  
207 207  let slippageContract = valueOrErrorMessage(addressFromString(getFactoryConfig()[idxFactorySlippageContract]), "incorrect staking address")
208 208  
209 209  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
210 210  
211 211  
212 212  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)
213 213  
214 214  
215 215  func getAccBalance (assetId) = if ((assetId == "WAVES"))
216 216      then wavesBalance(this).available
217 217      else assetBalance(this, fromBase58String(assetId))
218 218  
219 219  
220 220  func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
221 221  
222 222  
223 223  func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
224 224      let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
225 225      let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
226 226      calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
227 227      }
228 228  
229 229  
230 230  func calcPrices (amAmt,prAmt,lpAmt) = {
231 231      let cfg = getPoolConfig()
232 232      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
233 233      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
234 234      let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
235 235      let amAmtX18 = toX18(amAmt, amtAssetDcm)
236 236      let prAmtX18 = toX18(prAmt, priceAssetDcm)
237 237      let lpAmtX18 = toX18(lpAmt, scale8)
238 238      let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
239 239      let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
240 240  [priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
241 241      }
242 242  
243 243  
244 244  func calculatePrices (amAmt,prAmt,lpAmt) = {
245 245      let prices = calcPrices(amAmt, prAmt, lpAmt)
246 246  [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
247 247      }
248 248  
249 249  
250 250  func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
251 251      let cfg = getPoolConfig()
252 252      let lpAssetId = cfg[idxPoolLPAssetId]
253 253      let amAssetId = cfg[idxAmtAssetId]
254 254      let prAssetId = cfg[idxPriceAssetId]
255 255      let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
256 256      let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
257 257      let poolStatus = cfg[idxPoolStatus]
258 258      let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
259 259      if ((lpAssetId != pmtAssetId))
260 260          then throw("Invalid asset passed.")
261 261          else {
262 262              let amBalance = getAccBalance(amAssetId)
263 263              let amBalanceX18 = toX18(amBalance, amAssetDcm)
264 264              let prBalance = getAccBalance(prAssetId)
265 265              let prBalanceX18 = toX18(prBalance, prAssetDcm)
266 266              let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
267 267              let curPrice = fromX18(curPriceX18, scale8)
268 268              let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
269 269              let lpEmissionX18 = toX18(lpEmission, scale8)
270 270              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
271 271              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
272 272              let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
273 273              let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
274 274              let state = if ((txId58 == ""))
275 275                  then nil
276 276                  else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
277 277                      then unit
278 278                      else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
279 279                      then unit
280 280                      else fromBase58String(prAssetId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
281 281              $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
282 282              }
283 283      }
284 284  
285 285  
286 286  func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
287 287      let cfg = getPoolConfig()
288 288      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
289 289      let amAssetIdStr = cfg[idxAmtAssetId]
290 290      let prAssetIdStr = cfg[idxPriceAssetId]
291 291      let iAmtAssetId = cfg[idxIAmtAssetId]
292 292      let iPriceAssetId = cfg[idxIPriceAssetId]
293 293      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
294 294      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
295 295      let poolStatus = cfg[idxPoolStatus]
296 296      let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
297 297      let inAmAssetIdStr = toBase58String(valueOrElse(inAmAssetId, fromBase58String("WAVES")))
298 298      let inPrAssetIdStr = toBase58String(valueOrElse(inPrAssetId, fromBase58String("WAVES")))
299 299      if (if ((amAssetIdStr != inAmAssetIdStr))
300 300          then true
301 301          else (prAssetIdStr != inPrAssetIdStr))
302 302          then throw("Invalid amt or price asset passed.")
303 303          else {
304 304              let amBalance = if (isEvaluate)
305 305                  then getAccBalance(amAssetIdStr)
306 306                  else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
307 307              let prBalance = if (isEvaluate)
308 308                  then getAccBalance(prAssetIdStr)
309 309                  else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
310 310              let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
311 311              let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
312 312              let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
313 313              let amBalanceX18 = toX18(amBalance, amtAssetDcm)
314 314              let prBalanceX18 = toX18(prBalance, priceAssetDcm)
315 315              let res = if ((lpEmission == 0))
316 316                  then {
317 317                      let curPriceX18 = zeroBigInt
318 318                      let slippageX18 = zeroBigInt
319 319                      let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
320 320                      $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
321 321                      }
322 322                  else {
323 323                      let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
324 324                      let slippageX18 = fraction(absBigInt((curPriceX18 - userPriceX18)), scale18, curPriceX18)
325 325                      let slippageToleranceX18 = toX18(slippageTolerance, scale8)
326 326                      if (if ((curPriceX18 != zeroBigInt))
327 327                          then (slippageX18 > slippageToleranceX18)
328 328                          else false)
329 329                          then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
330 330                          else {
331 331                              let lpEmissionX18 = toX18(lpEmission, scale8)
332 332                              let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
333 333                              let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
334 334                              let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
335 335                                  then $Tuple2(amViaPrX18, inPrAssetAmtX18)
336 336                                  else $Tuple2(inAmAssetAmtX18, prViaAmX18)
337 337                              let expAmtAssetAmtX18 = expectedAmts._1
338 338                              let expPriceAssetAmtX18 = expectedAmts._2
339 339                              let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
340 340                              $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
341 341                              }
342 342                      }
343 343              let calcLpAmt = res._1
344 344              let calcAmAssetPmt = res._2
345 345              let calcPrAssetPmt = res._3
346 346              let curPrice = fromX18(res._4, scale8)
347 347              let slippageCalc = fromX18(res._5, scale8)
348 348              if ((0 >= calcLpAmt))
349 349                  then throw("Invalid calculations. LP calculated is less than zero.")
350 350                  else {
351 351                      let emitLpAmt = if (!(emitLp))
352 352                          then 0
353 353                          else calcLpAmt
354 354                      let amDiff = (inAmAssetAmt - calcAmAssetPmt)
355 355                      let prDiff = (inPrAssetAmt - calcPrAssetPmt)
356 356                      let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
357 357                      $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
358 358                      }
359 359              }
360 360      }
361 361  
362 362  
363 363  func validateMatcherOrderAllowed (order) = {
364 364      let cfg = getPoolConfig()
365 365      let amtAssetId = cfg[idxAmtAssetId]
366 366      let priceAssetId = cfg[idxPriceAssetId]
367 367      let poolStatus = parseIntValue(cfg[idxPoolStatus])
368 368      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
369 369      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
370 370      let accAmtAssetBalance = getAccBalance(amtAssetId)
371 371      let accPriceAssetBalance = getAccBalance(priceAssetId)
372 372      let curPriceX18 = if ((order.orderType == Buy))
373 373          then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
374 374          else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
375 375      let curPrice = fromX18(curPriceX18, scale8)
376 376      if (if (if (isGlobalShutdown())
377 377          then true
378 378          else (poolStatus == PoolMatcherDisabled))
379 379          then true
380 380          else (poolStatus == PoolShutdown))
381 381          then throw("Exchange operations disabled")
382 382          else {
383 383              let orderAmtAsset = order.assetPair.amountAsset
384 384              let orderAmtAssetStr = if ((orderAmtAsset == unit))
385 385                  then "WAVES"
386 386                  else toBase58String(value(orderAmtAsset))
387 387              let orderPriceAsset = order.assetPair.priceAsset
388 388              let orderPriceAssetStr = if ((orderPriceAsset == unit))
389 389                  then "WAVES"
390 390                  else toBase58String(value(orderPriceAsset))
391 391              if (if ((orderAmtAssetStr != amtAssetId))
392 392                  then true
393 393                  else (orderPriceAssetStr != priceAssetId))
394 394                  then throw("Wrong order assets.")
395 395                  else {
396 396                      let orderPrice = order.price
397 397                      let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
398 398                      let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
399 399                      let isOrderPriceValid = if ((order.orderType == Buy))
400 400                          then (curPrice >= castedOrderPrice)
401 401                          else (castedOrderPrice >= curPrice)
402 402                      true
403 403                      }
404 404              }
405 405      }
406 406  
407 407  
408 408  func commonGet (i) = if ((size(i.payments) != 1))
409 409      then throw("exactly 1 payment is expected")
410 410      else {
411 411          let pmt = value(i.payments[0])
412 412          let pmtAssetId = value(pmt.assetId)
413 413          let pmtAmt = pmt.amount
414 414          let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
415 415          let outAmAmt = res._1
416 416          let outPrAmt = res._2
417 417          let poolStatus = parseIntValue(res._9)
418 418          let state = res._10
419 419          if (if (isGlobalShutdown())
420 420              then true
421 421              else (poolStatus == PoolShutdown))
422 422              then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
423 423              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
424 424          }
425 425  
426 426  
427 427  func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
428 428      then throw("exactly 2 payments are expected")
429 429      else {
430 430          let amAssetPmt = value(i.payments[0])
431 431          let prAssetPmt = value(i.payments[1])
432 432          let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp)
433 433          let poolStatus = parseIntValue(estPut._8)
434 434          if (if (if (isGlobalShutdown())
435 435              then true
436 436              else (poolStatus == PoolPutDisabled))
437 437              then true
438 438              else (poolStatus == PoolShutdown))
439 439              then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
440 440              else estPut
441 441          }
442 442  
443 443  
444 444  func emit (amount) = {
445 445      let emitInv = invoke(factoryContract, "emit", [amount], nil)
446 446      if ((emitInv == emitInv))
447 447          then {
448 448              let emitInvLegacy =             match emitInv {
449 449                  case legacyFactoryContract: Address => 
450 450                      invoke(legacyFactoryContract, "emit", [amount], nil)
451 451                  case _ => 
452 452                      unit
453 453              }
454 454              if ((emitInvLegacy == emitInvLegacy))
455 455                  then amount
456 456                  else throw("Strict value is not equal to itself.")
457 457              }
458 458          else throw("Strict value is not equal to itself.")
459 459      }
460 460  
461 461  
462 462  func takeFee (amount) = {
463 463      let feeAmount = fraction(amount, fee, scale8)
464 464      $Tuple2((amount - feeAmount), feeAmount)
465 465      }
466 466  
467 467  
468 468  func calcPutOneToken (paymentAmountRaw,paymentAssetId,userAddress,txId) = {
469 469      let isEval = (txId == unit)
470 -     let $t02223222410 = parsePoolConfig(getPoolConfig())
471 -     let poolAddress = $t02223222410._1
472 -     let poolStatus = $t02223222410._2
473 -     let lpAssetId = $t02223222410._3
474 -     let amountAssetId = $t02223222410._4
475 -     let priceAssetId = $t02223222410._5
476 -     let amountAssetDecimals = $t02223222410._6
477 -     let priceAssetDecimals = $t02223222410._7
478 -     let amountBalanceRaw = getAccBalance(assetIdToString(amountAssetId))
479 -     let priceBalanceRaw = getAccBalance(assetIdToString(priceAssetId))
480 -     let paymentInAmountAsset = if ((paymentAssetId == amountAssetId))
470 +     let amountBalanceRaw = getAccBalance(assetIdToString(cfgAmountAssetId))
471 +     let priceBalanceRaw = getAccBalance(assetIdToString(cfgPriceAssetId))
472 +     let paymentInAmountAsset = if ((paymentAssetId == cfgAmountAssetId))
481 473          then true
482 -         else if ((paymentAssetId == priceAssetId))
474 +         else if ((paymentAssetId == cfgPriceAssetId))
483 475              then false
484 476              else throwErr("invalid asset")
485 -     let $t02274023033 = if (isEval)
477 +     let $t02257022863 = if (isEval)
486 478          then $Tuple2(amountBalanceRaw, priceBalanceRaw)
487 479          else if (paymentInAmountAsset)
488 480              then $Tuple2((amountBalanceRaw - paymentAmountRaw), priceBalanceRaw)
489 481              else $Tuple2(amountBalanceRaw, (priceBalanceRaw - paymentAmountRaw))
490 -     let amountBalanceOld = $t02274023033._1
491 -     let priceBalanceOld = $t02274023033._2
492 -     let $t02303723186 = if (paymentInAmountAsset)
482 +     let amountBalanceOld = $t02257022863._1
483 +     let priceBalanceOld = $t02257022863._2
484 +     let $t02286723016 = if (paymentInAmountAsset)
493 485          then $Tuple2(paymentAmountRaw, 0)
494 486          else $Tuple2(0, paymentAmountRaw)
495 -     let amountAssetAmountRaw = $t02303723186._1
496 -     let priceAssetAmountRaw = $t02303723186._2
487 +     let amountAssetAmountRaw = $t02286723016._1
488 +     let priceAssetAmountRaw = $t02286723016._2
497 489      let amountAssetAmount = takeFee(amountAssetAmountRaw)._1
498 490      let priceAssetAmount = takeFee(priceAssetAmountRaw)._1
499 -     let $t02330823367 = takeFee(paymentAmountRaw)
500 -     let paymentAmount = $t02330823367._1
501 -     let feeAmount = $t02330823367._2
491 +     let $t02313823197 = takeFee(paymentAmountRaw)
492 +     let paymentAmount = $t02313823197._1
493 +     let feeAmount = $t02313823197._2
502 494      let amountBalanceNew = (amountBalanceOld + amountAssetAmount)
503 495      let priceBalanceNew = (priceBalanceOld + priceAssetAmount)
504 -     let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, priceAssetDecimals), toX18(amountBalanceNew, amountAssetDecimals))
496 +     let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, cfgPriceAssetDecimals), toX18(amountBalanceNew, cfgAmountAssetDecimals))
505 497      let priceNew = fromX18(priceNewX18, scale8)
506 498      let paymentBalance = if (paymentInAmountAsset)
507 499          then amountBalanceOld
508 500          else priceBalanceOld
509 501      let paymentBalanceBigInt = toBigInt(paymentBalance)
510 -     let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
502 +     let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
511 503      let chechSupply = if ((supplyBigInt > big0))
512 504          then true
513 505          else throwErr("initial deposit requires all coins")
514 506      if ((chechSupply == chechSupply))
515 507          then {
516 508              let depositBigInt = toBigInt(paymentAmount)
517 509              let issueAmount = max([0, toInt(((supplyBigInt * (sqrtBigInt((scale18 + ((depositBigInt * scale18) / paymentBalanceBigInt)), 18, 18, DOWN) - scale18)) / scale18))])
518 510              let commonState = if (isEval)
519 511                  then nil
520 512                  else [IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew), StringEntry(pau(toString(value(userAddress)), toBase58String(value(txId))), dataPutActionInfo(amountAssetAmountRaw, priceAssetAmountRaw, issueAmount, priceNew, 0, 0, height, lastBlock.timestamp, 0, 0))]
521 -             let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, priceAssetDecimals), toX18(amountBalanceOld, amountAssetDecimals))
513 +             let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, cfgPriceAssetDecimals), toX18(amountBalanceOld, cfgAmountAssetDecimals))
522 514              let priceOld = fromX18(priceOldX18, scale8)
523 515              let priceImpact = abs((((priceNew - priceOld) * scale8) / priceOld))
524 516              $Tuple4(issueAmount, commonState, feeAmount, priceImpact)
525 517              }
526 518          else throw("Strict value is not equal to itself.")
527 519      }
528 520  
529 521  
530 522  func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
531 523      let isEval = (txId == unit)
532 -     let $t02518925350 = parsePoolConfig(getPoolConfig())
533 -     let poolAddress = $t02518925350._1
534 -     let poolStatus = $t02518925350._2
535 -     let lpAssetId = $t02518925350._3
536 -     let amountAssetId = $t02518925350._4
537 -     let priceAssetId = $t02518925350._5
538 -     let amDecimals = $t02518925350._6
539 -     let prDecimals = $t02518925350._7
540 -     let checks = [if ((paymentAssetId == lpAssetId))
524 +     let checks = [if ((paymentAssetId == cfgLpAssetId))
541 525          then true
542 526          else throwErr("invalid lp asset")]
543 527      if ((checks == checks))
544 528          then {
545 -             let outInAmountAsset = if ((outAssetId == amountAssetId))
529 +             let outInAmountAsset = if ((outAssetId == cfgAmountAssetId))
546 530                  then true
547 -                 else if ((outAssetId == priceAssetId))
531 +                 else if ((outAssetId == cfgPriceAssetId))
548 532                      then false
549 533                      else throwErr("invalid asset")
550 534              let balanceBigInt = if (outInAmountAsset)
551 -                 then toBigInt(getAccBalance(assetIdToString(amountAssetId)))
552 -                 else toBigInt(getAccBalance(assetIdToString(priceAssetId)))
553 -             let amBalanceOld = getAccBalance(assetIdToString(amountAssetId))
554 -             let prBalanceOld = getAccBalance(assetIdToString(priceAssetId))
535 +                 then toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId)))
536 +                 else toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId)))
537 +             let amBalanceOld = getAccBalance(assetIdToString(cfgAmountAssetId))
538 +             let prBalanceOld = getAccBalance(assetIdToString(cfgPriceAssetId))
555 539              let outBalance = if (outInAmountAsset)
556 540                  then amBalanceOld
557 541                  else prBalanceOld
558 542              let outBalanceBigInt = toBigInt(outBalance)
559 -             let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(lpAssetId), (("asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity)
543 +             let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
560 544              let redeemedBigInt = toBigInt(paymentAmount)
561 545              let amountRaw = max([0, toInt(((balanceBigInt * (scale18 - pow((scale18 - ((redeemedBigInt * scale18) / supplyBigInt)), 18, big2, 0, 18, DOWN))) / scale18))])
562 -             let $t02642526475 = takeFee(amountRaw)
563 -             let totalAmount = $t02642526475._1
564 -             let feeAmount = $t02642526475._2
565 -             let $t02647926705 = if (outInAmountAsset)
546 +             let $t02613526185 = takeFee(amountRaw)
547 +             let totalAmount = $t02613526185._1
548 +             let feeAmount = $t02613526185._2
549 +             let $t02618926415 = if (outInAmountAsset)
566 550                  then $Tuple4(totalAmount, 0, (amBalanceOld - amountRaw), prBalanceOld)
567 551                  else $Tuple4(0, totalAmount, amBalanceOld, (prBalanceOld - amountRaw))
568 -             let outAmAmount = $t02647926705._1
569 -             let outPrAmount = $t02647926705._2
570 -             let amBalanceNew = $t02647926705._3
571 -             let prBalanceNew = $t02647926705._4
572 -             let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, prDecimals), toX18(amBalanceNew, amDecimals))
552 +             let outAmAmount = $t02618926415._1
553 +             let outPrAmount = $t02618926415._2
554 +             let amBalanceNew = $t02618926415._3
555 +             let prBalanceNew = $t02618926415._4
556 +             let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, cfgPriceAssetDecimals), toX18(amBalanceNew, cfgAmountAssetDecimals))
573 557              let priceNew = fromX18(priceNewX18, scale8)
574 558              let commonState = if (isEval)
575 559                  then nil
576 560                  else [StringEntry(gau(toString(value(userAddress)), toBase58String(value(txId))), dataGetActionInfo(outAmAmount, outPrAmount, paymentAmount, priceNew, height, lastBlock.timestamp)), IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew)]
577 -             let priceOldX18 = calcPriceBigInt(toX18(prBalanceOld, prDecimals), toX18(amBalanceOld, amDecimals))
561 +             let priceOldX18 = calcPriceBigInt(toX18(prBalanceOld, cfgPriceAssetDecimals), toX18(amBalanceOld, cfgAmountAssetDecimals))
578 562              let priceOld = fromX18(priceOldX18, scale8)
579 563              let priceImpact = abs((((priceNew - priceOld) * scale8) / priceOld))
580 564              $Tuple4(totalAmount, commonState, feeAmount, priceImpact)
581 565              }
582 566          else throw("Strict value is not equal to itself.")
583 567      }
584 568  
585 569  
586 570  func managerPublicKeyOrUnit () = match getString(mpk()) {
587 571      case s: String => 
588 572          fromBase58String(s)
589 573      case _: Unit => 
590 574          unit
591 575      case _ => 
592 576          throw("Match error")
593 577  }
594 578  
595 579  
596 580  func pendingManagerPublicKeyOrUnit () = match getString(pmpk()) {
597 581      case s: String => 
598 582          fromBase58String(s)
599 583      case _: Unit => 
600 584          unit
601 585      case _ => 
602 586          throw("Match error")
603 587  }
604 588  
605 589  
606 590  func mustManager (i) = {
607 591      let pd = throw("Permission denied")
608 592      match managerPublicKeyOrUnit() {
609 593          case pk: ByteVector => 
610 594              if ((i.callerPublicKey == pk))
611 595                  then true
612 596                  else pd
613 597          case _: Unit => 
614 598              if ((i.caller == this))
615 599                  then true
616 600                  else pd
617 601          case _ => 
618 602              throw("Match error")
619 603      }
620 604      }
621 605  
622 606  
623 607  @Callable(i)
624 608  func setManager (pendingManagerPublicKey) = {
625 609      let checkCaller = mustManager(i)
626 610      if ((checkCaller == checkCaller))
627 611          then {
628 612              let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
629 613              if ((checkManagerPublicKey == checkManagerPublicKey))
630 614                  then [StringEntry(pmpk(), pendingManagerPublicKey)]
631 615                  else throw("Strict value is not equal to itself.")
632 616              }
633 617          else throw("Strict value is not equal to itself.")
634 618      }
635 619  
636 620  
637 621  
638 622  @Callable(i)
639 623  func confirmManager () = {
640 624      let pm = pendingManagerPublicKeyOrUnit()
641 625      let hasPM = if (isDefined(pm))
642 626          then true
643 627          else throw("No pending manager")
644 628      if ((hasPM == hasPM))
645 629          then {
646 630              let checkPM = if ((i.callerPublicKey == value(pm)))
647 631                  then true
648 632                  else throw("You are not pending manager")
649 633              if ((checkPM == checkPM))
650 634                  then [StringEntry(mpk(), toBase58String(value(pm))), DeleteEntry(pmpk())]
651 635                  else throw("Strict value is not equal to itself.")
652 636              }
653 637          else throw("Strict value is not equal to itself.")
654 638      }
655 639  
656 640  
657 641  
658 642  @Callable(i)
659 643  func put (slippageTolerance,shouldAutoStake) = if ((0 > slippageTolerance))
660 644      then throw("Invalid slippageTolerance passed")
661 645      else {
662 646          let estPut = commonPut(i, slippageTolerance, true)
663 647          let emitLpAmt = estPut._2
664 648          let lpAssetId = estPut._7
665 649          let state = estPut._9
666 650          let amDiff = estPut._10
667 651          let prDiff = estPut._11
668 652          let amId = estPut._12
669 653          let prId = estPut._13
670 654          let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
671 655          if ((emitInv == emitInv))
672 656              then {
673 657                  let emitInvLegacy =                 match emitInv {
674 658                      case legacyFactoryContract: Address => 
675 659                          invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
676 660                      case _ => 
677 661                          unit
678 662                  }
679 663                  if ((emitInvLegacy == emitInvLegacy))
680 664                      then {
681 665                          let slippageAInv = if ((amDiff > 0))
682 666                              then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
683 667                              else nil
684 668                          if ((slippageAInv == slippageAInv))
685 669                              then {
686 670                                  let slippagePInv = if ((prDiff > 0))
687 671                                      then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
688 672                                      else nil
689 673                                  if ((slippagePInv == slippagePInv))
690 674                                      then {
691 675                                          let lpTransfer = if (shouldAutoStake)
692 676                                              then {
693 677                                                  let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
694 678                                                  if ((slpStakeInv == slpStakeInv))
695 679                                                      then nil
696 680                                                      else throw("Strict value is not equal to itself.")
697 681                                                  }
698 682                                              else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
699 683                                          (state ++ lpTransfer)
700 684                                          }
701 685                                      else throw("Strict value is not equal to itself.")
702 686                                  }
703 687                              else throw("Strict value is not equal to itself.")
704 688                          }
705 689                      else throw("Strict value is not equal to itself.")
706 690                  }
707 691              else throw("Strict value is not equal to itself.")
708 692          }
709 693  
710 694  
711 695  
712 696  @Callable(i)
713 697  func putForFree (maxSlippage) = if ((0 > maxSlippage))
714 698      then throw("Invalid value passed")
715 699      else {
716 700          let estPut = commonPut(i, maxSlippage, false)
717 701          estPut._9
718 702          }
719 703  
720 704  
721 705  
722 706  @Callable(i)
723 707  func putOneTkn (minOutAmount,autoStake) = {
724 -     let isPutDisabled = if (if (isGlobalShutdown())
708 +     let isPoolOneTokenOperationsDisabled = {
709 +         let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
710 +         if ($isInstanceOf(@, "Boolean"))
711 +             then @
712 +             else throw(($getType(@) + " couldn't be cast to Boolean"))
713 +         }
714 +     let isPutDisabled = if (if (if (isGlobalShutdown())
725 715          then true
726 716          else (cfgPoolStatus == PoolPutDisabled))
727 717          then true
728 -         else (cfgPoolStatus == PoolShutdown)
718 +         else (cfgPoolStatus == PoolShutdown))
719 +         then true
720 +         else isPoolOneTokenOperationsDisabled
729 721      let checks = [if (!(isPutDisabled))
730 722          then true
731 723          else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
732 724          then true
733 725          else throwErr("exactly 1 payment are expected")]
734 726      if ((checks == checks))
735 727          then {
736 728              let payment = i.payments[0]
737 729              let paymentAssetId = payment.assetId
738 730              let paymentAmountRaw = payment.amount
739 731              let userAddress = i.caller
740 732              let txId = i.transactionId
741 -             let $t03105731184 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
742 -             let emitAmountEstimated = $t03105731184._1
743 -             let commonState = $t03105731184._2
744 -             let feeAmount = $t03105731184._3
745 -             let bonus = $t03105731184._4
733 +             let $t03099731124 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
734 +             let emitAmountEstimated = $t03099731124._1
735 +             let commonState = $t03099731124._2
736 +             let feeAmount = $t03099731124._3
737 +             let bonus = $t03099731124._4
746 738              let emitAmount = if (if ((minOutAmount > 0))
747 739                  then (minOutAmount > emitAmountEstimated)
748 740                  else false)
749 741                  then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
750 742                  else emitAmountEstimated
751 743              let emitInv = emit(emitAmount)
752 744              if ((emitInv == emitInv))
753 745                  then {
754 746                      let lpTransfer = if (autoStake)
755 747                          then {
756 748                              let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(cfgLpAssetId, emitAmount)])
757 749                              if ((stakeInv == stakeInv))
758 750                                  then nil
759 751                                  else throw("Strict value is not equal to itself.")
760 752                              }
761 753                          else [ScriptTransfer(i.caller, emitAmount, cfgLpAssetId)]
762 754                      let sendFee = if ((feeAmount > 0))
763 755                          then [ScriptTransfer(feeCollectorAddress, feeAmount, paymentAssetId)]
764 756                          else nil
765 757                      $Tuple2(((commonState ++ lpTransfer) ++ sendFee), emitAmount)
766 758                      }
767 759                  else throw("Strict value is not equal to itself.")
768 760              }
769 761          else throw("Strict value is not equal to itself.")
770 762      }
771 763  
772 764  
773 765  
774 766  @Callable(i)
775 767  func putOneTknREADONLY (paymentAssetId,paymentAmountRaw) = {
776 -     let $t03191332048 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
777 -     let emitAmountEstimated = $t03191332048._1
778 -     let commonState = $t03191332048._2
779 -     let feeAmount = $t03191332048._3
780 -     let bonus = $t03191332048._4
768 +     let $t03185331988 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
769 +     let emitAmountEstimated = $t03185331988._1
770 +     let commonState = $t03185331988._2
771 +     let feeAmount = $t03185331988._3
772 +     let bonus = $t03185331988._4
781 773      $Tuple2(nil, $Tuple3(emitAmountEstimated, feeAmount, bonus))
782 774      }
783 775  
784 776  
785 777  
786 778  @Callable(i)
787 779  func getOneTkn (outAssetIdStr,minOutAmount) = {
788 -     let isGetDisabled = if (isGlobalShutdown())
780 +     let isPoolOneTokenOperationsDisabled = {
781 +         let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
782 +         if ($isInstanceOf(@, "Boolean"))
783 +             then @
784 +             else throw(($getType(@) + " couldn't be cast to Boolean"))
785 +         }
786 +     let isGetDisabled = if (if (isGlobalShutdown())
789 787          then true
790 -         else (cfgPoolStatus == PoolShutdown)
788 +         else (cfgPoolStatus == PoolShutdown))
789 +         then true
790 +         else isPoolOneTokenOperationsDisabled
791 791      let checks = [if (!(isGetDisabled))
792 792          then true
793 793          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
794 794          then true
795 795          else throwErr("exactly 1 payment are expected")]
796 796      if ((checks == checks))
797 797          then {
798 798              let outAssetId = parseAssetId(outAssetIdStr)
799 799              let payment = i.payments[0]
800 800              let paymentAssetId = payment.assetId
801 801              let paymentAmount = payment.amount
802 802              let userAddress = i.caller
803 803              let txId = i.transactionId
804 -             let $t03263632768 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
805 -             let amountEstimated = $t03263632768._1
806 -             let commonState = $t03263632768._2
807 -             let feeAmount = $t03263632768._3
808 -             let bonus = $t03263632768._4
804 +             let $t03276032892 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
805 +             let amountEstimated = $t03276032892._1
806 +             let commonState = $t03276032892._2
807 +             let feeAmount = $t03276032892._3
808 +             let bonus = $t03276032892._4
809 809              let amount = if (if ((minOutAmount > 0))
810 810                  then (minOutAmount > amountEstimated)
811 811                  else false)
812 812                  then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
813 813                  else amountEstimated
814 814              let burnInv = invoke(factoryContract, "burn", [paymentAmount], [AttachedPayment(paymentAssetId, paymentAmount)])
815 815              if ((burnInv == burnInv))
816 816                  then {
817 817                      let assetTransfer = [ScriptTransfer(userAddress, amount, outAssetId)]
818 818                      let sendFee = if ((feeAmount > 0))
819 819                          then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
820 820                          else nil
821 821                      $Tuple2(((commonState ++ assetTransfer) ++ sendFee), amount)
822 822                      }
823 823                  else throw("Strict value is not equal to itself.")
824 824              }
825 825          else throw("Strict value is not equal to itself.")
826 826      }
827 827  
828 828  
829 829  
830 830  @Callable(i)
831 831  func getOneTknREADONLY (outAssetId,paymentAmount) = {
832 -     let $t03340333541 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
833 -     let amountEstimated = $t03340333541._1
834 -     let commonState = $t03340333541._2
835 -     let feeAmount = $t03340333541._3
836 -     let bonus = $t03340333541._4
832 +     let $t03352733665 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
833 +     let amountEstimated = $t03352733665._1
834 +     let commonState = $t03352733665._2
835 +     let feeAmount = $t03352733665._3
836 +     let bonus = $t03352733665._4
837 837      $Tuple2(nil, $Tuple3(amountEstimated, feeAmount, bonus))
838 838      }
839 839  
840 840  
841 841  
842 842  @Callable(i)
843 843  func unstakeAndGetOneTkn (unstakeAmount,outAssetIdStr,minOutAmount) = {
844 -     let isGetDisabled = if (isGlobalShutdown())
844 +     let isPoolOneTokenOperationsDisabled = {
845 +         let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
846 +         if ($isInstanceOf(@, "Boolean"))
847 +             then @
848 +             else throw(($getType(@) + " couldn't be cast to Boolean"))
849 +         }
850 +     let isGetDisabled = if (if (isGlobalShutdown())
845 851          then true
846 -         else (cfgPoolStatus == PoolShutdown)
852 +         else (cfgPoolStatus == PoolShutdown))
853 +         then true
854 +         else isPoolOneTokenOperationsDisabled
847 855      let checks = [if (!(isGetDisabled))
848 856          then true
849 857          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 0))
850 858          then true
851 859          else throwErr("no payments are expected")]
852 860      if ((checks == checks))
853 861          then {
854 862              let outAssetId = parseAssetId(outAssetIdStr)
855 863              let userAddress = i.caller
856 864              let txId = i.transactionId
857 865              let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
858 866              if ((unstakeInv == unstakeInv))
859 867                  then {
860 -                     let $t03414934279 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
861 -                     let amountEstimated = $t03414934279._1
862 -                     let commonState = $t03414934279._2
863 -                     let feeAmount = $t03414934279._3
864 -                     let bonus = $t03414934279._4
868 +                     let $t03445734587 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
869 +                     let amountEstimated = $t03445734587._1
870 +                     let commonState = $t03445734587._2
871 +                     let feeAmount = $t03445734587._3
872 +                     let bonus = $t03445734587._4
865 873                      let amount = if (if ((minOutAmount > 0))
866 874                          then (minOutAmount > amountEstimated)
867 875                          else false)
868 876                          then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
869 877                          else amountEstimated
870 878                      let burnInv = invoke(factoryContract, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
871 879                      if ((burnInv == burnInv))
872 880                          then {
873 881                              let assetTransfer = [ScriptTransfer(i.caller, amount, outAssetId)]
874 882                              let sendFee = if ((feeAmount > 0))
875 883                                  then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetId)]
876 884                                  else nil
877 885                              $Tuple2(((commonState ++ assetTransfer) ++ sendFee), amount)
878 886                              }
879 887                          else throw("Strict value is not equal to itself.")
880 888                      }
881 889                  else throw("Strict value is not equal to itself.")
882 890              }
883 891          else throw("Strict value is not equal to itself.")
884 892      }
885 893  
886 894  
887 895  
888 896  @Callable(i)
889 897  func get () = {
890 898      let res = commonGet(i)
891 899      let outAmtAmt = res._1
892 900      let outPrAmt = res._2
893 901      let pmtAmt = res._3
894 902      let pmtAssetId = res._4
895 903      let state = res._5
896 904      let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
897 905      if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
898 906          then state
899 907          else throw("Strict value is not equal to itself.")
900 908      }
901 909  
902 910  
903 911  
904 912  @Callable(i)
905 913  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
906 914      let res = commonGet(i)
907 915      let outAmAmt = res._1
908 916      let outPrAmt = res._2
909 917      let pmtAmt = res._3
910 918      let pmtAssetId = res._4
911 919      let state = res._5
912 920      if ((noLessThenAmtAsset > outAmAmt))
913 921          then throw(((("noLessThenAmtAsset failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
914 922          else if ((noLessThenPriceAsset > outPrAmt))
915 923              then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
916 924              else {
917 925                  let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
918 926                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
919 927                      then state
920 928                      else throw("Strict value is not equal to itself.")
921 929                  }
922 930      }
923 931  
924 932  
925 933  
926 934  @Callable(i)
927 935  func unstakeAndGet (amount) = {
928 936      let checkPayments = if ((size(i.payments) != 0))
929 937          then throw("No payments are expected")
930 938          else true
931 939      if ((checkPayments == checkPayments))
932 940          then {
933 941              let cfg = getPoolConfig()
934 942              let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
935 943              let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
936 944              if ((unstakeInv == unstakeInv))
937 945                  then {
938 946                      let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
939 947                      let poolStatus = parseIntValue(res._9)
940 948                      let state = res._10
941 949                      let checkPoolStatus = if (if (isGlobalShutdown())
942 950                          then true
943 951                          else (poolStatus == PoolShutdown))
944 952                          then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
945 953                          else true
946 954                      if ((checkPoolStatus == checkPoolStatus))
947 955                          then {
948 956                              let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
949 957                              if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
950 958                                  then state
951 959                                  else throw("Strict value is not equal to itself.")
952 960                              }
953 961                          else throw("Strict value is not equal to itself.")
954 962                      }
955 963                  else throw("Strict value is not equal to itself.")
956 964              }
957 965          else throw("Strict value is not equal to itself.")
958 966      }
959 967  
960 968  
961 969  
962 970  @Callable(i)
963 971  func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
964 972      then throw("permissions denied")
965 973      else $Tuple2([StringEntry(aa(), amtAssetStr), StringEntry(pa(), priceAssetStr)], "success")
966 974  
967 975  
968 976  
969 977  @Callable(i)
970 978  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
971 979  
972 980  
973 981  
974 982  @Callable(i)
975 983  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
976 984  
977 985  
978 986  
979 987  @Callable(i)
980 988  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
981 989      let prices = calcPrices(amAmt, prAmt, lpAmt)
982 990      $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
983 991      }
984 992  
985 993  
986 994  
987 995  @Callable(i)
988 996  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
989 997  
990 998  
991 999  
992 1000  @Callable(i)
993 1001  func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
994 1002  
995 1003  
996 1004  
997 1005  @Callable(i)
998 1006  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
999 1007  
1000 1008  
1001 1009  
1002 1010  @Callable(i)
1003 1011  func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp))
1004 1012  
1005 1013  
1006 1014  
1007 1015  @Callable(i)
1008 1016  func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
1009 1017      let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
1010 1018      $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
1011 1019      }
1012 1020  
1013 1021  
1014 1022  
1015 1023  @Callable(i)
1016 1024  func statsREADONLY () = {
1017 1025      let cfg = getPoolConfig()
1018 1026      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
1019 1027      let amtAssetId = cfg[idxAmtAssetId]
1020 1028      let priceAssetId = cfg[idxPriceAssetId]
1021 1029      let iAmtAssetId = cfg[idxIAmtAssetId]
1022 1030      let iPriceAssetId = cfg[idxIPriceAssetId]
1023 1031      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
1024 1032      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
1025 1033      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
1026 1034      let accAmtAssetBalance = getAccBalance(amtAssetId)
1027 1035      let accPriceAssetBalance = getAccBalance(priceAssetId)
1028 1036      let pricesList = if ((poolLPBalance == 0))
1029 1037          then [zeroBigInt, zeroBigInt, zeroBigInt]
1030 1038          else calcPrices(accAmtAssetBalance, accPriceAssetBalance, poolLPBalance)
1031 1039      let curPrice = 0
1032 1040      let lpAmtAssetShare = fromX18(pricesList[1], scale8)
1033 1041      let lpPriceAssetShare = fromX18(pricesList[2], scale8)
1034 1042      let poolWeight = value(getInteger(factoryContract, keyPoolWeight(toString(this))))
1035 1043      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
1036 1044      }
1037 1045  
1038 1046  
1039 1047  
1040 1048  @Callable(i)
1041 1049  func evaluatePutByAmountAssetREADONLY (inAmAssetAmt) = {
1042 1050      let cfg = getPoolConfig()
1043 1051      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
1044 1052      let amAssetIdStr = cfg[idxAmtAssetId]
1045 1053      let amAssetId = fromBase58String(amAssetIdStr)
1046 1054      let prAssetIdStr = cfg[idxPriceAssetId]
1047 1055      let prAssetId = fromBase58String(prAssetIdStr)
1048 1056      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
1049 1057      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
1050 1058      let poolStatus = cfg[idxPoolStatus]
1051 1059      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
1052 1060      let accAmtAssetBalance = getAccBalance(amAssetIdStr)
1053 1061      let accPriceAssetBalance = getAccBalance(prAssetIdStr)
1054 1062      let amtAssetAmtX18 = toX18(accAmtAssetBalance, amtAssetDcm)
1055 1063      let priceAssetAmtX18 = toX18(accPriceAssetBalance, priceAssetDcm)
1056 1064      let curPriceX18 = if ((poolLPBalance == 0))
1057 1065          then zeroBigInt
1058 1066          else calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
1059 1067      let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
1060 1068      let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
1061 1069      let inPrAssetAmt = fromX18(inPrAssetAmtX18, priceAssetDcm)
1062 1070      let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
1063 1071      let calcLpAmt = estPut._1
1064 1072      let curPriceCalc = estPut._3
1065 1073      let amBalance = estPut._4
1066 1074      let prBalance = estPut._5
1067 1075      let lpEmission = estPut._6
1068 1076      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
1069 1077      }
1070 1078  
1071 1079  
1072 1080  
1073 1081  @Callable(i)
1074 1082  func evaluatePutByPriceAssetREADONLY (inPrAssetAmt) = {
1075 1083      let cfg = getPoolConfig()
1076 1084      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
1077 1085      let amAssetIdStr = cfg[idxAmtAssetId]
1078 1086      let amAssetId = fromBase58String(amAssetIdStr)
1079 1087      let prAssetIdStr = cfg[idxPriceAssetId]
1080 1088      let prAssetId = fromBase58String(prAssetIdStr)
1081 1089      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
1082 1090      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
1083 1091      let poolStatus = cfg[idxPoolStatus]
1084 1092      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
1085 1093      let amBalanceRaw = getAccBalance(amAssetIdStr)
1086 1094      let prBalanceRaw = getAccBalance(prAssetIdStr)
1087 1095      let amBalanceRawX18 = toX18(amBalanceRaw, amtAssetDcm)
1088 1096      let prBalanceRawX18 = toX18(prBalanceRaw, priceAssetDcm)
1089 1097      let curPriceX18 = if ((poolLPBalance == 0))
1090 1098          then zeroBigInt
1091 1099          else calcPriceBigInt(prBalanceRawX18, amBalanceRawX18)
1092 1100      let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
1093 1101      let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
1094 1102      let inAmAssetAmt = fromX18(inAmAssetAmtX18, amtAssetDcm)
1095 1103      let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
1096 1104      let calcLpAmt = estPut._1
1097 1105      let curPriceCalc = estPut._3
1098 1106      let amBalance = estPut._4
1099 1107      let prBalance = estPut._5
1100 1108      let lpEmission = estPut._6
1101 1109      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
1102 1110      }
1103 1111  
1104 1112  
1105 1113  
1106 1114  @Callable(i)
1107 1115  func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
1108 1116      let res = estimateGetOperation("", paymentLpAssetId, paymentLpAmt, this)
1109 1117      let outAmAmt = res._1
1110 1118      let outPrAmt = res._2
1111 1119      let amBalance = res._5
1112 1120      let prBalance = res._6
1113 1121      let lpEmission = res._7
1114 1122      let curPrice = res._8
1115 1123      let poolStatus = parseIntValue(res._9)
1116 1124      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), toString(curPrice), toString(poolStatus)], SEP))
1117 1125      }
1118 1126  
1119 1127  
1120 1128  @Verifier(tx)
1121 1129  func verify () = {
1122 1130      let targetPublicKey =     match managerPublicKeyOrUnit() {
1123 1131          case pk: ByteVector => 
1124 1132              pk
1125 1133          case _: Unit => 
1126 1134              tx.senderPublicKey
1127 1135          case _ => 
1128 1136              throw("Match error")
1129 1137      }
1130 1138      match tx {
1131 1139          case order: Order => 
1132 1140              let matcherPub = getMatcherPubOrFail()
1133 1141              let orderValid = validateMatcherOrderAllowed(order)
1134 1142              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1135 1143              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1136 1144              if (if (if (orderValid)
1137 1145                  then senderValid
1138 1146                  else false)
1139 1147                  then matcherValid
1140 1148                  else false)
1141 1149                  then true
1142 1150                  else throwOrderError(orderValid, senderValid, matcherValid)
1143 1151          case s: SetScriptTransaction => 
1144 1152              let newHash = blake2b256(value(s.script))
1145 1153              let allowedHash = fromBase64String(value(getString(factoryContract, keyAllowedLpScriptHash())))
1146 1154              let currentHash = scriptHash(this)
1147 1155              if (if ((allowedHash == newHash))
1148 1156                  then (currentHash != newHash)
1149 1157                  else false)
1150 1158                  then true
1151 1159                  else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1152 1160          case _ => 
1153 1161              sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1154 1162      }
1155 1163      }
1156 1164

Old	New		Differences
467	467
468	468		func calcPutOneToken (paymentAmountRaw,paymentAssetId,userAddress,txId) = {
469	469		let isEval = (txId == unit)
470		-	let $t02223222410 = parsePoolConfig(getPoolConfig())
471		-	let poolAddress = $t02223222410._1
472		-	let poolStatus = $t02223222410._2
473		-	let lpAssetId = $t02223222410._3
474		-	let amountAssetId = $t02223222410._4
475		-	let priceAssetId = $t02223222410._5
476		-	let amountAssetDecimals = $t02223222410._6
477		-	let priceAssetDecimals = $t02223222410._7
478		-	let amountBalanceRaw = getAccBalance(assetIdToString(amountAssetId))
479		-	let priceBalanceRaw = getAccBalance(assetIdToString(priceAssetId))
480		-	let paymentInAmountAsset = if ((paymentAssetId == amountAssetId))
	470	+	let amountBalanceRaw = getAccBalance(assetIdToString(cfgAmountAssetId))
	471	+	let priceBalanceRaw = getAccBalance(assetIdToString(cfgPriceAssetId))
	472	+	let paymentInAmountAsset = if ((paymentAssetId == cfgAmountAssetId))
481	473		then true
482		-	else if ((paymentAssetId == ~~priceAssetId~~))
	474	+	else if ((paymentAssetId == cfgPriceAssetId))
483	475		then false
484	476		else throwErr("invalid asset")
485		-	let $~~t02274023033~~ = if (isEval)
	477	+	let $t02257022863 = if (isEval)
486	478		then $Tuple2(amountBalanceRaw, priceBalanceRaw)
487	479		else if (paymentInAmountAsset)
488	480		then $Tuple2((amountBalanceRaw - paymentAmountRaw), priceBalanceRaw)
489	481		else $Tuple2(amountBalanceRaw, (priceBalanceRaw - paymentAmountRaw))
490		-	let amountBalanceOld = $~~t02274023033~~._1
491		-	let priceBalanceOld = $~~t02274023033~~._2
492		-	let $~~t02303723186~~ = if (paymentInAmountAsset)
	482	+	let amountBalanceOld = $t02257022863._1
	483	+	let priceBalanceOld = $t02257022863._2
	484	+	let $t02286723016 = if (paymentInAmountAsset)
493	485		then $Tuple2(paymentAmountRaw, 0)
494	486		else $Tuple2(0, paymentAmountRaw)
495		-	let amountAssetAmountRaw = $~~t02303723186~~._1
496		-	let priceAssetAmountRaw = $~~t02303723186~~._2
	487	+	let amountAssetAmountRaw = $t02286723016._1
	488	+	let priceAssetAmountRaw = $t02286723016._2
497	489		let amountAssetAmount = takeFee(amountAssetAmountRaw)._1
498	490		let priceAssetAmount = takeFee(priceAssetAmountRaw)._1
499		-	let $~~t02330823367~~ = takeFee(paymentAmountRaw)
500		-	let paymentAmount = $~~t02330823367~~._1
501		-	let feeAmount = $~~t02330823367~~._2
	491	+	let $t02313823197 = takeFee(paymentAmountRaw)
	492	+	let paymentAmount = $t02313823197._1
	493	+	let feeAmount = $t02313823197._2
502	494		let amountBalanceNew = (amountBalanceOld + amountAssetAmount)
503	495		let priceBalanceNew = (priceBalanceOld + priceAssetAmount)
504		-	let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, ~~priceAssetDecimals~~), toX18(amountBalanceNew, ~~amountAssetDecimals~~))
	496	+	let priceNewX18 = calcPriceBigInt(toX18(priceBalanceNew, cfgPriceAssetDecimals), toX18(amountBalanceNew, cfgAmountAssetDecimals))
505	497		let priceNew = fromX18(priceNewX18, scale8)
506	498		let paymentBalance = if (paymentInAmountAsset)
507	499		then amountBalanceOld
508	500		else priceBalanceOld
509	501		let paymentBalanceBigInt = toBigInt(paymentBalance)
510		-	let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(~~lpAssetId~~), (("asset " + toBase58String(~~lpAssetId~~)) + " doesn't exist")).quantity)
	502	+	let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
511	503		let chechSupply = if ((supplyBigInt > big0))
512	504		then true
513	505		else throwErr("initial deposit requires all coins")

518	510		let commonState = if (isEval)
519	511		then nil
520	512		else [IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew), StringEntry(pau(toString(value(userAddress)), toBase58String(value(txId))), dataPutActionInfo(amountAssetAmountRaw, priceAssetAmountRaw, issueAmount, priceNew, 0, 0, height, lastBlock.timestamp, 0, 0))]
521		-	let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, ~~priceAssetDecimals~~), toX18(amountBalanceOld, ~~amountAssetDecimals~~))
	513	+	let priceOldX18 = calcPriceBigInt(toX18(priceBalanceOld, cfgPriceAssetDecimals), toX18(amountBalanceOld, cfgAmountAssetDecimals))
522	514		let priceOld = fromX18(priceOldX18, scale8)
523	515		let priceImpact = abs((((priceNew - priceOld) * scale8) / priceOld))
524	516		$Tuple4(issueAmount, commonState, feeAmount, priceImpact)

529	521
530	522		func calcGetOneToken (outAssetId,paymentAmount,paymentAssetId,userAddress,txId) = {
531	523		let isEval = (txId == unit)
532		-	let $t02518925350 = parsePoolConfig(getPoolConfig())
533		-	let poolAddress = $t02518925350._1
534		-	let poolStatus = $t02518925350._2
535		-	let lpAssetId = $t02518925350._3
536		-	let amountAssetId = $t02518925350._4
537		-	let priceAssetId = $t02518925350._5
538		-	let amDecimals = $t02518925350._6
539		-	let prDecimals = $t02518925350._7
540		-	let checks = [if ((paymentAssetId == lpAssetId))
	524	+	let checks = [if ((paymentAssetId == cfgLpAssetId))
541	525		then true
542	526		else throwErr("invalid lp asset")]
543	527		if ((checks == checks))
544	528		then {
545		-	let outInAmountAsset = if ((outAssetId == ~~amountAssetId~~))
	529	+	let outInAmountAsset = if ((outAssetId == cfgAmountAssetId))
546	530		then true
547		-	else if ((outAssetId == ~~priceAssetId~~))
	531	+	else if ((outAssetId == cfgPriceAssetId))
548	532		then false
549	533		else throwErr("invalid asset")
550	534		let balanceBigInt = if (outInAmountAsset)
551		-	then toBigInt(getAccBalance(assetIdToString(~~amountAssetId~~)))
552		-	else toBigInt(getAccBalance(assetIdToString(~~priceAssetId~~)))
553		-	let amBalanceOld = getAccBalance(assetIdToString(~~amountAssetId~~))
554		-	let prBalanceOld = getAccBalance(assetIdToString(~~priceAssetId~~))
	535	+	then toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId)))
	536	+	else toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId)))
	537	+	let amBalanceOld = getAccBalance(assetIdToString(cfgAmountAssetId))
	538	+	let prBalanceOld = getAccBalance(assetIdToString(cfgPriceAssetId))
555	539		let outBalance = if (outInAmountAsset)
556	540		then amBalanceOld
557	541		else prBalanceOld
558	542		let outBalanceBigInt = toBigInt(outBalance)
559		-	let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(~~lpAssetId~~), (("asset " + toBase58String(~~lpAssetId~~)) + " doesn't exist")).quantity)
	543	+	let supplyBigInt = toBigInt(valueOrErrorMessage(assetInfo(cfgLpAssetId), (("asset " + toBase58String(cfgLpAssetId)) + " doesn't exist")).quantity)
560	544		let redeemedBigInt = toBigInt(paymentAmount)
561	545		let amountRaw = max([0, toInt(((balanceBigInt * (scale18 - pow((scale18 - ((redeemedBigInt * scale18) / supplyBigInt)), 18, big2, 0, 18, DOWN))) / scale18))])
562		-	let $~~t02642526475~~ = takeFee(amountRaw)
563		-	let totalAmount = $~~t02642526475~~._1
564		-	let feeAmount = $~~t02642526475~~._2
565		-	let $~~t02647926705~~ = if (outInAmountAsset)
	546	+	let $t02613526185 = takeFee(amountRaw)
	547	+	let totalAmount = $t02613526185._1
	548	+	let feeAmount = $t02613526185._2
	549	+	let $t02618926415 = if (outInAmountAsset)
566	550		then $Tuple4(totalAmount, 0, (amBalanceOld - amountRaw), prBalanceOld)
567	551		else $Tuple4(0, totalAmount, amBalanceOld, (prBalanceOld - amountRaw))
568		-	let outAmAmount = $~~t02647926705~~._1
569		-	let outPrAmount = $~~t02647926705~~._2
570		-	let amBalanceNew = $~~t02647926705~~._3
571		-	let prBalanceNew = $~~t02647926705~~._4
572		-	let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, ~~prDecimals~~), toX18(amBalanceNew, ~~amDecimals~~))
	552	+	let outAmAmount = $t02618926415._1
	553	+	let outPrAmount = $t02618926415._2
	554	+	let amBalanceNew = $t02618926415._3
	555	+	let prBalanceNew = $t02618926415._4
	556	+	let priceNewX18 = calcPriceBigInt(toX18(prBalanceNew, cfgPriceAssetDecimals), toX18(amBalanceNew, cfgAmountAssetDecimals))
573	557		let priceNew = fromX18(priceNewX18, scale8)
574	558		let commonState = if (isEval)
575	559		then nil
576	560		else [StringEntry(gau(toString(value(userAddress)), toBase58String(value(txId))), dataGetActionInfo(outAmAmount, outPrAmount, paymentAmount, priceNew, height, lastBlock.timestamp)), IntegerEntry(pl(), priceNew), IntegerEntry(ph(height, lastBlock.timestamp), priceNew)]
577		-	let priceOldX18 = calcPriceBigInt(toX18(prBalanceOld, ~~prDecimals~~), toX18(amBalanceOld, ~~amDecimals~~))
	561	+	let priceOldX18 = calcPriceBigInt(toX18(prBalanceOld, cfgPriceAssetDecimals), toX18(amBalanceOld, cfgAmountAssetDecimals))
578	562		let priceOld = fromX18(priceOldX18, scale8)
579	563		let priceImpact = abs((((priceNew - priceOld) * scale8) / priceOld))
580	564		$Tuple4(totalAmount, commonState, feeAmount, priceImpact)

721	705
722	706		@Callable(i)
723	707		func putOneTkn (minOutAmount,autoStake) = {
724		-	let isPutDisabled = if (if (isGlobalShutdown())
	708	+	let isPoolOneTokenOperationsDisabled = {
	709	+	let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
	710	+	if ($isInstanceOf(@, "Boolean"))
	711	+	then @
	712	+	else throw(($getType(@) + " couldn't be cast to Boolean"))
	713	+	}
	714	+	let isPutDisabled = if (if (if (isGlobalShutdown())
725	715		then true
726	716		else (cfgPoolStatus == PoolPutDisabled))
727	717		then true
728		-	else (cfgPoolStatus == PoolShutdown)
	718	+	else (cfgPoolStatus == PoolShutdown))
	719	+	then true
	720	+	else isPoolOneTokenOperationsDisabled
729	721		let checks = [if (!(isPutDisabled))
730	722		then true
731	723		else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))

738	730		let paymentAmountRaw = payment.amount
739	731		let userAddress = i.caller
740	732		let txId = i.transactionId
741		-	let $~~t03105731184~~ = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
742		-	let emitAmountEstimated = $~~t03105731184~~._1
743		-	let commonState = $~~t03105731184~~._2
744		-	let feeAmount = $~~t03105731184~~._3
745		-	let bonus = $~~t03105731184~~._4
	733	+	let $t03099731124 = calcPutOneToken(paymentAmountRaw, paymentAssetId, userAddress, txId)
	734	+	let emitAmountEstimated = $t03099731124._1
	735	+	let commonState = $t03099731124._2
	736	+	let feeAmount = $t03099731124._3
	737	+	let bonus = $t03099731124._4
746	738		let emitAmount = if (if ((minOutAmount > 0))
747	739		then (minOutAmount > emitAmountEstimated)
748	740		else false)

773	765
774	766		@Callable(i)
775	767		func putOneTknREADONLY (paymentAssetId,paymentAmountRaw) = {
776		-	let $~~t03191332048~~ = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
777		-	let emitAmountEstimated = $~~t03191332048~~._1
778		-	let commonState = $~~t03191332048~~._2
779		-	let feeAmount = $~~t03191332048~~._3
780		-	let bonus = $~~t03191332048~~._4
	768	+	let $t03185331988 = calcPutOneToken(paymentAmountRaw, parseAssetId(paymentAssetId), unit, unit)
	769	+	let emitAmountEstimated = $t03185331988._1
	770	+	let commonState = $t03185331988._2
	771	+	let feeAmount = $t03185331988._3
	772	+	let bonus = $t03185331988._4
781	773		$Tuple2(nil, $Tuple3(emitAmountEstimated, feeAmount, bonus))
782	774		}
783	775

785	777
786	778		@Callable(i)
787	779		func getOneTkn (outAssetIdStr,minOutAmount) = {
788		-	let isGetDisabled = if (isGlobalShutdown())
	780	+	let isPoolOneTokenOperationsDisabled = {
	781	+	let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
	782	+	if ($isInstanceOf(@, "Boolean"))
	783	+	then @
	784	+	else throw(($getType(@) + " couldn't be cast to Boolean"))
	785	+	}
	786	+	let isGetDisabled = if (if (isGlobalShutdown())
789	787		then true
790		-	else (cfgPoolStatus == PoolShutdown)
	788	+	else (cfgPoolStatus == PoolShutdown))
	789	+	then true
	790	+	else isPoolOneTokenOperationsDisabled
791	791		let checks = [if (!(isGetDisabled))
792	792		then true
793	793		else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))

801	801		let paymentAmount = payment.amount
802	802		let userAddress = i.caller
803	803		let txId = i.transactionId
804		-	let $~~t03263632768~~ = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
805		-	let amountEstimated = $~~t03263632768~~._1
806		-	let commonState = $~~t03263632768~~._2
807		-	let feeAmount = $~~t03263632768~~._3
808		-	let bonus = $~~t03263632768~~._4
	804	+	let $t03276032892 = calcGetOneToken(outAssetId, paymentAmount, paymentAssetId, userAddress, txId)
	805	+	let amountEstimated = $t03276032892._1
	806	+	let commonState = $t03276032892._2
	807	+	let feeAmount = $t03276032892._3
	808	+	let bonus = $t03276032892._4
809	809		let amount = if (if ((minOutAmount > 0))
810	810		then (minOutAmount > amountEstimated)
811	811		else false)

829	829
830	830		@Callable(i)
831	831		func getOneTknREADONLY (outAssetId,paymentAmount) = {
832		-	let $~~t03340333541~~ = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
833		-	let amountEstimated = $~~t03340333541~~._1
834		-	let commonState = $~~t03340333541~~._2
835		-	let feeAmount = $~~t03340333541~~._3
836		-	let bonus = $~~t03340333541~~._4
	832	+	let $t03352733665 = calcGetOneToken(parseAssetId(outAssetId), paymentAmount, cfgLpAssetId, unit, unit)
	833	+	let amountEstimated = $t03352733665._1
	834	+	let commonState = $t03352733665._2
	835	+	let feeAmount = $t03352733665._3
	836	+	let bonus = $t03352733665._4
837	837		$Tuple2(nil, $Tuple3(amountEstimated, feeAmount, bonus))
838	838		}
839	839

841	841
842	842		@Callable(i)
843	843		func unstakeAndGetOneTkn (unstakeAmount,outAssetIdStr,minOutAmount) = {
844		-	let isGetDisabled = if (isGlobalShutdown())
	844	+	let isPoolOneTokenOperationsDisabled = {
	845	+	let @ = invoke(factoryContract, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
	846	+	if ($isInstanceOf(@, "Boolean"))
	847	+	then @
	848	+	else throw(($getType(@) + " couldn't be cast to Boolean"))
	849	+	}
	850	+	let isGetDisabled = if (if (isGlobalShutdown())
845	851		then true
846		-	else (cfgPoolStatus == PoolShutdown)
	852	+	else (cfgPoolStatus == PoolShutdown))
	853	+	then true
	854	+	else isPoolOneTokenOperationsDisabled
847	855		let checks = [if (!(isGetDisabled))
848	856		then true
849	857		else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 0))

857	865		let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
858	866		if ((unstakeInv == unstakeInv))
859	867		then {
860		-	let $~~t03414934279~~ = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
861		-	let amountEstimated = $~~t03414934279~~._1
862		-	let commonState = $~~t03414934279~~._2
863		-	let feeAmount = $~~t03414934279~~._3
864		-	let bonus = $~~t03414934279~~._4
	868	+	let $t03445734587 = calcGetOneToken(outAssetId, unstakeAmount, cfgLpAssetId, userAddress, txId)
	869	+	let amountEstimated = $t03445734587._1
	870	+	let commonState = $t03445734587._2
	871	+	let feeAmount = $t03445734587._3
	872	+	let bonus = $t03445734587._4
865	873		let amount = if (if ((minOutAmount > 0))
866	874		then (minOutAmount > amountEstimated)
867	875		else false)

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

github/deemru/w8io/026f985 
136.67 ms ◑