w8 · tx · tPf···tJu

tx · tPf4ksgoCwRFPeNbEni32JhpqRVWJhpTG8KG5W8MtJu

3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA:  -0.02900000 Waves

2022.08.30 12:02 [2206980] smart account 3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "tPf4ksgoCwRFPeNbEni32JhpqRVWJhpTG8KG5W8MtJu",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1661850164001,
    "version": 2,
    "chainId": 84,
    "sender": "3MzKSdTH2jFbypLsoNfrH7QgkzSbx3EYwCA",
    "senderPublicKey": "35yd3qw1gxKDxKwGAykHN9fANbXNWwseaUwbWDj24o3x",
    "proofs": [
        "3R3Sgbc881VtCBm7uupM1P64WRYj7VFY2dAvjsdo6pMwBxjayqijGaeAEommtMDUGeZ6BufA3HD6c3ozGPgnvwE6"
    ],
    "script": "base64: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",
    "height": 2206980,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 98aDwqZ1HchCAccKDav7rgPxPUH8txnBAVZ3we7nbe9f
Next: GNHraBT3fAmc8BmGJJZJa3zuKaj3gpsUb2HBAuH3Xwpp

Diff: 
Old New Differences
639 639                          let virtSwapOutAm = $t02476125337._6
640 640                          let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
641 641                          let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
642 -                         let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
643 -                         if ((D0vsD1 == D0vsD1))
644 -                             then {
645 -                                 let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
646 -                                 let estimLP = estPut._2
647 -                                 let lpAssetId = estPut._7
648 -                                 let state = estPut._9
649 -                                 let amDiff = estPut._10
650 -                                 let prDiff = estPut._11
651 -                                 let lpCalcRes = vad(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
652 -                                 let emitLpAmt = toInt(lpCalcRes._2)
653 -                                 let e = invoke(fca, "emit", [emitLpAmt], nil)
654 -                                 if ((e == e))
642 +                         if (true)
643 +                             then throw(((toString(amBalanceNow) + ", ") + toString(prBalanceNow)))
644 +                             else {
645 +                                 let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
646 +                                 if ((D0vsD1 == D0vsD1))
655 647                                      then {
656 -                                         let el =                                         match e {
657 -                                             case legacy: Address => 
658 -                                                 invoke(legacy, "emit", [emitLpAmt], nil)
659 -                                             case _ => 
660 -                                                 unit
661 -                                         }
662 -                                         if ((el == el))
648 +                                         let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
649 +                                         let estimLP = estPut._2
650 +                                         let lpAssetId = estPut._7
651 +                                         let state = estPut._9
652 +                                         let amDiff = estPut._10
653 +                                         let prDiff = estPut._11
654 +                                         let lpCalcRes = vad(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
655 +                                         let emitLpAmt = toInt(lpCalcRes._2)
656 +                                         let e = invoke(fca, "emit", [emitLpAmt], nil)
657 +                                         if ((e == e))
663 658                                              then {
664 -                                                 let sa = if ((amDiff > 0))
665 -                                                     then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
666 -                                                     else nil
667 -                                                 if ((sa == sa))
659 +                                                 let el =                                                 match e {
660 +                                                     case legacy: Address => 
661 +                                                         invoke(legacy, "emit", [emitLpAmt], nil)
662 +                                                     case _ => 
663 +                                                         unit
664 +                                                 }
665 +                                                 if ((el == el))
668 666                                                      then {
669 -                                                         let sp = if ((prDiff > 0))
670 -                                                             then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
667 +                                                         let sa = if ((amDiff > 0))
668 +                                                             then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
671 669                                                              else nil
672 -                                                         if ((sp == sp))
670 +                                                         if ((sa == sa))
673 671                                                              then {
674 -                                                                 let lpTrnsfr = if (autoStake)
672 +                                                                 let sp = if ((prDiff > 0))
673 +                                                                     then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
674 +                                                                     else nil
675 +                                                                 if ((sp == sp))
675 676                                                                      then {
676 -                                                                         let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
677 -                                                                         if ((ss == ss))
678 -                                                                             then nil
679 -                                                                             else throw("Strict value is not equal to itself.")
677 +                                                                         let lpTrnsfr = if (autoStake)
678 +                                                                             then {
679 +                                                                                 let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
680 +                                                                                 if ((ss == ss))
681 +                                                                                     then nil
682 +                                                                                     else throw("Strict value is not equal to itself.")
683 +                                                                                 }
684 +                                                                             else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
685 +                                                                         let sendFeeToMatcher = if ((feeAmount > 0))
686 +                                                                             then [ScriptTransfer(matcherAddress, feeAmount, fromBase58String(pmtAssetId))]
687 +                                                                             else nil
688 +                                                                         ((state ++ lpTrnsfr) ++ sendFeeToMatcher)
680 689                                                                          }
681 -                                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
682 -                                                                 let sendFeeToMatcher = if ((feeAmount > 0))
683 -                                                                     then [ScriptTransfer(matcherAddress, feeAmount, fromBase58String(pmtAssetId))]
684 -                                                                     else nil
685 -                                                                 ((state ++ lpTrnsfr) ++ sendFeeToMatcher)
690 +                                                                     else throw("Strict value is not equal to itself.")
686 691                                                                  }
687 692                                                              else throw("Strict value is not equal to itself.")
688 693                                                          }
692 697                                          }
693 698                                      else throw("Strict value is not equal to itself.")
694 699                                  }
695 -                             else throw("Strict value is not equal to itself.")
696 700                          }
697 701                  }
698 702      }
764 768                          let estimPrAmt = r._2
765 769                          let amBalance = getAccBalance(amId)
766 770                          let prBalance = getAccBalance(prId)
767 -                         let $t03027530735 = if ((outAssetId == amId))
771 +                         let $t03036430824 = if ((outAssetId == amId))
768 772                              then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), exchResult, estimPrAmt, 0, 0, (estimAmAmt + exchResult))
769 773                              else if ((outAssetId == prId))
770 774                                  then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, exchResult, estimAmAmt, (estimPrAmt + exchResult))
771 775                                  else throw("wrong outAssetId")
772 -                         let amBalanceNow = $t03027530735._1
773 -                         let prBalanceNow = $t03027530735._2
774 -                         let virtSwapInAm = $t03027530735._3
775 -                         let virtSwapOutPr = $t03027530735._4
776 -                         let virtSwapInPr = $t03027530735._5
777 -                         let virtSwapOutAm = $t03027530735._6
778 -                         let totalGetRaw = $t03027530735._7
776 +                         let amBalanceNow = $t03036430824._1
777 +                         let prBalanceNow = $t03036430824._2
778 +                         let virtSwapInAm = $t03036430824._3
779 +                         let virtSwapOutPr = $t03036430824._4
780 +                         let virtSwapInPr = $t03036430824._5
781 +                         let virtSwapOutAm = $t03036430824._6
782 +                         let totalGetRaw = $t03036430824._7
779 783                          if (if ((0 > virtSwapInAm))
780 784                              then true
781 785                              else (0 > virtSwapInPr))
790 794                                          let finalRes = vad(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
791 795                                          if ((finalRes == finalRes))
792 796                                              then {
793 -                                                 let $t03148231586 = if ((outAssetId == amId))
797 +                                                 let $t03157131675 = if ((outAssetId == amId))
794 798                                                      then $Tuple2(toInt(finalRes._2), 0)
795 799                                                      else $Tuple2(0, toInt(finalRes._2))
796 -                                                 let outAm = $t03148231586._1
797 -                                                 let outPr = $t03148231586._2
800 +                                                 let outAm = $t03157131675._1
801 +                                                 let outPr = $t03157131675._2
798 802                                                  let totalAmount = (outAm + outPr)
799 803                                                  let feeAmount = (totalGetRaw - totalGet)
800 804                                                  let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let scale8 = 100000000
5 5  
6 6  let scale8BigInt = toBigInt(100000000)
7 7  
8 8  let scale18 = toBigInt(1000000000000000000)
9 9  
10 10  let thousand = 1000
11 11  
12 12  let zeroBigInt = toBigInt(0)
13 13  
14 14  let oneBigInt = toBigInt(1)
15 15  
16 16  let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
17 17  
18 18  let Amult = "100"
19 19  
20 20  let Dconv = "1"
21 21  
22 22  let SEP = "__"
23 23  
24 24  let EMPTY = ""
25 25  
26 26  let PoolActive = 1
27 27  
28 28  let PoolPutDis = 2
29 29  
30 30  let PoolMatcherDis = 3
31 31  
32 32  let PoolShutdown = 4
33 33  
34 34  let idxPoolAddress = 1
35 35  
36 36  let idxPoolSt = 2
37 37  
38 38  let idxLPAsId = 3
39 39  
40 40  let idxAmAsId = 4
41 41  
42 42  let idxPrAsId = 5
43 43  
44 44  let idxAmtAsDcm = 6
45 45  
46 46  let idxPriceAsDcm = 7
47 47  
48 48  let idxIAmtAsId = 8
49 49  
50 50  let idxIPriceAsId = 9
51 51  
52 52  let idxFactStakCntr = 1
53 53  
54 54  let idxFactSlippCntr = 7
55 55  
56 56  let idxFactGwxRewCntr = 10
57 57  
58 58  let feePermilleDefault = 0
59 59  
60 60  func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
61 61  
62 62  
63 63  func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
64 64  
65 65  
66 66  func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
67 67  
68 68  
69 69  func abs (val) = if ((zeroBigInt > val))
70 70      then -(val)
71 71      else val
72 72  
73 73  
74 74  func fc () = "%s__factoryContract"
75 75  
76 76  
77 77  func mpk () = "%s__managerPublicKey"
78 78  
79 79  
80 80  func pmpk () = "%s__pendingManagerPublicKey"
81 81  
82 82  
83 83  func pl () = "%s%s__price__last"
84 84  
85 85  
86 86  func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
87 87  
88 88  
89 89  func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
90 90  
91 91  
92 92  func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
93 93  
94 94  
95 95  func aa () = "%s__amountAsset"
96 96  
97 97  
98 98  func pa () = "%s__priceAsset"
99 99  
100 100  
101 101  func amp () = "%s__amp"
102 102  
103 103  
104 104  func ada () = "%s__addonAddr"
105 105  
106 106  
107 107  let keyFeePermille = "%s__feePermille"
108 108  
109 109  let feePermille = valueOrElse(getInteger(this, keyFeePermille), feePermilleDefault)
110 110  
111 111  func fcfg () = "%s__factoryConfig"
112 112  
113 113  
114 114  func mtpk () = "%s%s__matcher__publicKey"
115 115  
116 116  
117 117  func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
118 118  
119 119  
120 120  func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
121 121  
122 122  
123 123  func aps () = "%s__shutdown"
124 124  
125 125  
126 126  func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
127 127  
128 128  
129 129  func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
130 130  
131 131  
132 132  func str (val) = match val {
133 133      case valStr: String => 
134 134          valStr
135 135      case _ => 
136 136          throw("fail cast to String")
137 137  }
138 138  
139 139  
140 140  func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
141 141  
142 142  
143 143  func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
144 144  
145 145  
146 146  let fca = addressFromStringValue(strf(this, fc()))
147 147  
148 148  let A = strf(this, amp())
149 149  
150 150  func igs () = valueOrElse(getBoolean(fca, aps()), false)
151 151  
152 152  
153 153  func mp () = fromBase58String(strf(fca, mtpk()))
154 154  
155 155  
156 156  let matcherAddress = addressFromPublicKey(mp())
157 157  
158 158  func gpc () = {
159 159      let amtAs = strf(this, aa())
160 160      let priceAs = strf(this, pa())
161 161      let iPriceAs = intf(fca, mba(priceAs))
162 162      let iAmtAs = intf(fca, mba(amtAs))
163 163      split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
164 164      }
165 165  
166 166  
167 167  func gfc () = split(strf(fca, fcfg()), SEP)
168 168  
169 169  
170 170  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
171 171  
172 172  
173 173  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)
174 174  
175 175  
176 176  func getAccBalance (assetId) = if ((assetId == "WAVES"))
177 177      then wavesBalance(this).available
178 178      else assetBalance(this, fromBase58String(assetId))
179 179  
180 180  
181 181  func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
182 182  
183 183  
184 184  func vad (A1,A2,slippage) = {
185 185      let diff = fraction((A1 - A2), scale8BigInt, A2)
186 186      let pass = ((slippage - abs(diff)) > zeroBigInt)
187 187      if (!(pass))
188 188          then throw(("Big slpg: " + toString(diff)))
189 189          else $Tuple2(pass, min([A1, A2]))
190 190      }
191 191  
192 192  
193 193  func vd (D1,D0,slpg) = {
194 194      let diff = fraction(D0, scale8BigInt, D1)
195 195      let fail = (slpg > diff)
196 196      if (if (fail)
197 197          then true
198 198          else (D0 > D1))
199 199          then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
200 200          else fail
201 201      }
202 202  
203 203  
204 204  func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
205 205      let amtAsAmtX18 = t1(amAmt, amAssetDcm)
206 206      let prAsAmtX18 = t1(prAmt, prAssetDcm)
207 207      cpbi(prAsAmtX18, amtAsAmtX18)
208 208      }
209 209  
210 210  
211 211  func calcPrices (amAmt,prAmt,lpAmt) = {
212 212      let cfg = gpc()
213 213      let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
214 214      let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
215 215      let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
216 216      let amAmtX18 = t1(amAmt, amtAsDcm)
217 217      let prAmtX18 = t1(prAmt, prAsDcm)
218 218      let lpAmtX18 = t1(lpAmt, scale8)
219 219      let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
220 220      let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
221 221  [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
222 222      }
223 223  
224 224  
225 225  func calculatePrices (amAmt,prAmt,lpAmt) = {
226 226      let p = calcPrices(amAmt, prAmt, lpAmt)
227 227  [f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
228 228      }
229 229  
230 230  
231 231  func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
232 232      let cfg = gpc()
233 233      let lpId = cfg[idxLPAsId]
234 234      let amId = cfg[idxAmAsId]
235 235      let prId = cfg[idxPrAsId]
236 236      let amDcm = parseIntValue(cfg[idxAmtAsDcm])
237 237      let prDcm = parseIntValue(cfg[idxPriceAsDcm])
238 238      let sts = cfg[idxPoolSt]
239 239      let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
240 240      if ((lpId != pmtAssetId))
241 241          then throw("Wrong pmt asset")
242 242          else {
243 243              let amBalance = getAccBalance(amId)
244 244              let amBalanceX18 = t1(amBalance, amDcm)
245 245              let prBalance = getAccBalance(prId)
246 246              let prBalanceX18 = t1(prBalance, prDcm)
247 247              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
248 248              let curPrice = f1(curPriceX18, scale8)
249 249              let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
250 250              let lpEmissX18 = t1(lpEmiss, scale8)
251 251              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
252 252              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
253 253              let outAmAmt = f1(outAmAmtX18, amDcm)
254 254              let outPrAmt = f1(outPrAmtX18, prDcm)
255 255              let state = if ((txId58 == ""))
256 256                  then nil
257 257                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
258 258                      then unit
259 259                      else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
260 260                      then unit
261 261                      else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
262 262              $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
263 263              }
264 264      }
265 265  
266 266  
267 267  func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,pmtAmt,pmtId) = {
268 268      let cfg = gpc()
269 269      let lpId = fromBase58String(cfg[idxLPAsId])
270 270      let amIdStr = cfg[idxAmAsId]
271 271      let prIdStr = cfg[idxPrAsId]
272 272      let inAmIdStr = cfg[idxIAmtAsId]
273 273      let inPrIdStr = cfg[idxIPriceAsId]
274 274      let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
275 275      let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
276 276      let sts = cfg[idxPoolSt]
277 277      let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
278 278      let amBalance = if (isEval)
279 279          then getAccBalance(amIdStr)
280 280          else if (if (isOneAsset)
281 281              then (pmtId == amIdStr)
282 282              else false)
283 283              then (getAccBalance(amIdStr) - pmtAmt)
284 284              else if (isOneAsset)
285 285                  then getAccBalance(amIdStr)
286 286                  else (getAccBalance(amIdStr) - inAmAmt)
287 287      let prBalance = if (isEval)
288 288          then getAccBalance(prIdStr)
289 289          else if (if (isOneAsset)
290 290              then (pmtId == prIdStr)
291 291              else false)
292 292              then (getAccBalance(prIdStr) - pmtAmt)
293 293              else if (isOneAsset)
294 294                  then getAccBalance(prIdStr)
295 295                  else (getAccBalance(prIdStr) - inPrAmt)
296 296      let inAmAssetAmtX18 = t1(inAmAmt, amtDcm)
297 297      let inPrAssetAmtX18 = t1(inPrAmt, priceDcm)
298 298      let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
299 299      let amBalanceX18 = t1(amBalance, amtDcm)
300 300      let prBalanceX18 = t1(prBalance, priceDcm)
301 301      let r = if ((lpEm == 0))
302 302          then {
303 303              let curPriceX18 = zeroBigInt
304 304              let slippageX18 = zeroBigInt
305 305              let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
306 306              $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
307 307              }
308 308          else {
309 309              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
310 310              let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
311 311              let slippageX18 = t1(slippage, scale8)
312 312              if (if ((curPriceX18 != zeroBigInt))
313 313                  then (slippageRealX18 > slippageX18)
314 314                  else false)
315 315                  then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
316 316                  else {
317 317                      let lpEmissionX18 = t1(lpEm, scale8)
318 318                      let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
319 319                      let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
320 320                      let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
321 321                          then $Tuple2(amViaPrX18, inPrAssetAmtX18)
322 322                          else $Tuple2(inAmAssetAmtX18, prViaAmX18)
323 323                      let expAmtAssetAmtX18 = expectedAmts._1
324 324                      let expPriceAssetAmtX18 = expectedAmts._2
325 325                      let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
326 326                      $Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
327 327                      }
328 328              }
329 329      let calcLpAmt = r._1
330 330      let calcAmAssetPmt = r._2
331 331      let calcPrAssetPmt = r._3
332 332      let curPrice = f1(r._4, scale8)
333 333      let slippageCalc = f1(r._5, scale8)
334 334      if ((0 >= calcLpAmt))
335 335          then throw("LP <= 0")
336 336          else {
337 337              let emitLpAmt = if (!(emitLp))
338 338                  then 0
339 339                  else calcLpAmt
340 340              let amDiff = (inAmAmt - calcAmAssetPmt)
341 341              let prDiff = (inPrAmt - calcPrAssetPmt)
342 342              let $t01558715932 = if (if (isOneAsset)
343 343                  then (pmtId == amIdStr)
344 344                  else false)
345 345                  then $Tuple2(pmtAmt, 0)
346 346                  else if (if (isOneAsset)
347 347                      then (pmtId == prIdStr)
348 348                      else false)
349 349                      then $Tuple2(0, pmtAmt)
350 350                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
351 351              let writeAmAmt = $t01558715932._1
352 352              let writePrAmt = $t01558715932._2
353 353              let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
354 354              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
355 355              }
356 356      }
357 357  
358 358  
359 359  func moa (order) = {
360 360      let cfg = gpc()
361 361      let amtAsId = cfg[idxAmAsId]
362 362      let prAsId = cfg[idxPrAsId]
363 363      let sts = parseIntValue(cfg[idxPoolSt])
364 364      let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
365 365      let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
366 366      let accAmtAsBalance = getAccBalance(amtAsId)
367 367      let accPrAsBalance = getAccBalance(prAsId)
368 368      let curPriceX18 = if ((order.orderType == Buy))
369 369          then pcp(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
370 370          else pcp(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
371 371      let curPrice = f1(curPriceX18, scale8)
372 372      if (if (if (igs())
373 373          then true
374 374          else (sts == PoolMatcherDis))
375 375          then true
376 376          else (sts == PoolShutdown))
377 377          then throw("Admin blocked")
378 378          else {
379 379              let orAmtAsset = order.assetPair.amountAsset
380 380              let orAmtAsStr = if ((orAmtAsset == unit))
381 381                  then "WAVES"
382 382                  else toBase58String(value(orAmtAsset))
383 383              let orPrAsset = order.assetPair.priceAsset
384 384              let orPrAsStr = if ((orPrAsset == unit))
385 385                  then "WAVES"
386 386                  else toBase58String(value(orPrAsset))
387 387              if (if ((orAmtAsStr != amtAsId))
388 388                  then true
389 389                  else (orPrAsStr != prAsId))
390 390                  then throw("Wr assets")
391 391                  else {
392 392                      let orderPrice = order.price
393 393                      let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
394 394                      let castOrderPrice = ts(orderPrice, scale8, priceDcm)
395 395                      let isOrderPriceValid = if ((order.orderType == Buy))
396 396                          then (curPrice >= castOrderPrice)
397 397                          else (castOrderPrice >= curPrice)
398 398                      true
399 399                      }
400 400              }
401 401      }
402 402  
403 403  
404 404  func cg (i) = if ((size(i.payments) != 1))
405 405      then throw("1 pmnt exp")
406 406      else {
407 407          let pmt = value(i.payments[0])
408 408          let pmtAssetId = value(pmt.assetId)
409 409          let pmtAmt = pmt.amount
410 410          let r = ego(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
411 411          let outAmAmt = r._1
412 412          let outPrAmt = r._2
413 413          let sts = parseIntValue(r._9)
414 414          let state = r._10
415 415          if (if (igs())
416 416              then true
417 417              else (sts == PoolShutdown))
418 418              then throw(("Admin blocked: " + toString(sts)))
419 419              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
420 420          }
421 421  
422 422  
423 423  func cp (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,pmtAmt,pmtId) = {
424 424      let r = epo(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp, isOneAsset, pmtAmt, pmtId)
425 425      let sts = parseIntValue(r._8)
426 426      if (if (if (igs())
427 427          then true
428 428          else (sts == PoolPutDis))
429 429          then true
430 430          else (sts == PoolShutdown))
431 431          then throw(("Blocked:" + toString(sts)))
432 432          else r
433 433      }
434 434  
435 435  
436 436  func takeFee (amount) = {
437 437      let fee = fraction(amount, feePermille, thousand)
438 438      $Tuple2((amount - fee), fee)
439 439      }
440 440  
441 441  
442 442  func m () = match getString(mpk()) {
443 443      case s: String => 
444 444          fromBase58String(s)
445 445      case _: Unit => 
446 446          unit
447 447      case _ => 
448 448          throw("Match error")
449 449  }
450 450  
451 451  
452 452  func pm () = match getString(pmpk()) {
453 453      case s: String => 
454 454          fromBase58String(s)
455 455      case _: Unit => 
456 456          unit
457 457      case _ => 
458 458          throw("Match error")
459 459  }
460 460  
461 461  
462 462  let pd = throw("Permission denied")
463 463  
464 464  func mm (i) = match m() {
465 465      case pk: ByteVector => 
466 466          if ((i.callerPublicKey == pk))
467 467              then true
468 468              else pd
469 469      case _: Unit => 
470 470          if ((i.caller == this))
471 471              then true
472 472              else pd
473 473      case _ => 
474 474          throw("Match error")
475 475  }
476 476  
477 477  
478 478  @Callable(i)
479 479  func constructor (fc) = {
480 480      let c = mm(i)
481 481      if ((c == c))
482 482          then [StringEntry(fc(), fc)]
483 483          else throw("Strict value is not equal to itself.")
484 484      }
485 485  
486 486  
487 487  
488 488  @Callable(i)
489 489  func setManager (pendingManagerPublicKey) = {
490 490      let c = mm(i)
491 491      if ((c == c))
492 492          then {
493 493              let cm = fromBase58String(pendingManagerPublicKey)
494 494              if ((cm == cm))
495 495                  then [StringEntry(pmpk(), pendingManagerPublicKey)]
496 496                  else throw("Strict value is not equal to itself.")
497 497              }
498 498          else throw("Strict value is not equal to itself.")
499 499      }
500 500  
501 501  
502 502  
503 503  @Callable(i)
504 504  func confirmManager () = {
505 505      let p = pm()
506 506      let hpm = if (isDefined(p))
507 507          then true
508 508          else throw("No pending manager")
509 509      if ((hpm == hpm))
510 510          then {
511 511              let cpm = if ((i.callerPublicKey == value(p)))
512 512                  then true
513 513                  else throw("You are not pending manager")
514 514              if ((cpm == cpm))
515 515                  then [StringEntry(mpk(), toBase58String(value(p))), DeleteEntry(pmpk())]
516 516                  else throw("Strict value is not equal to itself.")
517 517              }
518 518          else throw("Strict value is not equal to itself.")
519 519      }
520 520  
521 521  
522 522  
523 523  @Callable(i)
524 524  func put (slip,autoStake) = {
525 525      let factCfg = gfc()
526 526      let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
527 527      let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
528 528      if ((0 > slip))
529 529          then throw("Wrong slippage")
530 530          else if ((size(i.payments) != 2))
531 531              then throw("2 pmnts expd")
532 532              else {
533 533                  let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, 0, "")
534 534                  let emitLpAmt = e._2
535 535                  let lpAssetId = e._7
536 536                  let state = e._9
537 537                  let amDiff = e._10
538 538                  let prDiff = e._11
539 539                  let amId = e._12
540 540                  let prId = e._13
541 541                  let r = invoke(fca, "emit", [emitLpAmt], nil)
542 542                  if ((r == r))
543 543                      then {
544 544                          let el =                         match r {
545 545                              case legacy: Address => 
546 546                                  invoke(legacy, "emit", [emitLpAmt], nil)
547 547                              case _ => 
548 548                                  unit
549 549                          }
550 550                          if ((el == el))
551 551                              then {
552 552                                  let sa = if ((amDiff > 0))
553 553                                      then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
554 554                                      else nil
555 555                                  if ((sa == sa))
556 556                                      then {
557 557                                          let sp = if ((prDiff > 0))
558 558                                              then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
559 559                                              else nil
560 560                                          if ((sp == sp))
561 561                                              then {
562 562                                                  let lpTrnsfr = if (autoStake)
563 563                                                      then {
564 564                                                          let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
565 565                                                          if ((ss == ss))
566 566                                                              then nil
567 567                                                              else throw("Strict value is not equal to itself.")
568 568                                                          }
569 569                                                      else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
570 570                                                  (state ++ lpTrnsfr)
571 571                                                  }
572 572                                              else throw("Strict value is not equal to itself.")
573 573                                          }
574 574                                      else throw("Strict value is not equal to itself.")
575 575                                  }
576 576                              else throw("Strict value is not equal to itself.")
577 577                          }
578 578                      else throw("Strict value is not equal to itself.")
579 579                  }
580 580      }
581 581  
582 582  
583 583  
584 584  @Callable(i)
585 585  func putOneTkn (amAssetPart,prAssetPart,outLp,slippage,autoStake) = {
586 586      let cfg = gfc()
587 587      let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
588 588      let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
589 589      let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
590 590      let poolCfg = gpc()
591 591      let amId = poolCfg[idxAmAsId]
592 592      let prId = poolCfg[idxPrAsId]
593 593      let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
594 594      let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
595 595      let addon = valueOrElse(getString(this, ada()), "")
596 596      let userAddress = if ((addon == toString(i.caller)))
597 597          then i.originCaller
598 598          else i.caller
599 599      if (if (if (if ((0 >= slippage))
600 600          then true
601 601          else (0 >= amAssetPart))
602 602          then true
603 603          else (0 >= prAssetPart))
604 604          then true
605 605          else (0 >= outLp))
606 606          then throw("Wrong params")
607 607          else if ((size(i.payments) != 1))
608 608              then throw("1 pmnt expd")
609 609              else {
610 610                  let pmt = value(i.payments[0])
611 611                  let pmtAssetId = toBase58String(value(pmt.assetId))
612 612                  let paymentAmountRaw = pmt.amount
613 613                  let $t02454924601 = takeFee(paymentAmountRaw)
614 614                  let pmtAmt = $t02454924601._1
615 615                  let feeAmount = $t02454924601._2
616 616                  if ((10000000 > paymentAmountRaw))
617 617                      then throw("Wrong pmt amt")
618 618                      else {
619 619                          let amBalance = getAccBalance(amId)
620 620                          let prBalance = getAccBalance(prId)
621 621                          let $t02476125337 = if ((pmtAssetId == amId))
622 622                              then if (if ((pmtAmt > amBalance))
623 623                                  then true
624 624                                  else (amAssetPart > pmtAmt))
625 625                                  then throw("invalid payment amount")
626 626                                  else $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
627 627                              else if ((pmtAssetId == prId))
628 628                                  then if (if ((pmtAmt > prBalance))
629 629                                      then true
630 630                                      else (prAssetPart > pmtAmt))
631 631                                      then throw("invalid payment amount")
632 632                                      else $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
633 633                                  else throw("wrong pmtAssetId")
634 634                          let amBalanceNow = $t02476125337._1
635 635                          let prBalanceNow = $t02476125337._2
636 636                          let virtSwapInAm = $t02476125337._3
637 637                          let virtSwapOutPr = $t02476125337._4
638 638                          let virtSwapInPr = $t02476125337._5
639 639                          let virtSwapOutAm = $t02476125337._6
640 640                          let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
641 641                          let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
642 -                         let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
643 -                         if ((D0vsD1 == D0vsD1))
644 -                             then {
645 -                                 let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
646 -                                 let estimLP = estPut._2
647 -                                 let lpAssetId = estPut._7
648 -                                 let state = estPut._9
649 -                                 let amDiff = estPut._10
650 -                                 let prDiff = estPut._11
651 -                                 let lpCalcRes = vad(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
652 -                                 let emitLpAmt = toInt(lpCalcRes._2)
653 -                                 let e = invoke(fca, "emit", [emitLpAmt], nil)
654 -                                 if ((e == e))
642 +                         if (true)
643 +                             then throw(((toString(amBalanceNow) + ", ") + toString(prBalanceNow)))
644 +                             else {
645 +                                 let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
646 +                                 if ((D0vsD1 == D0vsD1))
655 647                                      then {
656 -                                         let el =                                         match e {
657 -                                             case legacy: Address => 
658 -                                                 invoke(legacy, "emit", [emitLpAmt], nil)
659 -                                             case _ => 
660 -                                                 unit
661 -                                         }
662 -                                         if ((el == el))
648 +                                         let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
649 +                                         let estimLP = estPut._2
650 +                                         let lpAssetId = estPut._7
651 +                                         let state = estPut._9
652 +                                         let amDiff = estPut._10
653 +                                         let prDiff = estPut._11
654 +                                         let lpCalcRes = vad(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
655 +                                         let emitLpAmt = toInt(lpCalcRes._2)
656 +                                         let e = invoke(fca, "emit", [emitLpAmt], nil)
657 +                                         if ((e == e))
663 658                                              then {
664 -                                                 let sa = if ((amDiff > 0))
665 -                                                     then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
666 -                                                     else nil
667 -                                                 if ((sa == sa))
659 +                                                 let el =                                                 match e {
660 +                                                     case legacy: Address => 
661 +                                                         invoke(legacy, "emit", [emitLpAmt], nil)
662 +                                                     case _ => 
663 +                                                         unit
664 +                                                 }
665 +                                                 if ((el == el))
668 666                                                      then {
669 -                                                         let sp = if ((prDiff > 0))
670 -                                                             then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
667 +                                                         let sa = if ((amDiff > 0))
668 +                                                             then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
671 669                                                              else nil
672 -                                                         if ((sp == sp))
670 +                                                         if ((sa == sa))
673 671                                                              then {
674 -                                                                 let lpTrnsfr = if (autoStake)
672 +                                                                 let sp = if ((prDiff > 0))
673 +                                                                     then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
674 +                                                                     else nil
675 +                                                                 if ((sp == sp))
675 676                                                                      then {
676 -                                                                         let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
677 -                                                                         if ((ss == ss))
678 -                                                                             then nil
679 -                                                                             else throw("Strict value is not equal to itself.")
677 +                                                                         let lpTrnsfr = if (autoStake)
678 +                                                                             then {
679 +                                                                                 let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
680 +                                                                                 if ((ss == ss))
681 +                                                                                     then nil
682 +                                                                                     else throw("Strict value is not equal to itself.")
683 +                                                                                 }
684 +                                                                             else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
685 +                                                                         let sendFeeToMatcher = if ((feeAmount > 0))
686 +                                                                             then [ScriptTransfer(matcherAddress, feeAmount, fromBase58String(pmtAssetId))]
687 +                                                                             else nil
688 +                                                                         ((state ++ lpTrnsfr) ++ sendFeeToMatcher)
680 689                                                                          }
681 -                                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
682 -                                                                 let sendFeeToMatcher = if ((feeAmount > 0))
683 -                                                                     then [ScriptTransfer(matcherAddress, feeAmount, fromBase58String(pmtAssetId))]
684 -                                                                     else nil
685 -                                                                 ((state ++ lpTrnsfr) ++ sendFeeToMatcher)
690 +                                                                     else throw("Strict value is not equal to itself.")
686 691                                                                  }
687 692                                                              else throw("Strict value is not equal to itself.")
688 693                                                          }
689 694                                                      else throw("Strict value is not equal to itself.")
690 695                                                  }
691 696                                              else throw("Strict value is not equal to itself.")
692 697                                          }
693 698                                      else throw("Strict value is not equal to itself.")
694 699                                  }
695 -                             else throw("Strict value is not equal to itself.")
696 700                          }
697 701                  }
698 702      }
699 703  
700 704  
701 705  
702 706  @Callable(i)
703 707  func putForFree (maxSlpg) = if ((0 > maxSlpg))
704 708      then throw("Wrong slpg")
705 709      else if ((size(i.payments) != 2))
706 710          then throw("2 pmnts expd")
707 711          else {
708 712              let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, 0, "")
709 713              estPut._9
710 714              }
711 715  
712 716  
713 717  
714 718  @Callable(i)
715 719  func get () = {
716 720      let r = cg(i)
717 721      let outAmtAmt = r._1
718 722      let outPrAmt = r._2
719 723      let pmtAmt = r._3
720 724      let pmtAssetId = r._4
721 725      let state = r._5
722 726      let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
723 727      if ((b == b))
724 728          then state
725 729          else throw("Strict value is not equal to itself.")
726 730      }
727 731  
728 732  
729 733  
730 734  @Callable(i)
731 735  func getOneTkn (exchResult,notUsed,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
732 736      then throw("1 pmnt expd")
733 737      else {
734 738          let cfg = gpc()
735 739          let lpId = cfg[idxLPAsId]
736 740          let amId = cfg[idxAmAsId]
737 741          let prId = cfg[idxPrAsId]
738 742          let amDcm = parseIntValue(cfg[idxAmtAsDcm])
739 743          let prDcm = parseIntValue(cfg[idxPriceAsDcm])
740 744          let sts = cfg[idxPoolSt]
741 745          let factCfg = gfc()
742 746          let gwxCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactGwxRewCntr]), "Wr sl addr")
743 747          let pmt = value(i.payments[0])
744 748          let addon = valueOrElse(getString(this, ada()), "")
745 749          let userAddress = if ((addon == toString(i.caller)))
746 750              then i.originCaller
747 751              else i.caller
748 752          let txId58 = toBase58String(i.transactionId)
749 753          let pmtAssetId = value(pmt.assetId)
750 754          let pmtAmt = pmt.amount
751 755          if ((1000000000 > pmtAmt))
752 756              then throw("Min pmt 10 LP")
753 757              else if (if (if ((0 > slippage))
754 758                  then true
755 759                  else (0 > exchResult))
756 760                  then true
757 761                  else (0 > outAmount))
758 762                  then throw("Wrong params")
759 763                  else if ((lpId != toBase58String(pmtAssetId)))
760 764                      then throw("Wrong LP")
761 765                      else {
762 766                          let r = ego(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
763 767                          let estimAmAmt = r._1
764 768                          let estimPrAmt = r._2
765 769                          let amBalance = getAccBalance(amId)
766 770                          let prBalance = getAccBalance(prId)
767 -                         let $t03027530735 = if ((outAssetId == amId))
771 +                         let $t03036430824 = if ((outAssetId == amId))
768 772                              then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), exchResult, estimPrAmt, 0, 0, (estimAmAmt + exchResult))
769 773                              else if ((outAssetId == prId))
770 774                                  then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, exchResult, estimAmAmt, (estimPrAmt + exchResult))
771 775                                  else throw("wrong outAssetId")
772 -                         let amBalanceNow = $t03027530735._1
773 -                         let prBalanceNow = $t03027530735._2
774 -                         let virtSwapInAm = $t03027530735._3
775 -                         let virtSwapOutPr = $t03027530735._4
776 -                         let virtSwapInPr = $t03027530735._5
777 -                         let virtSwapOutAm = $t03027530735._6
778 -                         let totalGetRaw = $t03027530735._7
776 +                         let amBalanceNow = $t03036430824._1
777 +                         let prBalanceNow = $t03036430824._2
778 +                         let virtSwapInAm = $t03036430824._3
779 +                         let virtSwapOutPr = $t03036430824._4
780 +                         let virtSwapInPr = $t03036430824._5
781 +                         let virtSwapOutAm = $t03036430824._6
782 +                         let totalGetRaw = $t03036430824._7
779 783                          if (if ((0 > virtSwapInAm))
780 784                              then true
781 785                              else (0 > virtSwapInPr))
782 786                              then throw("Wrong calc")
783 787                              else {
784 788                                  let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
785 789                                  let D1 = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
786 790                                  let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
787 791                                  if ((D0vsD1 == D0vsD1))
788 792                                      then {
789 793                                          let totalGet = takeFee(totalGetRaw)._1
790 794                                          let finalRes = vad(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
791 795                                          if ((finalRes == finalRes))
792 796                                              then {
793 -                                                 let $t03148231586 = if ((outAssetId == amId))
797 +                                                 let $t03157131675 = if ((outAssetId == amId))
794 798                                                      then $Tuple2(toInt(finalRes._2), 0)
795 799                                                      else $Tuple2(0, toInt(finalRes._2))
796 -                                                 let outAm = $t03148231586._1
797 -                                                 let outPr = $t03148231586._2
800 +                                                 let outAm = $t03157131675._1
801 +                                                 let outPr = $t03157131675._2
798 802                                                  let totalAmount = (outAm + outPr)
799 803                                                  let feeAmount = (totalGetRaw - totalGet)
800 804                                                  let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
801 805                                                      then unit
802 806                                                      else fromBase58String(outAssetId)
803 807                                                  let sendFeeToMatcher = if ((feeAmount > 0))
804 808                                                      then [ScriptTransfer(matcherAddress, feeAmount, outAssetIdOrWaves)]
805 809                                                      else nil
806 810                                                  let curPrX18 = cpbi(t1(prBalance, prDcm), t1(amBalance, amDcm))
807 811                                                  let curPr = f1(curPrX18, scale8)
808 812                                                  let state = [ScriptTransfer(userAddress, totalAmount, outAssetIdOrWaves), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)]
809 813                                                  if ((state == state))
810 814                                                      then {
811 815                                                          let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
812 816                                                          if ((burn == burn))
813 817                                                              then (state ++ sendFeeToMatcher)
814 818                                                              else throw("Strict value is not equal to itself.")
815 819                                                          }
816 820                                                      else throw("Strict value is not equal to itself.")
817 821                                                  }
818 822                                              else throw("Strict value is not equal to itself.")
819 823                                          }
820 824                                      else throw("Strict value is not equal to itself.")
821 825                                  }
822 826                          }
823 827          }
824 828  
825 829  
826 830  
827 831  @Callable(i)
828 832  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
829 833      let r = cg(i)
830 834      let outAmAmt = r._1
831 835      let outPrAmt = r._2
832 836      let pmtAmt = r._3
833 837      let pmtAssetId = r._4
834 838      let state = r._5
835 839      if ((noLessThenAmtAsset > outAmAmt))
836 840          then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
837 841          else if ((noLessThenPriceAsset > outPrAmt))
838 842              then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
839 843              else {
840 844                  let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
841 845                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
842 846                      then state
843 847                      else throw("Strict value is not equal to itself.")
844 848                  }
845 849      }
846 850  
847 851  
848 852  
849 853  @Callable(i)
850 854  func unstakeAndGet (amount) = {
851 855      let checkPayments = if ((size(i.payments) != 0))
852 856          then throw("No pmnts expd")
853 857          else true
854 858      if ((checkPayments == checkPayments))
855 859          then {
856 860              let cfg = gpc()
857 861              let factoryCfg = gfc()
858 862              let lpAssetId = fromBase58String(cfg[idxLPAsId])
859 863              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
860 864              let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
861 865              if ((unstakeInv == unstakeInv))
862 866                  then {
863 867                      let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
864 868                      let sts = parseIntValue(r._9)
865 869                      let state = r._10
866 870                      let v = if (if (igs())
867 871                          then true
868 872                          else (sts == PoolShutdown))
869 873                          then throw(("Blocked: " + toString(sts)))
870 874                          else true
871 875                      if ((v == v))
872 876                          then {
873 877                              let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
874 878                              if ((burnA == burnA))
875 879                                  then state
876 880                                  else throw("Strict value is not equal to itself.")
877 881                              }
878 882                          else throw("Strict value is not equal to itself.")
879 883                      }
880 884                  else throw("Strict value is not equal to itself.")
881 885              }
882 886          else throw("Strict value is not equal to itself.")
883 887      }
884 888  
885 889  
886 890  
887 891  @Callable(i)
888 892  func activate (amtAsStr,prAsStr) = if ((toString(i.caller) != toString(fca)))
889 893      then throw("denied")
890 894      else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr)], "success")
891 895  
892 896  
893 897  
894 898  @Callable(i)
895 899  func setS (k,v) = if ((toString(i.caller) != strf(this, ada())))
896 900      then pd
897 901      else [StringEntry(k, v)]
898 902  
899 903  
900 904  
901 905  @Callable(i)
902 906  func setI (k,v) = if ((toString(i.caller) != strf(this, ada())))
903 907      then pd
904 908      else [IntegerEntry(k, v)]
905 909  
906 910  
907 911  
908 912  @Callable(i)
909 913  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, gpc())
910 914  
911 915  
912 916  
913 917  @Callable(i)
914 918  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
915 919  
916 920  
917 921  
918 922  @Callable(i)
919 923  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
920 924      let pr = calcPrices(amAmt, prAmt, lpAmt)
921 925      $Tuple2(nil, [toString(pr[0]), toString(pr[1]), toString(pr[2])])
922 926      }
923 927  
924 928  
925 929  
926 930  @Callable(i)
927 931  func fromX18WrapperREADONLY (val,resScaleMult) = $Tuple2(nil, f1(parseBigIntValue(val), resScaleMult))
928 932  
929 933  
930 934  
931 935  @Callable(i)
932 936  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(t1(origVal, origScaleMult)))
933 937  
934 938  
935 939  
936 940  @Callable(i)
937 941  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(cpbi(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
938 942  
939 943  
940 944  
941 945  @Callable(i)
942 946  func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,usrAddr,isEval,emitLp) = $Tuple2(nil, epo(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, usrAddr, isEval, emitLp, false, 0, ""))
943 947  
944 948  
945 949  
946 950  @Callable(i)
947 951  func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
948 952      let r = ego(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
949 953      $Tuple2(nil, $Tuple10(r._1, r._2, r._3, r._4, r._5, r._6, r._7, toString(r._8), r._9, r._10))
950 954      }
951 955  
952 956  
953 957  @Verifier(tx)
954 958  func verify () = {
955 959      let targetPublicKey =     match m() {
956 960          case pk: ByteVector => 
957 961              pk
958 962          case _: Unit => 
959 963              tx.senderPublicKey
960 964          case _ => 
961 965              throw("Match error")
962 966      }
963 967      match tx {
964 968          case order: Order => 
965 969              let matcherPub = mp()
966 970              let orderValid = moa(order)
967 971              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
968 972              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
969 973              if (if (if (orderValid)
970 974                  then senderValid
971 975                  else false)
972 976                  then matcherValid
973 977                  else false)
974 978                  then true
975 979                  else toe(orderValid, senderValid, matcherValid)
976 980          case s: SetScriptTransaction => 
977 981              let newHash = blake2b256(value(s.script))
978 982              let allowedHash = fromBase64String(value(getString(fca, keyAllowedLpStableScriptHash())))
979 983              let currentHash = scriptHash(this)
980 984              if (if ((allowedHash == newHash))
981 985                  then (currentHash != newHash)
982 986                  else false)
983 987                  then true
984 988                  else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
985 989          case _ => 
986 990              sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
987 991      }
988 992      }
989 993

Old	New		Differences
639	639		let virtSwapOutAm = $t02476125337._6
640	640		let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
641	641		let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
642		-	let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
643		-	if ((D0vsD1 == D0vsD1))
644		-	then {
645		-	let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
646		-	let estimLP = estPut._2
647		-	let lpAssetId = estPut._7
648		-	let state = estPut._9
649		-	let amDiff = estPut._10
650		-	let prDiff = estPut._11
651		-	let lpCalcRes = vad(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
652		-	let emitLpAmt = toInt(lpCalcRes._2)
653		-	let e = invoke(fca, "emit", [emitLpAmt], nil)
654		-	if ((e == e))
	642	+	if (true)
	643	+	then throw(((toString(amBalanceNow) + ", ") + toString(prBalanceNow)))
	644	+	else {
	645	+	let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
	646	+	if ((D0vsD1 == D0vsD1))
655	647		then {
656		-	let el = match e {
657		-	case legacy: Address =>
658		-	invoke(legacy, "emit", [emitLpAmt], nil)
659		-	case _ =>
660		-	unit
661		-	}
662		-	if ((el == el))
	648	+	let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
	649	+	let estimLP = estPut._2
	650	+	let lpAssetId = estPut._7
	651	+	let state = estPut._9
	652	+	let amDiff = estPut._10
	653	+	let prDiff = estPut._11
	654	+	let lpCalcRes = vad(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
	655	+	let emitLpAmt = toInt(lpCalcRes._2)
	656	+	let e = invoke(fca, "emit", [emitLpAmt], nil)
	657	+	if ((e == e))
663	658		then {
664		-	let sa = if ((amDiff > 0))
665		-	then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
666		-	else nil
667		-	if ((sa == sa))
	659	+	let el = match e {
	660	+	case legacy: Address =>
	661	+	invoke(legacy, "emit", [emitLpAmt], nil)
	662	+	case _ =>
	663	+	unit
	664	+	}
	665	+	if ((el == el))
668	666		then {
669		-	let sp = if ((~~prDiff~~ > 0))
670		-	then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(~~prId~~), ~~prDiff~~)])
	667	+	let sa = if ((amDiff > 0))
	668	+	then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
671	669		else nil
672		-	if ((sp == sp))
	670	+	if ((sa == sa))
673	671		then {
674		-	let lpTrnsfr = if (autoStake)
	672	+	let sp = if ((prDiff > 0))
	673	+	then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
	674	+	else nil
	675	+	if ((sp == sp))
675	676		then {
676		-	let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
677		-	if ((ss == ss))
678		-	then nil
679		-	else throw("Strict value is not equal to itself.")
	677	+	let lpTrnsfr = if (autoStake)
	678	+	then {
	679	+	let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
	680	+	if ((ss == ss))
	681	+	then nil
	682	+	else throw("Strict value is not equal to itself.")
	683	+	}
	684	+	else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
	685	+	let sendFeeToMatcher = if ((feeAmount > 0))
	686	+	then [ScriptTransfer(matcherAddress, feeAmount, fromBase58String(pmtAssetId))]
	687	+	else nil
	688	+	((state ++ lpTrnsfr) ++ sendFeeToMatcher)
680	689		}
681		-	else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
682		-	let sendFeeToMatcher = if ((feeAmount > 0))
683		-	then [ScriptTransfer(matcherAddress, feeAmount, fromBase58String(pmtAssetId))]
684		-	else nil
685		-	((state ++ lpTrnsfr) ++ sendFeeToMatcher)
	690	+	else throw("Strict value is not equal to itself.")
686	691		}
687	692		else throw("Strict value is not equal to itself.")
688	693		}

692	697		}
693	698		else throw("Strict value is not equal to itself.")
694	699		}
695		-	else throw("Strict value is not equal to itself.")
696	700		}
697	701		}
698	702		}

