w8 · tx · CGd···oTJ

tx · CGdQ82uwzGp6NgqSQzQzQKaUiTPMpSk9PmRfrFkBPoTJ

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.01400000 Waves

2021.12.27 22:40 [1853088] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CGdQ82uwzGp6NgqSQzQzQKaUiTPMpSk9PmRfrFkBPoTJ",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1640634039545,
    "version": 1,
    "sender": "3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT",
    "senderPublicKey": "D1BL65meykxFZTCuq7jq9HSGLLnWvQamQPUNrguW5w39",
    "proofs": [
        "5f8fgBjdyNqAqrENFumx7nmA98btaqSx8t5GYx43CpZJHqscNH4qqGvU4KmFjGQkpae1P9s5QRxBK3aEThkeikpz"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1853088,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: HHeuM2zhjjZfidLv6CVqg3kfzAaPBmNhia4jUGVJVnAi
Next: 47H95UycXv3LoHGhRuebiSvJFFTgpZ3DYdbjc1TWW83V

Diff: 
Old New Differences
321 321                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
322 322              let writeAmAmt = $t01564815994._1
323 323              let writePrAmt = $t01564815994._2
324 -             let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
324 +             let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
325 325              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
326 326              }
327 327      }
489 489                  let pmtAmt = pmt.amount
490 490                  let amBalance = getAccBalance(amId)
491 491                  let prBalance = getAccBalance(prId)
492 -                 let $t02367624056 = if ((pmtAssetId == amId))
492 +                 let $t02366724047 = if ((pmtAssetId == amId))
493 493                      then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
494 494                      else if ((pmtAssetId == prId))
495 495                          then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
496 496                          else throw("wrong pmtAssetId")
497 -                 let amBalanceNow = $t02367624056._1
498 -                 let prBalanceNow = $t02367624056._2
499 -                 let virtSwapInAm = $t02367624056._3
500 -                 let virtSwapOutPr = $t02367624056._4
501 -                 let virtSwapInPr = $t02367624056._5
502 -                 let virtSwapOutAm = $t02367624056._6
497 +                 let amBalanceNow = $t02366724047._1
498 +                 let prBalanceNow = $t02366724047._2
499 +                 let virtSwapInAm = $t02366724047._3
500 +                 let virtSwapOutPr = $t02366724047._4
501 +                 let virtSwapInPr = $t02366724047._5
502 +                 let virtSwapOutAm = $t02366724047._6
503 503                  let dCur = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
504 504                  let dNew = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
505 505                  let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(dNew)), parseBigIntValue(asString(dCur)), toBigInt(1000))
618 618                              let estimPrAmt = r._2
619 619                              let amBalance = getAccBalance(amId)
620 620                              let prBalance = getAccBalance(prId)
621 -                             let $t02866329147 = if ((outAssetId == amId))
621 +                             let $t02865429138 = if ((outAssetId == amId))
622 622                                  then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), (outAmount - estimAmAmt), prAssetSwap, 0, 0, (estimAmAmt + amAssetSwap))
623 623                                  else if ((outAssetId == prId))
624 624                                      then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, (outAmount - estimPrAmt), amAssetSwap, (estimPrAmt + prAssetSwap))
625 625                                      else throw("wrong outAssetId")
626 -                             let amBalanceNow = $t02866329147._1
627 -                             let prBalanceNow = $t02866329147._2
628 -                             let virtSwapInAm = $t02866329147._3
629 -                             let virtSwapOutPr = $t02866329147._4
630 -                             let virtSwapInPr = $t02866329147._5
631 -                             let virtSwapOutAm = $t02866329147._6
632 -                             let totalGet = $t02866329147._7
626 +                             let amBalanceNow = $t02865429138._1
627 +                             let prBalanceNow = $t02865429138._2
628 +                             let virtSwapInAm = $t02865429138._3
629 +                             let virtSwapOutPr = $t02865429138._4
630 +                             let virtSwapInPr = $t02865429138._5
631 +                             let virtSwapOutAm = $t02865429138._6
632 +                             let totalGet = $t02865429138._7
633 633                              let invLeft = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
634 634                              let invRight = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
635 635                              let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 5 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let scale8 = 100000000
5 5  
6 6  let scale8BigInt = toBigInt(100000000)
7 7  
8 8  let scale18 = toBigInt(1000000000000000000)
9 9  
10 10  let zeroBigInt = toBigInt(0)
11 11  
12 12  let oneBigInt = toBigInt(1)
13 13  
14 14  let Amult = "100000000"
15 15  
16 16  let Dconv = "1"
17 17  
18 18  let SEP = "__"
19 19  
20 20  let EMPTY = ""
21 21  
22 22  let PoolActive = 1
23 23  
24 24  let PoolPutDis = 2
25 25  
26 26  let PoolMatcherDis = 3
27 27  
28 28  let PoolShutdown = 4
29 29  
30 30  let idxPoolAddress = 1
31 31  
32 32  let idxPoolSt = 2
33 33  
34 34  let idxLPAsId = 3
35 35  
36 36  let idxAmAsId = 4
37 37  
38 38  let idxPrAsId = 5
39 39  
40 40  let idxAmtAsDcm = 6
41 41  
42 42  let idxPriceAsDcm = 7
43 43  
44 44  let idxIAmtAsId = 8
45 45  
46 46  let idxIPriceAsId = 9
47 47  
48 48  let idxFactStakCntr = 1
49 49  
50 50  let idxFactSlippCntr = 7
51 51  
52 52  let idxFactGwxRewCntr = 10
53 53  
54 54  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
55 55  
56 56  
57 57  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
58 58  
59 59  
60 60  func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
61 61  
62 62  
63 63  func abs (val) = if ((zeroBigInt > val))
64 64      then -(val)
65 65      else val
66 66  
67 67  
68 68  func keyFactCntr () = "%s__factoryContract"
69 69  
70 70  
71 71  func keyManPubKey () = "%s__managerPublicKey"
72 72  
73 73  
74 74  func keyPriceLast () = "%s%s__price__last"
75 75  
76 76  
77 77  func keyPriceHistory (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
78 78  
79 79  
80 80  func keyPutActionByUser (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
81 81  
82 82  
83 83  func keyGetActionByUser (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
84 84  
85 85  
86 86  func keyAmtAsset () = "%s__amountAsset"
87 87  
88 88  
89 89  func keyPriceAsset () = "%s__priceAsset"
90 90  
91 91  
92 92  func keyAmplificator () = "%s__amp"
93 93  
94 94  
95 95  func keyFactoryConfig () = "%s__factoryConfig"
96 96  
97 97  
98 98  func keyMatcherPub () = "%s%s__matcher__publicKey"
99 99  
100 100  
101 101  func keyPoolConfig (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
102 102  
103 103  
104 104  func keyMappingsBaseAsset2internalId (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
105 105  
106 106  
107 107  func keyAllPoolsShutdown () = "%s__shutdown"
108 108  
109 109  
110 110  func keyPoolWeight (p) = ("%s%s__poolWeight__" + p)
111 111  
112 112  
113 113  func throwOrderError (orV,sendrV,matchV) = throw(((((("Failed: orderValid=" + toString(orV)) + " senderValid=") + toString(sendrV)) + " matcherValid=") + toString(matchV)))
114 114  
115 115  
116 116  func asString (val) = match val {
117 117      case valStr: String => 
118 118          valStr
119 119      case _ => 
120 120          throw("fail cast to String")
121 121  }
122 122  
123 123  
124 124  func getStringOrFail (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
125 125  
126 126  
127 127  func getIntOrFail (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
128 128  
129 129  
130 130  let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactCntr()))
131 131  
132 132  let A = getStringOrFail(this, keyAmplificator())
133 133  
134 134  func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
135 135  
136 136  
137 137  func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
138 138  
139 139  
140 140  func getPoolConfig () = {
141 141      let amtAs = getStringOrFail(this, keyAmtAsset())
142 142      let priceAs = getStringOrFail(this, keyPriceAsset())
143 143      let iPriceAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAs))
144 144      let iAmtAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAs))
145 145      split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAs), toString(iPriceAs))), SEP)
146 146      }
147 147  
148 148  
149 149  func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
150 150  
151 151  
152 152  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)
153 153  
154 154  
155 155  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)
156 156  
157 157  
158 158  func getAccBalance (assetId) = if ((assetId == "WAVES"))
159 159      then wavesBalance(this).available
160 160      else assetBalance(this, fromBase58String(assetId))
161 161  
162 162  
163 163  func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
164 164  
165 165  
166 166  func validateAbsDiff (realAmt,expectedAmt,slippage) = {
167 167      let diff = fraction((realAmt - expectedAmt), scale8BigInt, expectedAmt)
168 168      let passed = ((slippage - abs(diff)) > zeroBigInt)
169 169      if (!(passed))
170 170          then throw(((("Too big slippage: " + toString(diff)) + " vs ") + toString(slippage)))
171 171          else $Tuple2(passed, min([realAmt, expectedAmt]))
172 172      }
173 173  
174 174  
175 175  func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
176 176      let amtAsAmtX18 = toX18(amAmt, amAssetDcm)
177 177      let prAsAmtX18 = toX18(prAmt, prAssetDcm)
178 178      calcPriceBigInt(prAsAmtX18, amtAsAmtX18)
179 179      }
180 180  
181 181  
182 182  func calcPrices (amAmt,prAmt,lpAmt) = {
183 183      let cfg = getPoolConfig()
184 184      let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
185 185      let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
186 186      let priceX18 = privateCalcPrice(amtAsDcm, prAsDcm, amAmt, prAmt)
187 187      let amAmtX18 = toX18(amAmt, amtAsDcm)
188 188      let prAmtX18 = toX18(prAmt, prAsDcm)
189 189      let lpAmtX18 = toX18(lpAmt, scale8)
190 190      let lpPrInAmAsX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
191 191      let lpPrInPrAsX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
192 192  [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
193 193      }
194 194  
195 195  
196 196  func calculatePrices (amAmt,prAmt,lpAmt) = {
197 197      let prices = calcPrices(amAmt, prAmt, lpAmt)
198 198  [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
199 199      }
200 200  
201 201  
202 202  func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
203 203      let cfg = getPoolConfig()
204 204      let lpId = cfg[idxLPAsId]
205 205      let amId = cfg[idxAmAsId]
206 206      let prId = cfg[idxPrAsId]
207 207      let amDcm = parseIntValue(cfg[idxAmtAsDcm])
208 208      let prDcm = parseIntValue(cfg[idxPriceAsDcm])
209 209      let poolStatus = cfg[idxPoolSt]
210 210      let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Invalid LP id").quantity
211 211      if ((lpId != pmtAssetId))
212 212          then throw("Invalid pmt asset")
213 213          else {
214 214              let amBalance = getAccBalance(amId)
215 215              let amBalanceX18 = toX18(amBalance, amDcm)
216 216              let prBalance = getAccBalance(prId)
217 217              let prBalanceX18 = toX18(prBalance, prDcm)
218 218              let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
219 219              let curPrice = fromX18(curPriceX18, scale8)
220 220              let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
221 221              let lpEmissionX18 = toX18(lpEmission, scale8)
222 222              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
223 223              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
224 224              let outAmAmt = fromX18(outAmAmtX18, amDcm)
225 225              let outPrAmt = fromX18(outPrAmtX18, prDcm)
226 226              let state = if ((txId58 == ""))
227 227                  then nil
228 228                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
229 229                      then unit
230 230                      else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
231 231                      then unit
232 232                      else fromBase58String(prId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
233 233              $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
234 234              }
235 235      }
236 236  
237 237  
238 238  func estimatePutOperation (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,pmtAmt,pmtId) = {
239 239      let cfg = getPoolConfig()
240 240      let lpId = fromBase58String(cfg[idxLPAsId])
241 241      let amIdStr = cfg[idxAmAsId]
242 242      let prIdStr = cfg[idxPrAsId]
243 243      let inAmIdStr = cfg[idxIAmtAsId]
244 244      let inPrIdStr = cfg[idxIPriceAsId]
245 245      let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
246 246      let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
247 247      let poolStatus = cfg[idxPoolSt]
248 248      let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
249 249      let amBalance = if (isEval)
250 250          then getAccBalance(amIdStr)
251 251          else if (if (isOneAsset)
252 252              then (pmtId == amIdStr)
253 253              else false)
254 254              then (getAccBalance(amIdStr) - pmtAmt)
255 255              else if (isOneAsset)
256 256                  then getAccBalance(amIdStr)
257 257                  else (getAccBalance(amIdStr) - inAmAmt)
258 258      let prBalance = if (isEval)
259 259          then getAccBalance(prIdStr)
260 260          else if (if (isOneAsset)
261 261              then (pmtId == prIdStr)
262 262              else false)
263 263              then (getAccBalance(prIdStr) - pmtAmt)
264 264              else if (isOneAsset)
265 265                  then getAccBalance(prIdStr)
266 266                  else (getAccBalance(prIdStr) - inPrAmt)
267 267      let inAmAssetAmtX18 = toX18(inAmAmt, amtDcm)
268 268      let inPrAssetAmtX18 = toX18(inPrAmt, priceDcm)
269 269      let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
270 270      let amBalanceX18 = toX18(amBalance, amtDcm)
271 271      let prBalanceX18 = toX18(prBalance, priceDcm)
272 272      let res = if ((lpEm == 0))
273 273          then {
274 274              let curPriceX18 = zeroBigInt
275 275              let slippageX18 = zeroBigInt
276 276              let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
277 277              $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtDcm), fromX18(inPrAssetAmtX18, priceDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
278 278              }
279 279          else {
280 280              let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
281 281              let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
282 282              let slippageX18 = toX18(slippage, scale8)
283 283              if (if ((curPriceX18 != zeroBigInt))
284 284                  then (slippageRealX18 > slippageX18)
285 285                  else false)
286 286                  then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
287 287                  else {
288 288                      let lpEmissionX18 = toX18(lpEm, scale8)
289 289                      let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
290 290                      let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
291 291                      let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
292 292                          then $Tuple2(amViaPrX18, inPrAssetAmtX18)
293 293                          else $Tuple2(inAmAssetAmtX18, prViaAmX18)
294 294                      let expAmtAssetAmtX18 = expectedAmts._1
295 295                      let expPriceAssetAmtX18 = expectedAmts._2
296 296                      let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
297 297                      $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtDcm), fromX18(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
298 298                      }
299 299              }
300 300      let calcLpAmt = res._1
301 301      let calcAmAssetPmt = res._2
302 302      let calcPrAssetPmt = res._3
303 303      let curPrice = fromX18(res._4, scale8)
304 304      let slippageCalc = fromX18(res._5, scale8)
305 305      if ((0 >= calcLpAmt))
306 306          then throw("LP <= 0")
307 307          else {
308 308              let emitLpAmt = if (!(emitLp))
309 309                  then 0
310 310                  else calcLpAmt
311 311              let amDiff = (inAmAmt - calcAmAssetPmt)
312 312              let prDiff = (inPrAmt - calcPrAssetPmt)
313 313              let $t01564815994 = if (if (isOneAsset)
314 314                  then (pmtId == amIdStr)
315 315                  else false)
316 316                  then $Tuple2(pmtAmt, 0)
317 317                  else if (if (isOneAsset)
318 318                      then (pmtId == prIdStr)
319 319                      else false)
320 320                      then $Tuple2(0, pmtAmt)
321 321                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
322 322              let writeAmAmt = $t01564815994._1
323 323              let writePrAmt = $t01564815994._2
324 -             let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
324 +             let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
325 325              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
326 326              }
327 327      }
328 328  
329 329  
330 330  func validateMatcherOrderAllowed (order) = {
331 331      let cfg = getPoolConfig()
332 332      let amtAsId = cfg[idxAmAsId]
333 333      let prAsId = cfg[idxPrAsId]
334 334      let poolStatus = parseIntValue(cfg[idxPoolSt])
335 335      let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
336 336      let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
337 337      let accAmtAsBalance = getAccBalance(amtAsId)
338 338      let accPrAsBalance = getAccBalance(prAsId)
339 339      let curPriceX18 = if ((order.orderType == Buy))
340 340          then privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
341 341          else privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
342 342      let curPrice = fromX18(curPriceX18, scale8)
343 343      if (if (if (isGlobalShutdown())
344 344          then true
345 345          else (poolStatus == PoolMatcherDis))
346 346          then true
347 347          else (poolStatus == PoolShutdown))
348 348          then throw("Admin blocked")
349 349          else {
350 350              let orAmtAsset = order.assetPair.amountAsset
351 351              let orAmtAsStr = if ((orAmtAsset == unit))
352 352                  then "WAVES"
353 353                  else toBase58String(value(orAmtAsset))
354 354              let orPrAsset = order.assetPair.priceAsset
355 355              let orPrAsStr = if ((orPrAsset == unit))
356 356                  then "WAVES"
357 357                  else toBase58String(value(orPrAsset))
358 358              if (if ((orAmtAsStr != amtAsId))
359 359                  then true
360 360                  else (orPrAsStr != prAsId))
361 361                  then throw("Wr assets")
362 362                  else {
363 363                      let orderPrice = order.price
364 364                      let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
365 365                      let castOrderPrice = toScale(orderPrice, scale8, priceDcm)
366 366                      let isOrderPriceValid = if ((order.orderType == Buy))
367 367                          then (curPrice >= castOrderPrice)
368 368                          else (castOrderPrice >= curPrice)
369 369                      true
370 370                      }
371 371              }
372 372      }
373 373  
374 374  
375 375  func commonGet (i) = if ((size(i.payments) != 1))
376 376      then throw("1 pmnt exp")
377 377      else {
378 378          let pmt = value(i.payments[0])
379 379          let pmtAssetId = value(pmt.assetId)
380 380          let pmtAmt = pmt.amount
381 381          let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
382 382          let outAmAmt = res._1
383 383          let outPrAmt = res._2
384 384          let poolStatus = parseIntValue(res._9)
385 385          let state = res._10
386 386          if (if (isGlobalShutdown())
387 387              then true
388 388              else (poolStatus == PoolShutdown))
389 389              then throw(("Admin blocked: " + toString(poolStatus)))
390 390              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
391 391          }
392 392  
393 393  
394 394  func commonPut (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,pmtAmt,pmtId) = {
395 395      let r = estimatePutOperation(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp, isOneAsset, pmtAmt, pmtId)
396 396      let status = parseIntValue(r._8)
397 397      if (if (if (isGlobalShutdown())
398 398          then true
399 399          else (status == PoolPutDis))
400 400          then true
401 401          else (status == PoolShutdown))
402 402          then throw(("Admin blocked: " + toString(status)))
403 403          else r
404 404      }
405 405  
406 406  
407 407  @Callable(i)
408 408  func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
409 409      then throw("denied")
410 410      else [StringEntry(keyFactCntr(), factoryContract), StringEntry(keyManPubKey(), managerPublicKey)]
411 411  
412 412  
413 413  
414 414  @Callable(i)
415 415  func put (slip,autoStake) = {
416 416      let factCfg = getFactoryConfig()
417 417      let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
418 418      let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
419 419      if ((0 > slip))
420 420          then throw("Invalid slippage")
421 421          else if ((size(i.payments) != 2))
422 422              then throw("2 pmnts expected")
423 423              else {
424 424                  let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, 0, "")
425 425                  let emitLpAmt = estPut._2
426 426                  let lpAssetId = estPut._7
427 427                  let state = estPut._9
428 428                  let amDiff = estPut._10
429 429                  let prDiff = estPut._11
430 430                  let amId = estPut._12
431 431                  let prId = estPut._13
432 432                  let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
433 433                  if ((emitInv == emitInv))
434 434                      then {
435 435                          let slippageAInv = if ((amDiff > 0))
436 436                              then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
437 437                              else nil
438 438                          if ((slippageAInv == slippageAInv))
439 439                              then {
440 440                                  let slippagePInv = if ((prDiff > 0))
441 441                                      then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
442 442                                      else nil
443 443                                  if ((slippagePInv == slippagePInv))
444 444                                      then {
445 445                                          let lpTrnsfr = if (autoStake)
446 446                                              then {
447 447                                                  let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
448 448                                                  if ((slpStakeInv == slpStakeInv))
449 449                                                      then nil
450 450                                                      else throw("Strict value is not equal to itself.")
451 451                                                  }
452 452                                              else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
453 453                                          (state ++ lpTrnsfr)
454 454                                          }
455 455                                      else throw("Strict value is not equal to itself.")
456 456                                  }
457 457                              else throw("Strict value is not equal to itself.")
458 458                          }
459 459                      else throw("Strict value is not equal to itself.")
460 460                  }
461 461      }
462 462  
463 463  
464 464  
465 465  @Callable(i)
466 466  func putOneTkn (amAssetPart,prAssetPart,outLp,slippage,autoStake) = {
467 467      let cfg = getFactoryConfig()
468 468      let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
469 469      let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
470 470      let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
471 471      let poolCfg = getPoolConfig()
472 472      let amId = poolCfg[idxAmAsId]
473 473      let prId = poolCfg[idxPrAsId]
474 474      let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
475 475      let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
476 476      if (if (if (if ((0 >= slippage))
477 477          then true
478 478          else (0 >= amAssetPart))
479 479          then true
480 480          else (0 >= prAssetPart))
481 481          then true
482 482          else (0 >= outLp))
483 483          then throw("Wrong params")
484 484          else if ((size(i.payments) != 1))
485 485              then throw("1 pmnt expected")
486 486              else {
487 487                  let pmt = value(i.payments[0])
488 488                  let pmtAssetId = toBase58String(value(pmt.assetId))
489 489                  let pmtAmt = pmt.amount
490 490                  let amBalance = getAccBalance(amId)
491 491                  let prBalance = getAccBalance(prId)
492 -                 let $t02367624056 = if ((pmtAssetId == amId))
492 +                 let $t02366724047 = if ((pmtAssetId == amId))
493 493                      then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
494 494                      else if ((pmtAssetId == prId))
495 495                          then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
496 496                          else throw("wrong pmtAssetId")
497 -                 let amBalanceNow = $t02367624056._1
498 -                 let prBalanceNow = $t02367624056._2
499 -                 let virtSwapInAm = $t02367624056._3
500 -                 let virtSwapOutPr = $t02367624056._4
501 -                 let virtSwapInPr = $t02367624056._5
502 -                 let virtSwapOutAm = $t02367624056._6
497 +                 let amBalanceNow = $t02366724047._1
498 +                 let prBalanceNow = $t02366724047._2
499 +                 let virtSwapInAm = $t02366724047._3
500 +                 let virtSwapOutPr = $t02366724047._4
501 +                 let virtSwapInPr = $t02366724047._5
502 +                 let virtSwapOutAm = $t02366724047._6
503 503                  let dCur = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
504 504                  let dNew = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
505 505                  let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(dNew)), parseBigIntValue(asString(dCur)), toBigInt(1000))
506 506                  if ((D0vsD1 == D0vsD1))
507 507                      then {
508 508                          let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), 50000000000, true, true, pmtAmt, pmtAssetId)
509 509                          let estimLP = estPut._2
510 510                          let lpAssetId = estPut._7
511 511                          let state = estPut._9
512 512                          let amDiff = estPut._10
513 513                          let prDiff = estPut._11
514 514                          let lpCalcRes = validateAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
515 515                          let emitLpAmt = toInt(lpCalcRes._2)
516 516                          let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
517 517                          if ((emitInv == emitInv))
518 518                              then {
519 519                                  let slippageAInv = if ((amDiff > 0))
520 520                                      then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
521 521                                      else nil
522 522                                  if ((slippageAInv == slippageAInv))
523 523                                      then {
524 524                                          let slippagePInv = if ((prDiff > 0))
525 525                                              then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
526 526                                              else nil
527 527                                          if ((slippagePInv == slippagePInv))
528 528                                              then {
529 529                                                  let lpTrnsfr = if (autoStake)
530 530                                                      then {
531 531                                                          let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
532 532                                                          if ((slpStakeInv == slpStakeInv))
533 533                                                              then nil
534 534                                                              else throw("Strict value is not equal to itself.")
535 535                                                          }
536 536                                                      else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
537 537                                                  (state ++ lpTrnsfr)
538 538                                                  }
539 539                                              else throw("Strict value is not equal to itself.")
540 540                                          }
541 541                                      else throw("Strict value is not equal to itself.")
542 542                                  }
543 543                              else throw("Strict value is not equal to itself.")
544 544                          }
545 545                      else throw("Strict value is not equal to itself.")
546 546                  }
547 547      }
548 548  
549 549  
550 550  
551 551  @Callable(i)
552 552  func putForFree (maxSlippage) = if ((0 > maxSlippage))
553 553      then throw("Invalid slippage")
554 554      else if ((size(i.payments) != 2))
555 555          then throw("2 pmnts expected")
556 556          else {
557 557              let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlippage, false, false, 0, "")
558 558              estPut._9
559 559              }
560 560  
561 561  
562 562  
563 563  @Callable(i)
564 564  func get () = {
565 565      let res = commonGet(i)
566 566      let outAmtAmt = res._1
567 567      let outPrAmt = res._2
568 568      let pmtAmt = res._3
569 569      let pmtAssetId = res._4
570 570      let state = res._5
571 571      let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
572 572      if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
573 573          then state
574 574          else throw("Strict value is not equal to itself.")
575 575      }
576 576  
577 577  
578 578  
579 579  @Callable(i)
580 580  func getOneTkn (amAssetSwap,prAssetSwap,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
581 581      then throw("1 pmnt expected")
582 582      else {
583 583          let cfg = getPoolConfig()
584 584          let lpId = cfg[idxLPAsId]
585 585          let amId = cfg[idxAmAsId]
586 586          let prId = cfg[idxPrAsId]
587 587          let amDcm = parseIntValue(cfg[idxAmtAsDcm])
588 588          let prDcm = parseIntValue(cfg[idxPriceAsDcm])
589 589          let poolStatus = cfg[idxPoolSt]
590 590          let fcfg = getFactoryConfig()
591 591          let gwxCntr = valueOrErrorMessage(addressFromString(fcfg[idxFactGwxRewCntr]), "Wr sl addr")
592 592          if (if ((outAssetId != amId))
593 593              then (outAssetId != prId)
594 594              else false)
595 595              then throw("Wr out as")
596 596              else {
597 597                  let resultAssetId = if ((outAssetId == amId))
598 598                      then amId
599 599                      else prId
600 600                  let pmt = value(i.payments[0])
601 601                  let userAddress = i.caller
602 602                  let txId58 = toBase58String(i.transactionId)
603 603                  let pmtAssetId = value(pmt.assetId)
604 604                  let pmtAmt = pmt.amount
605 605                  if (if (if (if ((0 > slippage))
606 606                      then true
607 607                      else (0 > amAssetSwap))
608 608                      then true
609 609                      else (0 > prAssetSwap))
610 610                      then true
611 611                      else (0 > outAmount))
612 612                      then throw("Wrong params")
613 613                      else if ((lpId != toBase58String(pmtAssetId)))
614 614                          then throw("Invalid LP")
615 615                          else {
616 616                              let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
617 617                              let estimAmAmt = r._1
618 618                              let estimPrAmt = r._2
619 619                              let amBalance = getAccBalance(amId)
620 620                              let prBalance = getAccBalance(prId)
621 -                             let $t02866329147 = if ((outAssetId == amId))
621 +                             let $t02865429138 = if ((outAssetId == amId))
622 622                                  then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), (outAmount - estimAmAmt), prAssetSwap, 0, 0, (estimAmAmt + amAssetSwap))
623 623                                  else if ((outAssetId == prId))
624 624                                      then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, (outAmount - estimPrAmt), amAssetSwap, (estimPrAmt + prAssetSwap))
625 625                                      else throw("wrong outAssetId")
626 -                             let amBalanceNow = $t02866329147._1
627 -                             let prBalanceNow = $t02866329147._2
628 -                             let virtSwapInAm = $t02866329147._3
629 -                             let virtSwapOutPr = $t02866329147._4
630 -                             let virtSwapInPr = $t02866329147._5
631 -                             let virtSwapOutAm = $t02866329147._6
632 -                             let totalGet = $t02866329147._7
626 +                             let amBalanceNow = $t02865429138._1
627 +                             let prBalanceNow = $t02865429138._2
628 +                             let virtSwapInAm = $t02865429138._3
629 +                             let virtSwapOutPr = $t02865429138._4
630 +                             let virtSwapInPr = $t02865429138._5
631 +                             let virtSwapOutAm = $t02865429138._6
632 +                             let totalGet = $t02865429138._7
633 633                              let invLeft = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
634 634                              let invRight = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
635 635                              let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))
636 636                              if ((D0vsD1 == D0vsD1))
637 637                                  then {
638 638                                      let amount2Return = validateAbsDiff(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
639 639                                      if ((amount2Return == amount2Return))
640 640                                          then {
641 641                                              let resultTuple = if ((outAssetId == amId))
642 642                                                  then $Tuple2(toInt(amount2Return._2), 0)
643 643                                                  else $Tuple2(0, toInt(amount2Return._2))
644 644                                              let curPriceX18 = calcPriceBigInt(toX18(prBalance, prDcm), toX18(amBalance, amDcm))
645 645                                              let curPrice = fromX18(curPriceX18, scale8)
646 646                                              let state = [ScriptTransfer(userAddress, if ((resultAssetId == amId))
647 647                                                  then resultTuple._1
648 648                                                  else resultTuple._2, if ((resultAssetId == "WAVES"))
649 649                                                  then unit
650 650                                                  else fromBase58String(resultAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(resultTuple._1, resultTuple._2, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
651 651                                              if ((state == state))
652 652                                                  then {
653 653                                                      let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
654 654                                                      if ((burn == burn))
655 655                                                          then state
656 656                                                          else throw("Strict value is not equal to itself.")
657 657                                                      }
658 658                                                  else throw("Strict value is not equal to itself.")
659 659                                              }
660 660                                          else throw("Strict value is not equal to itself.")
661 661                                      }
662 662                                  else throw("Strict value is not equal to itself.")
663 663                              }
664 664                  }
665 665          }
666 666  
667 667  
668 668  
669 669  @Callable(i)
670 670  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
671 671      let res = commonGet(i)
672 672      let outAmAmt = res._1
673 673      let outPrAmt = res._2
674 674      let pmtAmt = res._3
675 675      let pmtAssetId = res._4
676 676      let state = res._5
677 677      if ((noLessThenAmtAsset > outAmAmt))
678 678          then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
679 679          else if ((noLessThenPriceAsset > outPrAmt))
680 680              then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
681 681              else {
682 682                  let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
683 683                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
684 684                      then state
685 685                      else throw("Strict value is not equal to itself.")
686 686                  }
687 687      }
688 688  
689 689  
690 690  
691 691  @Callable(i)
692 692  func unstakeAndGet (amount) = {
693 693      let checkPayments = if ((size(i.payments) != 0))
694 694          then throw("No pmnts expected")
695 695          else true
696 696      if ((checkPayments == checkPayments))
697 697          then {
698 698              let cfg = getPoolConfig()
699 699              let factoryCfg = getFactoryConfig()
700 700              let lpAssetId = fromBase58String(cfg[idxLPAsId])
701 701              let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
702 702              let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
703 703              if ((unstakeInv == unstakeInv))
704 704                  then {
705 705                      let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
706 706                      let poolStatus = parseIntValue(r._9)
707 707                      let state = r._10
708 708                      let checkPoolStatus = if (if (isGlobalShutdown())
709 709                          then true
710 710                          else (poolStatus == PoolShutdown))
711 711                          then throw(("Blocked: " + toString(poolStatus)))
712 712                          else true
713 713                      if ((checkPoolStatus == checkPoolStatus))
714 714                          then {
715 715                              let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
716 716                              if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
717 717                                  then state
718 718                                  else throw("Strict value is not equal to itself.")
719 719                              }
720 720                          else throw("Strict value is not equal to itself.")
721 721                      }
722 722                  else throw("Strict value is not equal to itself.")
723 723              }
724 724          else throw("Strict value is not equal to itself.")
725 725      }
726 726  
727 727  
728 728  
729 729  @Callable(i)
730 730  func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
731 731      then throw("denied")
732 732      else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
733 733  
734 734  
735 735  
736 736  @Callable(i)
737 737  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
738 738  
739 739  
740 740  
741 741  @Callable(i)
742 742  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
743 743  
744 744  
745 745  
746 746  @Callable(i)
747 747  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
748 748      let prices = calcPrices(amAmt, prAmt, lpAmt)
749 749      $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
750 750      }
751 751  
752 752  
753 753  
754 754  @Callable(i)
755 755  func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
756 756  
757 757  
758 758  
759 759  @Callable(i)
760 760  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
761 761  
762 762  
763 763  
764 764  @Callable(i)
765 765  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
766 766  
767 767  
768 768  
769 769  @Callable(i)
770 770  func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,usrAddr,isEval,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, usrAddr, isEval, emitLp, false, 0, ""))
771 771  
772 772  
773 773  
774 774  @Callable(i)
775 775  func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
776 776      let res = estimateGetOperation(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
777 777      $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
778 778      }
779 779  
780 780  
781 781  @Verifier(tx)
782 782  func verify () = match tx {
783 783      case order: Order => 
784 784          let mtchPub = getMatcherPubOrFail()
785 785          let orV = validateMatcherOrderAllowed(order)
786 786          let sndrV = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
787 787          let mtchV = sigVerify(order.bodyBytes, order.proofs[1], mtchPub)
788 788          if (if (if (orV)
789 789              then sndrV
790 790              else false)
791 791              then mtchV
792 792              else false)
793 793              then true
794 794              else throwOrderError(orV, sndrV, mtchV)
795 795      case _ => 
796 796          let admin = valueOrElse(getString(this, keyManPubKey()), EMPTY)
797 797          if ((admin == EMPTY))
798 798              then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
799 799              else sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(admin))
800 800  }
801 801

