w8 · tx · wGB···dXu

tx · wGBwx2dPek6HaZ8N8GVpwAgs34e4tqsqkveq9heqdXu

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.01400000 Waves

2021.12.19 22:56 [1841593] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

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

View: original | compacted
Prev: HddKR35Sh4bfT3fqiLthS5mwP9AmLGNMwjFdHeTf3rNS
Next: 5VbsdSdcBSnHu3CXbwVePGAfMfeEkCj7KzqZau3Lm7CG

Diff: 
Old New Differences
459 459              let amAssetSwapX18 = toX18(inAmtAmount, amAssetDcm)
460 460              let prAssetSwapX18 = toX18(inPrAmount, prAssetDcm)
461 461              let inPrice = calcPriceBigInt(prAssetSwapX18, amAssetSwapX18)
462 -             if (true)
463 -                 then throw(((toBase58String(pmtAssetId) + " : ") + amAssetId))
462 +             let isValid = if ((toBase58String(pmtAssetId) == amAssetId))
463 +                 then {
464 +                     let pmtAmtX18 = toX18(pmtAmt, amAssetDcm)
465 +                     let diffByPriceAsset = (pmtAmtX18 - amAssetSwapX18)
466 +                     let eqPriceAsset = fraction(diffByPriceAsset, inPrice, scale18)
467 +                     let prAssetDiff = fraction((eqPriceAsset - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
468 +                     if (true)
469 +                         then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqPriceAsset = ") + toString(eqPriceAsset)) + " diffByPriceAsset = ") + toString(diffByPriceAsset)))
470 +                         else true
471 +                     }
464 472                  else {
465 -                     let isValid = if ((toBase58String(pmtAssetId) == amAssetId))
473 +                     let pmtPrX18 = toX18(pmtAmt, prAssetDcm)
474 +                     let diffByAmtAsset = (pmtPrX18 - prAssetSwapX18)
475 +                     let eqAmtAsset = fraction(diffByAmtAsset, scale18, inPrice)
476 +                     let amAssetDiff = fraction((eqAmtAsset - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
477 +                     if (true)
478 +                         then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqAmtAsset = ") + toString(eqAmtAsset)) + " diffByAmountAsset = ") + toString(diffByAmtAsset)))
479 +                         else true
480 +                     }
481 +             let estPut = estimatePutOperation(toBase58String(i.transactionId), 0, inAmtAmount, fromBase58String(amAssetId), inPrAmount, fromBase58String(prAssetId), toString(i.caller), false, true, true)
482 +             let emitLpAmt = estPut._2
483 +             let lpAssetId = estPut._7
484 +             let status = parseIntValue(estPut._8)
485 +             if (if (if (isGlobalShutdown())
486 +                 then true
487 +                 else (status == PoolPutDisabled))
488 +                 then true
489 +                 else (status == PoolShutdown))
490 +                 then throw(("Put operation is blocked by admin. Status = " + toString(status)))
491 +                 else {
492 +                     let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
493 +                     if ((emitInv == emitInv))
466 494                          then {
467 -                             let pmtAmtX18 = toX18(pmtAmt, amAssetDcm)
468 -                             let diffByPriceAsset = (pmtAmtX18 - amAssetSwapX18)
469 -                             let eqPriceAsset = fraction(diffByPriceAsset, inPrice, scale18)
470 -                             let prAssetDiff = fraction((eqPriceAsset - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
471 -                             if (true)
472 -                                 then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqPriceAsset = ") + toString(eqPriceAsset)) + " diffByPriceAsset = ") + toString(diffByPriceAsset)))
473 -                                 else true
495 +                             let lpTrnsfr = if (autoStake)
496 +                                 then {
497 +                                     let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
498 +                                     if ((stakeInv == stakeInv))
499 +                                         then nil
500 +                                         else throw("Strict value is not equal to itself.")
501 +                                     }
502 +                                 else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
503 +                             (estPut._9 ++ lpTrnsfr)
474 504                              }
475 -                         else {
476 -                             let pmtPrX18 = toX18(pmtAmt, prAssetDcm)
477 -                             let diffByAmtAsset = (pmtPrX18 - prAssetSwapX18)
478 -                             let eqAmtAsset = fraction(diffByAmtAsset, scale18, inPrice)
479 -                             let amAssetDiff = fraction((eqAmtAsset - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
480 -                             if (true)
481 -                                 then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqAmtAsset = ") + toString(eqAmtAsset)) + " diffByAmountAsset = ") + toString(diffByAmtAsset)))
482 -                                 else true
483 -                             }
484 -                     let estPut = estimatePutOperation(toBase58String(i.transactionId), 0, inAmtAmount, fromBase58String(amAssetId), inPrAmount, fromBase58String(prAssetId), toString(i.caller), false, true, true)
485 -                     let emitLpAmt = estPut._2
486 -                     let lpAssetId = estPut._7
487 -                     let status = parseIntValue(estPut._8)
488 -                     if (if (if (isGlobalShutdown())
489 -                         then true
490 -                         else (status == PoolPutDisabled))
491 -                         then true
492 -                         else (status == PoolShutdown))
493 -                         then throw(("Put operation is blocked by admin. Status = " + toString(status)))
494 -                         else {
495 -                             let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
496 -                             if ((emitInv == emitInv))
497 -                                 then {
498 -                                     let lpTrnsfr = if (autoStake)
499 -                                         then {
500 -                                             let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
501 -                                             if ((stakeInv == stakeInv))
502 -                                                 then nil
503 -                                                 else throw("Strict value is not equal to itself.")
504 -                                             }
505 -                                         else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
506 -                                     (estPut._9 ++ lpTrnsfr)
507 -                                     }
508 -                                 else throw("Strict value is not equal to itself.")
509 -                             }
505 +                         else throw("Strict value is not equal to itself.")
510 506                      }
511 507              }
512 508      }
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 5 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let lPdecimals = 8
5 5  
6 6  let scale8 = 100000000
7 7  
8 8  let scale8BigInt = toBigInt(100000000)
9 9  
10 10  let calcError = toBigInt(1000000)
11 11  
12 12  let scale18 = toBigInt(1000000000000000000)
13 13  
14 14  let zeroBigInt = toBigInt(0)
15 15  
16 16  let SEP = "__"
17 17  
18 18  let EMPTY = ""
19 19  
20 20  let PoolActive = 1
21 21  
22 22  let PoolPutDisabled = 2
23 23  
24 24  let PoolMatcherDisabled = 3
25 25  
26 26  let PoolShutdown = 4
27 27  
28 28  let idxPoolAddress = 1
29 29  
30 30  let idxPoolStatus = 2
31 31  
32 32  let idxPoolLPAssetId = 3
33 33  
34 34  let idxAmtAssetId = 4
35 35  
36 36  let idxPriceAssetId = 5
37 37  
38 38  let idxAmtAssetDcm = 6
39 39  
40 40  let idxPriceAssetDcm = 7
41 41  
42 42  let idxIAmtAssetId = 8
43 43  
44 44  let idxIPriceAssetId = 9
45 45  
46 46  let idxLPAssetDcm = 10
47 47  
48 48  let idxPoolAmtAssetAmt = 1
49 49  
50 50  let idxPoolPriceAssetAmt = 2
51 51  
52 52  let idxPoolLPAssetAmt = 3
53 53  
54 54  let idxFactoryStakingContract = 1
55 55  
56 56  let idxFactorySlippageContract = 7
57 57  
58 58  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
59 59  
60 60  
61 61  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
62 62  
63 63  
64 64  func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
65 65  
66 66  
67 67  func abs (val) = if ((zeroBigInt > val))
68 68      then -(val)
69 69      else val
70 70  
71 71  
72 72  func keyFactoryContract () = "%s__factoryContract"
73 73  
74 74  
75 75  func keyManagerPublicKey () = "%s__managerPublicKey"
76 76  
77 77  
78 78  func keyPriceLast () = "%s%s__price__last"
79 79  
80 80  
81 81  func keyPriceHistory (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
82 82  
83 83  
84 84  func keyPutActionByUser (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
85 85  
86 86  
87 87  func keyGetActionByUser (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
88 88  
89 89  
90 90  func keyAmtAsset () = "%s__amountAsset"
91 91  
92 92  
93 93  func keyPriceAsset () = "%s__priceAsset"
94 94  
95 95  
96 96  func keyKHistoric (h,timestamp) = makeString(["%s%s%d%d__K_history", toString(h), toString(timestamp)], SEP)
97 97  
98 98  
99 99  func keyFactoryConfig () = "%s__factoryConfig"
100 100  
101 101  
102 102  func keyMatcherPub () = "%s%s__matcher__publicKey"
103 103  
104 104  
105 105  func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
106 106  
107 107  
108 108  func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
109 109  
110 110  
111 111  func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
112 112  
113 113  
114 114  func keyAllPoolsShutdown () = "%s__shutdown"
115 115  
116 116  
117 117  func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
118 118  
119 119  
120 120  func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
121 121  
122 122  
123 123  func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
124 124  
125 125  
126 126  func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
127 127  
128 128  
129 129  let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactoryContract()))
130 130  
131 131  func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
132 132  
133 133  
134 134  func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
135 135  
136 136  
137 137  func getPoolConfig () = {
138 138      let amtAsset = getStringOrFail(this, keyAmtAsset())
139 139      let priceAsset = getStringOrFail(this, keyPriceAsset())
140 140      let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
141 141      let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
142 142      split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
143 143      }
144 144  
145 145  
146 146  func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
147 147  
148 148  
149 149  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
150 150  
151 151  
152 152  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)
153 153  
154 154  
155 155  func getAccBalance (assetId) = if ((assetId == "WAVES"))
156 156      then wavesBalance(this).available
157 157      else assetBalance(this, fromBase58String(assetId))
158 158  
159 159  
160 160  func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
161 161  
162 162  
163 163  func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
164 164      let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
165 165      let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
166 166      calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
167 167      }
168 168  
169 169  
170 170  func calcPrices (amAmt,prAmt,lpAmt) = {
171 171      let cfg = getPoolConfig()
172 172      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
173 173      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
174 174      let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
175 175      let amAmtX18 = toX18(amAmt, amtAssetDcm)
176 176      let prAmtX18 = toX18(prAmt, priceAssetDcm)
177 177      let lpAmtX18 = toX18(lpAmt, scale8)
178 178      let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
179 179      let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
180 180  [priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
181 181      }
182 182  
183 183  
184 184  func calculatePrices (amAmt,prAmt,lpAmt) = {
185 185      let prices = calcPrices(amAmt, prAmt, lpAmt)
186 186  [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
187 187      }
188 188  
189 189  
190 190  func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
191 191      let cfg = getPoolConfig()
192 192      let lpAssetId = cfg[idxPoolLPAssetId]
193 193      let amAssetId = cfg[idxAmtAssetId]
194 194      let prAssetId = cfg[idxPriceAssetId]
195 195      let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
196 196      let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
197 197      let poolStatus = cfg[idxPoolStatus]
198 198      let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
199 199      if ((lpAssetId != pmtAssetId))
200 200          then throw("Invalid asset passed.")
201 201          else {
202 202              let amBalance = getAccBalance(amAssetId)
203 203              let amBalanceX18 = toX18(amBalance, amAssetDcm)
204 204              let prBalance = getAccBalance(prAssetId)
205 205              let prBalanceX18 = toX18(prBalance, prAssetDcm)
206 206              let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
207 207              let curPrice = fromX18(curPriceX18, scale8)
208 208              let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
209 209              let lpEmissionX18 = toX18(lpEmission, scale8)
210 210              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
211 211              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
212 212              let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
213 213              let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
214 214              let state = if ((txId58 == ""))
215 215                  then nil
216 216                  else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
217 217                      then unit
218 218                      else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
219 219                      then unit
220 220                      else fromBase58String(prAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
221 221              $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
222 222              }
223 223      }
224 224  
225 225  
226 226  func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp,isOneAsset) = {
227 227      let cfg = getPoolConfig()
228 228      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
229 229      let amAssetIdStr = cfg[idxAmtAssetId]
230 230      let prAssetIdStr = cfg[idxPriceAssetId]
231 231      let inAmAssetIdStr = cfg[idxIAmtAssetId]
232 232      let inPrAssetIdStr = cfg[idxIPriceAssetId]
233 233      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
234 234      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
235 235      let poolStatus = cfg[idxPoolStatus]
236 236      let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
237 237      let amBalance = if (isEvaluate)
238 238          then getAccBalance(amAssetIdStr)
239 239          else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
240 240      let prBalance = if (isEvaluate)
241 241          then getAccBalance(prAssetIdStr)
242 242          else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
243 243      let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
244 244      let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
245 245      let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
246 246      let amBalanceX18 = toX18(amBalance, amtAssetDcm)
247 247      let prBalanceX18 = toX18(prBalance, priceAssetDcm)
248 248      let res = if ((lpEmission == 0))
249 249          then {
250 250              let curPriceX18 = zeroBigInt
251 251              let slippageX18 = zeroBigInt
252 252              let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
253 253              $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
254 254              }
255 255          else {
256 256              let tRes = if (isOneAsset)
257 257                  then {
258 258                      let lpEmissionX18 = toX18(lpEmission, scale8)
259 259                      let sumInAssets = (inAmAssetAmtX18 + inPrAssetAmtX18)
260 260                      let sumPoolBalances = (amBalanceX18 + prBalanceX18)
261 261                      let lpAmtX18 = fraction(lpEmissionX18, sumInAssets, sumPoolBalances)
262 262                      let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
263 263                      $Tuple5(fromX18(lpAmtX18, scale8), inAmAssetAmt, inPrAssetAmt, curPriceX18, toBigInt(0))
264 264                      }
265 265                  else {
266 266                      let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
267 267                      let slippageX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
268 268                      let slippageToleranceX18 = toX18(slippageTolerance, scale8)
269 269                      if (if ((curPriceX18 != zeroBigInt))
270 270                          then (slippageX18 > slippageToleranceX18)
271 271                          else false)
272 272                          then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
273 273                          else {
274 274                              let lpEmissionX18 = toX18(lpEmission, scale8)
275 275                              let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
276 276                              let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
277 277                              let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
278 278                                  then $Tuple2(amViaPrX18, inPrAssetAmtX18)
279 279                                  else $Tuple2(inAmAssetAmtX18, prViaAmX18)
280 280                              let expAmtAssetAmtX18 = expectedAmts._1
281 281                              let expPriceAssetAmtX18 = expectedAmts._2
282 282                              let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
283 283                              $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
284 284                              }
285 285                      }
286 286              tRes
287 287              }
288 288      let calcLpAmt = res._1
289 289      let calcAmAssetPmt = res._2
290 290      let calcPrAssetPmt = res._3
291 291      let curPrice = fromX18(res._4, scale8)
292 292      let slippageCalc = fromX18(res._5, scale8)
293 293      if ((0 >= calcLpAmt))
294 294          then throw("Invalid calculations. LP calculated is less than zero.")
295 295          else {
296 296              let emitLpAmt = if (!(emitLp))
297 297                  then 0
298 298                  else calcLpAmt
299 299              let amDiff = (inAmAssetAmt - calcAmAssetPmt)
300 300              let prDiff = (inPrAssetAmt - calcPrAssetPmt)
301 301              let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
302 302              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
303 303              }
304 304      }
305 305  
306 306  
307 307  func validateMatcherOrderAllowed (order) = {
308 308      let cfg = getPoolConfig()
309 309      let amtAssetId = cfg[idxAmtAssetId]
310 310      let priceAssetId = cfg[idxPriceAssetId]
311 311      let poolStatus = parseIntValue(cfg[idxPoolStatus])
312 312      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
313 313      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
314 314      let accAmtAssetBalance = getAccBalance(amtAssetId)
315 315      let accPriceAssetBalance = getAccBalance(priceAssetId)
316 316      let curPriceX18 = if ((order.orderType == Buy))
317 317          then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
318 318          else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
319 319      let curPrice = fromX18(curPriceX18, scale8)
320 320      if (if (if (isGlobalShutdown())
321 321          then true
322 322          else (poolStatus == PoolMatcherDisabled))
323 323          then true
324 324          else (poolStatus == PoolShutdown))
325 325          then throw("Exchange operations disabled")
326 326          else {
327 327              let orderAmtAsset = order.assetPair.amountAsset
328 328              let orderAmtAssetStr = if ((orderAmtAsset == unit))
329 329                  then "WAVES"
330 330                  else toBase58String(value(orderAmtAsset))
331 331              let orderPriceAsset = order.assetPair.priceAsset
332 332              let orderPriceAssetStr = if ((orderPriceAsset == unit))
333 333                  then "WAVES"
334 334                  else toBase58String(value(orderPriceAsset))
335 335              if (if ((orderAmtAssetStr != amtAssetId))
336 336                  then true
337 337                  else (orderPriceAssetStr != priceAssetId))
338 338                  then throw("Wrong order assets.")
339 339                  else {
340 340                      let orderPrice = order.price
341 341                      let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
342 342                      let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
343 343                      let isOrderPriceValid = if ((order.orderType == Buy))
344 344                          then (curPrice >= castedOrderPrice)
345 345                          else (castedOrderPrice >= curPrice)
346 346                      true
347 347                      }
348 348              }
349 349      }
350 350  
351 351  
352 352  func commonGet (i) = if ((size(i.payments) != 1))
353 353      then throw("exactly 1 payment is expected")
354 354      else {
355 355          let pmt = value(i.payments[0])
356 356          let pmtAssetId = value(pmt.assetId)
357 357          let pmtAmt = pmt.amount
358 358          let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
359 359          let outAmAmt = res._1
360 360          let outPrAmt = res._2
361 361          let poolStatus = parseIntValue(res._9)
362 362          let state = res._10
363 363          if (if (isGlobalShutdown())
364 364              then true
365 365              else (poolStatus == PoolShutdown))
366 366              then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
367 367              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
368 368          }
369 369  
370 370  
371 371  func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
372 372      then throw("exactly 2 payments are expected")
373 373      else {
374 374          let amAssetPmt = value(i.payments[0])
375 375          let prAssetPmt = value(i.payments[1])
376 376          let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp, false)
377 377          let status = parseIntValue(estPut._8)
378 378          if (if (if (isGlobalShutdown())
379 379              then true
380 380              else (status == PoolPutDisabled))
381 381              then true
382 382              else (status == PoolShutdown))
383 383              then throw(("Put operation is blocked by admin. Status = " + toString(status)))
384 384              else estPut
385 385          }
386 386  
387 387  
388 388  @Callable(i)
389 389  func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
390 390      then throw("permissions denied")
391 391      else [StringEntry(keyFactoryContract(), factoryContract), StringEntry(keyManagerPublicKey(), managerPublicKey)]
392 392  
393 393  
394 394  
395 395  @Callable(i)
396 396  func put (slippageTolerance,autoStake) = {
397 397      let factoryCfg = getFactoryConfig()
398 398      let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
399 399      let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
400 400      if ((0 > slippageTolerance))
401 401          then throw("Invalid slippageTolerance passed")
402 402          else {
403 403              let estPut = commonPut(i, slippageTolerance, true)
404 404              let emitLpAmt = estPut._2
405 405              let lpAssetId = estPut._7
406 406              let state = estPut._9
407 407              let amDiff = estPut._10
408 408              let prDiff = estPut._11
409 409              let amId = estPut._12
410 410              let prId = estPut._13
411 411              let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
412 412              if ((emitInv == emitInv))
413 413                  then {
414 414                      let slippageAInv = if ((amDiff > 0))
415 415                          then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
416 416                          else nil
417 417                      if ((slippageAInv == slippageAInv))
418 418                          then {
419 419                              let slippagePInv = if ((prDiff > 0))
420 420                                  then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
421 421                                  else nil
422 422                              if ((slippagePInv == slippagePInv))
423 423                                  then {
424 424                                      let lpTrnsfr = if (autoStake)
425 425                                          then {
426 426                                              let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
427 427                                              if ((slpStakeInv == slpStakeInv))
428 428                                                  then nil
429 429                                                  else throw("Strict value is not equal to itself.")
430 430                                              }
431 431                                          else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
432 432                                      (state ++ lpTrnsfr)
433 433                                      }
434 434                                  else throw("Strict value is not equal to itself.")
435 435                              }
436 436                          else throw("Strict value is not equal to itself.")
437 437                      }
438 438                  else throw("Strict value is not equal to itself.")
439 439              }
440 440      }
441 441  
442 442  
443 443  
444 444  @Callable(i)
445 445  func putOneTkn (inAmtAmount,inPrAmount,autoStake) = {
446 446      let cfg = getFactoryConfig()
447 447      let stakingContract = valueOrErrorMessage(addressFromString(cfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
448 448      let poolCfg = getPoolConfig()
449 449      let amAssetId = poolCfg[idxAmtAssetId]
450 450      let prAssetId = poolCfg[idxPriceAssetId]
451 451      let amAssetDcm = parseIntValue(poolCfg[idxAmtAssetDcm])
452 452      let prAssetDcm = parseIntValue(poolCfg[idxPriceAssetDcm])
453 453      if ((size(i.payments) != 1))
454 454          then throw("exactly 1 payment are expected")
455 455          else {
456 456              let pmt = value(i.payments[0])
457 457              let pmtAssetId = value(pmt.assetId)
458 458              let pmtAmt = pmt.amount
459 459              let amAssetSwapX18 = toX18(inAmtAmount, amAssetDcm)
460 460              let prAssetSwapX18 = toX18(inPrAmount, prAssetDcm)
461 461              let inPrice = calcPriceBigInt(prAssetSwapX18, amAssetSwapX18)
462 -             if (true)
463 -                 then throw(((toBase58String(pmtAssetId) + " : ") + amAssetId))
462 +             let isValid = if ((toBase58String(pmtAssetId) == amAssetId))
463 +                 then {
464 +                     let pmtAmtX18 = toX18(pmtAmt, amAssetDcm)
465 +                     let diffByPriceAsset = (pmtAmtX18 - amAssetSwapX18)
466 +                     let eqPriceAsset = fraction(diffByPriceAsset, inPrice, scale18)
467 +                     let prAssetDiff = fraction((eqPriceAsset - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
468 +                     if (true)
469 +                         then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqPriceAsset = ") + toString(eqPriceAsset)) + " diffByPriceAsset = ") + toString(diffByPriceAsset)))
470 +                         else true
471 +                     }
464 472                  else {
465 -                     let isValid = if ((toBase58String(pmtAssetId) == amAssetId))
473 +                     let pmtPrX18 = toX18(pmtAmt, prAssetDcm)
474 +                     let diffByAmtAsset = (pmtPrX18 - prAssetSwapX18)
475 +                     let eqAmtAsset = fraction(diffByAmtAsset, scale18, inPrice)
476 +                     let amAssetDiff = fraction((eqAmtAsset - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
477 +                     if (true)
478 +                         then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqAmtAsset = ") + toString(eqAmtAsset)) + " diffByAmountAsset = ") + toString(diffByAmtAsset)))
479 +                         else true
480 +                     }
481 +             let estPut = estimatePutOperation(toBase58String(i.transactionId), 0, inAmtAmount, fromBase58String(amAssetId), inPrAmount, fromBase58String(prAssetId), toString(i.caller), false, true, true)
482 +             let emitLpAmt = estPut._2
483 +             let lpAssetId = estPut._7
484 +             let status = parseIntValue(estPut._8)
485 +             if (if (if (isGlobalShutdown())
486 +                 then true
487 +                 else (status == PoolPutDisabled))
488 +                 then true
489 +                 else (status == PoolShutdown))
490 +                 then throw(("Put operation is blocked by admin. Status = " + toString(status)))
491 +                 else {
492 +                     let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
493 +                     if ((emitInv == emitInv))
466 494                          then {
467 -                             let pmtAmtX18 = toX18(pmtAmt, amAssetDcm)
468 -                             let diffByPriceAsset = (pmtAmtX18 - amAssetSwapX18)
469 -                             let eqPriceAsset = fraction(diffByPriceAsset, inPrice, scale18)
470 -                             let prAssetDiff = fraction((eqPriceAsset - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
471 -                             if (true)
472 -                                 then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqPriceAsset = ") + toString(eqPriceAsset)) + " diffByPriceAsset = ") + toString(diffByPriceAsset)))
473 -                                 else true
495 +                             let lpTrnsfr = if (autoStake)
496 +                                 then {
497 +                                     let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
498 +                                     if ((stakeInv == stakeInv))
499 +                                         then nil
500 +                                         else throw("Strict value is not equal to itself.")
501 +                                     }
502 +                                 else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
503 +                             (estPut._9 ++ lpTrnsfr)
474 504                              }
475 -                         else {
476 -                             let pmtPrX18 = toX18(pmtAmt, prAssetDcm)
477 -                             let diffByAmtAsset = (pmtPrX18 - prAssetSwapX18)
478 -                             let eqAmtAsset = fraction(diffByAmtAsset, scale18, inPrice)
479 -                             let amAssetDiff = fraction((eqAmtAsset - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
480 -                             if (true)
481 -                                 then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqAmtAsset = ") + toString(eqAmtAsset)) + " diffByAmountAsset = ") + toString(diffByAmtAsset)))
482 -                                 else true
483 -                             }
484 -                     let estPut = estimatePutOperation(toBase58String(i.transactionId), 0, inAmtAmount, fromBase58String(amAssetId), inPrAmount, fromBase58String(prAssetId), toString(i.caller), false, true, true)
485 -                     let emitLpAmt = estPut._2
486 -                     let lpAssetId = estPut._7
487 -                     let status = parseIntValue(estPut._8)
488 -                     if (if (if (isGlobalShutdown())
489 -                         then true
490 -                         else (status == PoolPutDisabled))
491 -                         then true
492 -                         else (status == PoolShutdown))
493 -                         then throw(("Put operation is blocked by admin. Status = " + toString(status)))
494 -                         else {
495 -                             let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
496 -                             if ((emitInv == emitInv))
497 -                                 then {
498 -                                     let lpTrnsfr = if (autoStake)
499 -                                         then {
500 -                                             let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
501 -                                             if ((stakeInv == stakeInv))
502 -                                                 then nil
503 -                                                 else throw("Strict value is not equal to itself.")
504 -                                             }
505 -                                         else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
506 -                                     (estPut._9 ++ lpTrnsfr)
507 -                                     }
508 -                                 else throw("Strict value is not equal to itself.")
509 -                             }
505 +                         else throw("Strict value is not equal to itself.")
510 506                      }
511 507              }
512 508      }
513 509  
514 510  
515 511  
516 512  @Callable(i)
517 513  func putForFree (maxSlippage) = if ((0 > maxSlippage))
518 514      then throw("Invalid value passed")
519 515      else {
520 516          let estPut = commonPut(i, maxSlippage, false)
521 517          estPut._9
522 518          }
523 519  
524 520  
525 521  
526 522  @Callable(i)
527 523  func get () = {
528 524      let res = commonGet(i)
529 525      let outAmtAmt = res._1
530 526      let outPrAmt = res._2
531 527      let pmtAmt = res._3
532 528      let pmtAssetId = res._4
533 529      let state = res._5
534 530      let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
535 531      if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
536 532          then state
537 533          else throw("Strict value is not equal to itself.")
538 534      }
539 535  
540 536  
541 537  
542 538  @Callable(i)
543 539  func getOneTkn (amAssetSwap,prAssetSwap,outAmount,outAssetId) = if ((size(i.payments) != 1))
544 540      then throw("exactly 1 payment is expected")
545 541      else {
546 542          let cfg = getPoolConfig()
547 543          let lpAssetId = cfg[idxPoolLPAssetId]
548 544          let amAssetId = cfg[idxAmtAssetId]
549 545          let prAssetId = cfg[idxPriceAssetId]
550 546          let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
551 547          let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
552 548          let poolStatus = cfg[idxPoolStatus]
553 549          if (if ((outAssetId != amAssetId))
554 550              then (outAssetId != prAssetId)
555 551              else false)
556 552              then throw(("Incorrect out asset id passed: " + outAssetId))
557 553              else {
558 554                  let resultAssetId = if ((outAssetId == amAssetId))
559 555                      then amAssetId
560 556                      else prAssetId
561 557                  let resultAmtAmount = if ((outAssetId == amAssetId))
562 558                      then outAmount
563 559                      else 0
564 560                  let resultPrAmount = if ((outAssetId == prAssetId))
565 561                      then outAmount
566 562                      else 0
567 563                  let pmt = value(i.payments[0])
568 564                  let userAddress = i.caller
569 565                  let txId58 = toBase58String(i.transactionId)
570 566                  let pmtAssetId = value(pmt.assetId)
571 567                  let pmtAmt = pmt.amount
572 568                  if ((lpAssetId != toBase58String(pmtAssetId)))
573 569                      then throw("Invalid asset passed.")
574 570                      else {
575 571                          let amAssetSwapX18 = toX18(amAssetSwap, amAssetDcm)
576 572                          let prAssetSwapX18 = toX18(prAssetSwap, prAssetDcm)
577 573                          let swapPriceX18 = calcPriceBigInt(prAssetSwapX18, amAssetSwapX18)
578 574                          let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
579 575                          let outAmAmt = r._1
580 576                          let outPrAmt = r._2
581 577                          let isValid = if ((outAssetId == amAssetId))
582 578                              then {
583 579                                  let prSwopPartInAmountAsset = (resultAmtAmount - outAmAmt)
584 580                                  let convRes = fraction(toX18(prSwopPartInAmountAsset, amAssetDcm), swapPriceX18, scale18)
585 581                                  let prAssetDiff = fraction((convRes - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
586 582                                  if (if ((prAssetDiff > calcError))
587 583                                      then true
588 584                                      else (-(calcError) > prAssetDiff))
589 585                                      then throw(((("Slippage exeeded the value " + toString(calcError)) + " and equal to ") + toString(prAssetDiff)))
590 586                                      else true
591 587                                  }
592 588                              else {
593 589                                  let amSwopPartInPriceAsset = (resultPrAmount - outPrAmt)
594 590                                  let convRes = fraction(toX18(amSwopPartInPriceAsset, amAssetDcm), scale18, swapPriceX18)
595 591                                  let amAssetDiff = fraction((convRes - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
596 592                                  if (if ((amAssetDiff > calcError))
597 593                                      then true
598 594                                      else (-(calcError) > amAssetDiff))
599 595                                      then throw(((("Slippage exeeded the value " + toString(calcError)) + " and equal to ") + toString(amAssetDiff)))
600 596                                      else true
601 597                                  }
602 598                          let amBalance = getAccBalance(amAssetId)
603 599                          let amBalanceX18 = toX18(amBalance, amAssetDcm)
604 600                          let prBalance = getAccBalance(prAssetId)
605 601                          let prBalanceX18 = toX18(prBalance, prAssetDcm)
606 602                          let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
607 603                          let curPrice = fromX18(curPriceX18, scale8)
608 604                          let state = [ScriptTransfer(userAddress, outAmount, if ((resultAssetId == "WAVES"))
609 605                              then unit
610 606                              else fromBase58String(resultAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(resultAmtAmount, resultPrAmount, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
611 607                          let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
612 608                          if ((burn == burn))
613 609                              then state
614 610                              else throw("Strict value is not equal to itself.")
615 611                          }
616 612                  }
617 613          }
618 614  
619 615  
620 616  
621 617  @Callable(i)
622 618  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
623 619      let res = commonGet(i)
624 620      let outAmAmt = res._1
625 621      let outPrAmt = res._2
626 622      let pmtAmt = res._3
627 623      let pmtAssetId = res._4
628 624      let state = res._5
629 625      if ((noLessThenAmtAsset > outAmAmt))
630 626          then throw(((("noLessThenAmtAsset failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
631 627          else if ((noLessThenPriceAsset > outPrAmt))
632 628              then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
633 629              else {
634 630                  let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
635 631                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
636 632                      then state
637 633                      else throw("Strict value is not equal to itself.")
638 634                  }
639 635      }
640 636  
641 637  
642 638  
643 639  @Callable(i)
644 640  func unstakeAndGet (amount) = {
645 641      let checkPayments = if ((size(i.payments) != 0))
646 642          then throw("No payments are expected")
647 643          else true
648 644      if ((checkPayments == checkPayments))
649 645          then {
650 646              let cfg = getPoolConfig()
651 647              let factoryCfg = getFactoryConfig()
652 648              let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
653 649              let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
654 650              let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
655 651              if ((unstakeInv == unstakeInv))
656 652                  then {
657 653                      let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
658 654                      let poolStatus = parseIntValue(res._9)
659 655                      let state = res._10
660 656                      let checkPoolStatus = if (if (isGlobalShutdown())
661 657                          then true
662 658                          else (poolStatus == PoolShutdown))
663 659                          then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
664 660                          else true
665 661                      if ((checkPoolStatus == checkPoolStatus))
666 662                          then {
667 663                              let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
668 664                              if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
669 665                                  then state
670 666                                  else throw("Strict value is not equal to itself.")
671 667                              }
672 668                          else throw("Strict value is not equal to itself.")
673 669                      }
674 670                  else throw("Strict value is not equal to itself.")
675 671              }
676 672          else throw("Strict value is not equal to itself.")
677 673      }
678 674  
679 675  
680 676  
681 677  @Callable(i)
682 678  func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
683 679      then throw("permissions denied")
684 680      else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
685 681  
686 682  
687 683  
688 684  @Callable(i)
689 685  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
690 686  
691 687  
692 688  
693 689  @Callable(i)
694 690  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
695 691  
696 692  
697 693  
698 694  @Callable(i)
699 695  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
700 696      let prices = calcPrices(amAmt, prAmt, lpAmt)
701 697      $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
702 698      }
703 699  
704 700  
705 701  
706 702  @Callable(i)
707 703  func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
708 704  
709 705  
710 706  
711 707  @Callable(i)
712 708  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
713 709  
714 710  
715 711  
716 712  @Callable(i)
717 713  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
718 714  
719 715  
720 716  
721 717  @Callable(i)
722 718  func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp,isOneAsset) = $Tuple2(nil, estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp, isOneAsset))
723 719  
724 720  
725 721  
726 722  @Callable(i)
727 723  func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
728 724      let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
729 725      $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
730 726      }
731 727  
732 728  
733 729  @Verifier(tx)
734 730  func verify () = match tx {
735 731      case order: Order => 
736 732          let matcherPub = getMatcherPubOrFail()
737 733          let orderValid = validateMatcherOrderAllowed(order)
738 734          let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
739 735          let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
740 736          if (if (if (orderValid)
741 737              then senderValid
742 738              else false)
743 739              then matcherValid
744 740              else false)
745 741              then true
746 742              else throwOrderError(orderValid, senderValid, matcherValid)
747 743      case _ => 
748 744          let managerPublic = valueOrElse(getString(this, keyManagerPublicKey()), EMPTY)
749 745          if ((managerPublic == EMPTY))
750 746              then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
751 747              else sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(managerPublic))
752 748  }
753 749

Old	New		Differences
459	459		let amAssetSwapX18 = toX18(inAmtAmount, amAssetDcm)
460	460		let prAssetSwapX18 = toX18(inPrAmount, prAssetDcm)
461	461		let inPrice = calcPriceBigInt(prAssetSwapX18, amAssetSwapX18)
462		-	if (true)
463		-	then throw(((toBase58String(pmtAssetId) + " : ") + amAssetId))
	462	+	let isValid = if ((toBase58String(pmtAssetId) == amAssetId))
	463	+	then {
	464	+	let pmtAmtX18 = toX18(pmtAmt, amAssetDcm)
	465	+	let diffByPriceAsset = (pmtAmtX18 - amAssetSwapX18)
	466	+	let eqPriceAsset = fraction(diffByPriceAsset, inPrice, scale18)
	467	+	let prAssetDiff = fraction((eqPriceAsset - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
	468	+	if (true)
	469	+	then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqPriceAsset = ") + toString(eqPriceAsset)) + " diffByPriceAsset = ") + toString(diffByPriceAsset)))
	470	+	else true
	471	+	}
464	472		else {
465		-	let isValid = if ((toBase58String(pmtAssetId) == amAssetId))
	473	+	let pmtPrX18 = toX18(pmtAmt, prAssetDcm)
	474	+	let diffByAmtAsset = (pmtPrX18 - prAssetSwapX18)
	475	+	let eqAmtAsset = fraction(diffByAmtAsset, scale18, inPrice)
	476	+	let amAssetDiff = fraction((eqAmtAsset - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
	477	+	if (true)
	478	+	then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqAmtAsset = ") + toString(eqAmtAsset)) + " diffByAmountAsset = ") + toString(diffByAmtAsset)))
	479	+	else true
	480	+	}
	481	+	let estPut = estimatePutOperation(toBase58String(i.transactionId), 0, inAmtAmount, fromBase58String(amAssetId), inPrAmount, fromBase58String(prAssetId), toString(i.caller), false, true, true)
	482	+	let emitLpAmt = estPut._2
	483	+	let lpAssetId = estPut._7
	484	+	let status = parseIntValue(estPut._8)
	485	+	if (if (if (isGlobalShutdown())
	486	+	then true
	487	+	else (status == PoolPutDisabled))
	488	+	then true
	489	+	else (status == PoolShutdown))
	490	+	then throw(("Put operation is blocked by admin. Status = " + toString(status)))
	491	+	else {
	492	+	let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
	493	+	if ((emitInv == emitInv))
466	494		then {
467		-	let pmtAmtX18 = toX18(pmtAmt, amAssetDcm)
468		-	let diffByPriceAsset = (pmtAmtX18 - amAssetSwapX18)
469		-	let eqPriceAsset = fraction(diffByPriceAsset, inPrice, scale18)
470		-	let prAssetDiff = fraction((eqPriceAsset - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
471		-	if (true)
472		-	then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqPriceAsset = ") + toString(eqPriceAsset)) + " diffByPriceAsset = ") + toString(diffByPriceAsset)))
473		-	else true
	495	+	let lpTrnsfr = if (autoStake)
	496	+	then {
	497	+	let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
	498	+	if ((stakeInv == stakeInv))
	499	+	then nil
	500	+	else throw("Strict value is not equal to itself.")
	501	+	}
	502	+	else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
	503	+	(estPut._9 ++ lpTrnsfr)
474	504		}
475		-	else {
476		-	let pmtPrX18 = toX18(pmtAmt, prAssetDcm)
477		-	let diffByAmtAsset = (pmtPrX18 - prAssetSwapX18)
478		-	let eqAmtAsset = fraction(diffByAmtAsset, scale18, inPrice)
479		-	let amAssetDiff = fraction((eqAmtAsset - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
480		-	if (true)
481		-	then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqAmtAsset = ") + toString(eqAmtAsset)) + " diffByAmountAsset = ") + toString(diffByAmtAsset)))
482		-	else true
483		-	}
484		-	let estPut = estimatePutOperation(toBase58String(i.transactionId), 0, inAmtAmount, fromBase58String(amAssetId), inPrAmount, fromBase58String(prAssetId), toString(i.caller), false, true, true)
485		-	let emitLpAmt = estPut._2
486		-	let lpAssetId = estPut._7
487		-	let status = parseIntValue(estPut._8)
488		-	if (if (if (isGlobalShutdown())
489		-	then true
490		-	else (status == PoolPutDisabled))
491		-	then true
492		-	else (status == PoolShutdown))
493		-	then throw(("Put operation is blocked by admin. Status = " + toString(status)))
494		-	else {
495		-	let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
496		-	if ((emitInv == emitInv))
497		-	then {
498		-	let lpTrnsfr = if (autoStake)
499		-	then {
500		-	let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
501		-	if ((stakeInv == stakeInv))
502		-	then nil
503		-	else throw("Strict value is not equal to itself.")
504		-	}
505		-	else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
506		-	(estPut._9 ++ lpTrnsfr)
507		-	}
508		-	else throw("Strict value is not equal to itself.")
509		-	}
	505	+	else throw("Strict value is not equal to itself.")
510	506		}
511	507		}
512	508		}

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

github/deemru/w8io/169f3d6 
82.61 ms ◑