764	768		let estimPrAmt = r._2
765	769		let amBalance = getAccBalance(amId)
766	770		let prBalance = getAccBalance(prId)
767		-	let $~~t03027530735~~ = if ((outAssetId == amId))
	771	+	let $t03036430824 = if ((outAssetId == amId))
768	772		then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), exchResult, estimPrAmt, 0, 0, (estimAmAmt + exchResult))
769	773		else if ((outAssetId == prId))
770	774		then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, exchResult, estimAmAmt, (estimPrAmt + exchResult))
771	775		else throw("wrong outAssetId")
772		-	let amBalanceNow = $~~t03027530735~~._1
773		-	let prBalanceNow = $~~t03027530735~~._2
774		-	let virtSwapInAm = $~~t03027530735~~._3
775		-	let virtSwapOutPr = $~~t03027530735~~._4
776		-	let virtSwapInPr = $~~t03027530735~~._5
777		-	let virtSwapOutAm = $~~t03027530735~~._6
778		-	let totalGetRaw = $~~t03027530735~~._7
	776	+	let amBalanceNow = $t03036430824._1
	777	+	let prBalanceNow = $t03036430824._2
	778	+	let virtSwapInAm = $t03036430824._3
	779	+	let virtSwapOutPr = $t03036430824._4
	780	+	let virtSwapInPr = $t03036430824._5
	781	+	let virtSwapOutAm = $t03036430824._6
	782	+	let totalGetRaw = $t03036430824._7
779	783		if (if ((0 > virtSwapInAm))
780	784		then true
781	785		else (0 > virtSwapInPr))

790	794		let finalRes = vad(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
791	795		if ((finalRes == finalRes))
792	796		then {
793		-	let $~~t03148231586~~ = if ((outAssetId == amId))
	797	+	let $t03157131675 = if ((outAssetId == amId))
794	798		then $Tuple2(toInt(finalRes._2), 0)
795	799		else $Tuple2(0, toInt(finalRes._2))
796		-	let outAm = $~~t03148231586~~._1
797		-	let outPr = $~~t03148231586~~._2
	800	+	let outAm = $t03157131675._1
	801	+	let outPr = $t03157131675._2
798	802		let totalAmount = (outAm + outPr)
799	803		let feeAmount = (totalGetRaw - totalGet)
800	804		let outAssetIdOrWaves = if ((outAssetId == "WAVES"))

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

github/deemru/w8io/c3f4982 
125.59 ms ◑