Old	New		Differences
321	321		else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
322	322		let writeAmAmt = $t01564815994._1
323	323		let writePrAmt = $t01564815994._2
324		-	let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(~~calcAmAssetPmt~~, ~~calcPrAssetPmt~~, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
	324	+	let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
325	325		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
326	326		}
327	327		}

489	489		let pmtAmt = pmt.amount
490	490		let amBalance = getAccBalance(amId)
491	491		let prBalance = getAccBalance(prId)
492		-	let $~~t02367624056~~ = if ((pmtAssetId == amId))
	492	+	let $t02366724047 = if ((pmtAssetId == amId))
493	493		then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
494	494		else if ((pmtAssetId == prId))
495	495		then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
496	496		else throw("wrong pmtAssetId")
497		-	let amBalanceNow = $~~t02367624056~~._1
498		-	let prBalanceNow = $~~t02367624056~~._2
499		-	let virtSwapInAm = $~~t02367624056~~._3
500		-	let virtSwapOutPr = $~~t02367624056~~._4
501		-	let virtSwapInPr = $~~t02367624056~~._5
502		-	let virtSwapOutAm = $~~t02367624056~~._6
	497	+	let amBalanceNow = $t02366724047._1
	498	+	let prBalanceNow = $t02366724047._2
	499	+	let virtSwapInAm = $t02366724047._3
	500	+	let virtSwapOutPr = $t02366724047._4
	501	+	let virtSwapInPr = $t02366724047._5
	502	+	let virtSwapOutAm = $t02366724047._6
503	503		let dCur = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
504	504		let dNew = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
505	505		let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(dNew)), parseBigIntValue(asString(dCur)), toBigInt(1000))

618	618		let estimPrAmt = r._2
619	619		let amBalance = getAccBalance(amId)
620	620		let prBalance = getAccBalance(prId)
621		-	let $~~t02866329147~~ = if ((outAssetId == amId))
	621	+	let $t02865429138 = if ((outAssetId == amId))
622	622		then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), (outAmount - estimAmAmt), prAssetSwap, 0, 0, (estimAmAmt + amAssetSwap))
623	623		else if ((outAssetId == prId))
624	624		then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, (outAmount - estimPrAmt), amAssetSwap, (estimPrAmt + prAssetSwap))
625	625		else throw("wrong outAssetId")
626		-	let amBalanceNow = $~~t02866329147~~._1
627		-	let prBalanceNow = $~~t02866329147~~._2
628		-	let virtSwapInAm = $~~t02866329147~~._3
629		-	let virtSwapOutPr = $~~t02866329147~~._4
630		-	let virtSwapInPr = $~~t02866329147~~._5
631		-	let virtSwapOutAm = $~~t02866329147~~._6
632		-	let totalGet = $~~t02866329147~~._7
	626	+	let amBalanceNow = $t02865429138._1
	627	+	let prBalanceNow = $t02865429138._2
	628	+	let virtSwapInAm = $t02865429138._3
	629	+	let virtSwapOutPr = $t02865429138._4
	630	+	let virtSwapInPr = $t02865429138._5
	631	+	let virtSwapOutAm = $t02865429138._6
	632	+	let totalGet = $t02865429138._7
633	633		let invLeft = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
634	634		let invRight = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
635	635		let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))

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

github/deemru/w8io/3ef1775 
142.27 ms ◑