tx · HddKR35Sh4bfT3fqiLthS5mwP9AmLGNMwjFdHeTf3rNS

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.01400000 Waves

2021.12.19 22:55 [1841592] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 252bH56jGDYbjE8uJy96dMrJBpJrckFFZwGsE68PLXMQ
Next: wGBwx2dPek6HaZ8N8GVpwAgs34e4tqsqkveq9heqdXu

Diff: 

OldNewDifferences
446446     let cfg = getFactoryConfig()
447447     let stakingContract = valueOrErrorMessage(addressFromString(cfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
448448     let poolCfg = getPoolConfig()
449-    let amAssetId = cfg[idxAmtAssetId]
450-    let prAssetId = cfg[idxPriceAssetId]
451-    let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
452-    let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
449+    let amAssetId = poolCfg[idxAmtAssetId]
450+    let prAssetId = poolCfg[idxPriceAssetId]
451+    let amAssetDcm = parseIntValue(poolCfg[idxAmtAssetDcm])
452+    let prAssetDcm = parseIntValue(poolCfg[idxPriceAssetDcm])
453453     if ((size(i.payments) != 1))
454454         then throw("exactly 1 payment are expected")
455455         else {

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let lPdecimals = 8
55 
66 let scale8 = 100000000
77 
88 let scale8BigInt = toBigInt(100000000)
99 
1010 let calcError = toBigInt(1000000)
1111 
1212 let scale18 = toBigInt(1000000000000000000)
1313 
1414 let zeroBigInt = toBigInt(0)
1515 
1616 let SEP = "__"
1717 
1818 let EMPTY = ""
1919 
2020 let PoolActive = 1
2121 
2222 let PoolPutDisabled = 2
2323 
2424 let PoolMatcherDisabled = 3
2525 
2626 let PoolShutdown = 4
2727 
2828 let idxPoolAddress = 1
2929 
3030 let idxPoolStatus = 2
3131 
3232 let idxPoolLPAssetId = 3
3333 
3434 let idxAmtAssetId = 4
3535 
3636 let idxPriceAssetId = 5
3737 
3838 let idxAmtAssetDcm = 6
3939 
4040 let idxPriceAssetDcm = 7
4141 
4242 let idxIAmtAssetId = 8
4343 
4444 let idxIPriceAssetId = 9
4545 
4646 let idxLPAssetDcm = 10
4747 
4848 let idxPoolAmtAssetAmt = 1
4949 
5050 let idxPoolPriceAssetAmt = 2
5151 
5252 let idxPoolLPAssetAmt = 3
5353 
5454 let idxFactoryStakingContract = 1
5555 
5656 let idxFactorySlippageContract = 7
5757 
5858 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
5959 
6060 
6161 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
6262 
6363 
6464 func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
6565 
6666 
6767 func abs (val) = if ((zeroBigInt > val))
6868     then -(val)
6969     else val
7070 
7171 
7272 func keyFactoryContract () = "%s__factoryContract"
7373 
7474 
7575 func keyManagerPublicKey () = "%s__managerPublicKey"
7676 
7777 
7878 func keyPriceLast () = "%s%s__price__last"
7979 
8080 
8181 func keyPriceHistory (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
8282 
8383 
8484 func keyPutActionByUser (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
8585 
8686 
8787 func keyGetActionByUser (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
8888 
8989 
9090 func keyAmtAsset () = "%s__amountAsset"
9191 
9292 
9393 func keyPriceAsset () = "%s__priceAsset"
9494 
9595 
9696 func keyKHistoric (h,timestamp) = makeString(["%s%s%d%d__K_history", toString(h), toString(timestamp)], SEP)
9797 
9898 
9999 func keyFactoryConfig () = "%s__factoryConfig"
100100 
101101 
102102 func keyMatcherPub () = "%s%s__matcher__publicKey"
103103 
104104 
105105 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
106106 
107107 
108108 func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
109109 
110110 
111111 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
112112 
113113 
114114 func keyAllPoolsShutdown () = "%s__shutdown"
115115 
116116 
117117 func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
118118 
119119 
120120 func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
121121 
122122 
123123 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
124124 
125125 
126126 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
127127 
128128 
129129 let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactoryContract()))
130130 
131131 func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
132132 
133133 
134134 func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
135135 
136136 
137137 func getPoolConfig () = {
138138     let amtAsset = getStringOrFail(this, keyAmtAsset())
139139     let priceAsset = getStringOrFail(this, keyPriceAsset())
140140     let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
141141     let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
142142     split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
143143     }
144144 
145145 
146146 func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
147147 
148148 
149149 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)
150150 
151151 
152152 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)
153153 
154154 
155155 func getAccBalance (assetId) = if ((assetId == "WAVES"))
156156     then wavesBalance(this).available
157157     else assetBalance(this, fromBase58String(assetId))
158158 
159159 
160160 func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
161161 
162162 
163163 func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
164164     let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
165165     let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
166166     calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
167167     }
168168 
169169 
170170 func calcPrices (amAmt,prAmt,lpAmt) = {
171171     let cfg = getPoolConfig()
172172     let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
173173     let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
174174     let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
175175     let amAmtX18 = toX18(amAmt, amtAssetDcm)
176176     let prAmtX18 = toX18(prAmt, priceAssetDcm)
177177     let lpAmtX18 = toX18(lpAmt, scale8)
178178     let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
179179     let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
180180 [priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
181181     }
182182 
183183 
184184 func calculatePrices (amAmt,prAmt,lpAmt) = {
185185     let prices = calcPrices(amAmt, prAmt, lpAmt)
186186 [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
187187     }
188188 
189189 
190190 func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
191191     let cfg = getPoolConfig()
192192     let lpAssetId = cfg[idxPoolLPAssetId]
193193     let amAssetId = cfg[idxAmtAssetId]
194194     let prAssetId = cfg[idxPriceAssetId]
195195     let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
196196     let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
197197     let poolStatus = cfg[idxPoolStatus]
198198     let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
199199     if ((lpAssetId != pmtAssetId))
200200         then throw("Invalid asset passed.")
201201         else {
202202             let amBalance = getAccBalance(amAssetId)
203203             let amBalanceX18 = toX18(amBalance, amAssetDcm)
204204             let prBalance = getAccBalance(prAssetId)
205205             let prBalanceX18 = toX18(prBalance, prAssetDcm)
206206             let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
207207             let curPrice = fromX18(curPriceX18, scale8)
208208             let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
209209             let lpEmissionX18 = toX18(lpEmission, scale8)
210210             let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
211211             let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
212212             let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
213213             let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
214214             let state = if ((txId58 == ""))
215215                 then nil
216216                 else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
217217                     then unit
218218                     else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
219219                     then unit
220220                     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)]
221221             $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
222222             }
223223     }
224224 
225225 
226226 func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp,isOneAsset) = {
227227     let cfg = getPoolConfig()
228228     let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
229229     let amAssetIdStr = cfg[idxAmtAssetId]
230230     let prAssetIdStr = cfg[idxPriceAssetId]
231231     let inAmAssetIdStr = cfg[idxIAmtAssetId]
232232     let inPrAssetIdStr = cfg[idxIPriceAssetId]
233233     let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
234234     let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
235235     let poolStatus = cfg[idxPoolStatus]
236236     let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
237237     let amBalance = if (isEvaluate)
238238         then getAccBalance(amAssetIdStr)
239239         else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
240240     let prBalance = if (isEvaluate)
241241         then getAccBalance(prAssetIdStr)
242242         else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
243243     let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
244244     let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
245245     let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
246246     let amBalanceX18 = toX18(amBalance, amtAssetDcm)
247247     let prBalanceX18 = toX18(prBalance, priceAssetDcm)
248248     let res = if ((lpEmission == 0))
249249         then {
250250             let curPriceX18 = zeroBigInt
251251             let slippageX18 = zeroBigInt
252252             let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
253253             $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
254254             }
255255         else {
256256             let tRes = if (isOneAsset)
257257                 then {
258258                     let lpEmissionX18 = toX18(lpEmission, scale8)
259259                     let sumInAssets = (inAmAssetAmtX18 + inPrAssetAmtX18)
260260                     let sumPoolBalances = (amBalanceX18 + prBalanceX18)
261261                     let lpAmtX18 = fraction(lpEmissionX18, sumInAssets, sumPoolBalances)
262262                     let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
263263                     $Tuple5(fromX18(lpAmtX18, scale8), inAmAssetAmt, inPrAssetAmt, curPriceX18, toBigInt(0))
264264                     }
265265                 else {
266266                     let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
267267                     let slippageX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
268268                     let slippageToleranceX18 = toX18(slippageTolerance, scale8)
269269                     if (if ((curPriceX18 != zeroBigInt))
270270                         then (slippageX18 > slippageToleranceX18)
271271                         else false)
272272                         then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
273273                         else {
274274                             let lpEmissionX18 = toX18(lpEmission, scale8)
275275                             let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
276276                             let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
277277                             let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
278278                                 then $Tuple2(amViaPrX18, inPrAssetAmtX18)
279279                                 else $Tuple2(inAmAssetAmtX18, prViaAmX18)
280280                             let expAmtAssetAmtX18 = expectedAmts._1
281281                             let expPriceAssetAmtX18 = expectedAmts._2
282282                             let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
283283                             $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
284284                             }
285285                     }
286286             tRes
287287             }
288288     let calcLpAmt = res._1
289289     let calcAmAssetPmt = res._2
290290     let calcPrAssetPmt = res._3
291291     let curPrice = fromX18(res._4, scale8)
292292     let slippageCalc = fromX18(res._5, scale8)
293293     if ((0 >= calcLpAmt))
294294         then throw("Invalid calculations. LP calculated is less than zero.")
295295         else {
296296             let emitLpAmt = if (!(emitLp))
297297                 then 0
298298                 else calcLpAmt
299299             let amDiff = (inAmAssetAmt - calcAmAssetPmt)
300300             let prDiff = (inPrAssetAmt - calcPrAssetPmt)
301301             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))]
302302             $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
303303             }
304304     }
305305 
306306 
307307 func validateMatcherOrderAllowed (order) = {
308308     let cfg = getPoolConfig()
309309     let amtAssetId = cfg[idxAmtAssetId]
310310     let priceAssetId = cfg[idxPriceAssetId]
311311     let poolStatus = parseIntValue(cfg[idxPoolStatus])
312312     let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
313313     let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
314314     let accAmtAssetBalance = getAccBalance(amtAssetId)
315315     let accPriceAssetBalance = getAccBalance(priceAssetId)
316316     let curPriceX18 = if ((order.orderType == Buy))
317317         then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
318318         else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
319319     let curPrice = fromX18(curPriceX18, scale8)
320320     if (if (if (isGlobalShutdown())
321321         then true
322322         else (poolStatus == PoolMatcherDisabled))
323323         then true
324324         else (poolStatus == PoolShutdown))
325325         then throw("Exchange operations disabled")
326326         else {
327327             let orderAmtAsset = order.assetPair.amountAsset
328328             let orderAmtAssetStr = if ((orderAmtAsset == unit))
329329                 then "WAVES"
330330                 else toBase58String(value(orderAmtAsset))
331331             let orderPriceAsset = order.assetPair.priceAsset
332332             let orderPriceAssetStr = if ((orderPriceAsset == unit))
333333                 then "WAVES"
334334                 else toBase58String(value(orderPriceAsset))
335335             if (if ((orderAmtAssetStr != amtAssetId))
336336                 then true
337337                 else (orderPriceAssetStr != priceAssetId))
338338                 then throw("Wrong order assets.")
339339                 else {
340340                     let orderPrice = order.price
341341                     let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
342342                     let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
343343                     let isOrderPriceValid = if ((order.orderType == Buy))
344344                         then (curPrice >= castedOrderPrice)
345345                         else (castedOrderPrice >= curPrice)
346346                     true
347347                     }
348348             }
349349     }
350350 
351351 
352352 func commonGet (i) = if ((size(i.payments) != 1))
353353     then throw("exactly 1 payment is expected")
354354     else {
355355         let pmt = value(i.payments[0])
356356         let pmtAssetId = value(pmt.assetId)
357357         let pmtAmt = pmt.amount
358358         let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
359359         let outAmAmt = res._1
360360         let outPrAmt = res._2
361361         let poolStatus = parseIntValue(res._9)
362362         let state = res._10
363363         if (if (isGlobalShutdown())
364364             then true
365365             else (poolStatus == PoolShutdown))
366366             then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
367367             else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
368368         }
369369 
370370 
371371 func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
372372     then throw("exactly 2 payments are expected")
373373     else {
374374         let amAssetPmt = value(i.payments[0])
375375         let prAssetPmt = value(i.payments[1])
376376         let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp, false)
377377         let status = parseIntValue(estPut._8)
378378         if (if (if (isGlobalShutdown())
379379             then true
380380             else (status == PoolPutDisabled))
381381             then true
382382             else (status == PoolShutdown))
383383             then throw(("Put operation is blocked by admin. Status = " + toString(status)))
384384             else estPut
385385         }
386386 
387387 
388388 @Callable(i)
389389 func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
390390     then throw("permissions denied")
391391     else [StringEntry(keyFactoryContract(), factoryContract), StringEntry(keyManagerPublicKey(), managerPublicKey)]
392392 
393393 
394394 
395395 @Callable(i)
396396 func put (slippageTolerance,autoStake) = {
397397     let factoryCfg = getFactoryConfig()
398398     let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
399399     let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
400400     if ((0 > slippageTolerance))
401401         then throw("Invalid slippageTolerance passed")
402402         else {
403403             let estPut = commonPut(i, slippageTolerance, true)
404404             let emitLpAmt = estPut._2
405405             let lpAssetId = estPut._7
406406             let state = estPut._9
407407             let amDiff = estPut._10
408408             let prDiff = estPut._11
409409             let amId = estPut._12
410410             let prId = estPut._13
411411             let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
412412             if ((emitInv == emitInv))
413413                 then {
414414                     let slippageAInv = if ((amDiff > 0))
415415                         then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
416416                         else nil
417417                     if ((slippageAInv == slippageAInv))
418418                         then {
419419                             let slippagePInv = if ((prDiff > 0))
420420                                 then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
421421                                 else nil
422422                             if ((slippagePInv == slippagePInv))
423423                                 then {
424424                                     let lpTrnsfr = if (autoStake)
425425                                         then {
426426                                             let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
427427                                             if ((slpStakeInv == slpStakeInv))
428428                                                 then nil
429429                                                 else throw("Strict value is not equal to itself.")
430430                                             }
431431                                         else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
432432                                     (state ++ lpTrnsfr)
433433                                     }
434434                                 else throw("Strict value is not equal to itself.")
435435                             }
436436                         else throw("Strict value is not equal to itself.")
437437                     }
438438                 else throw("Strict value is not equal to itself.")
439439             }
440440     }
441441 
442442 
443443 
444444 @Callable(i)
445445 func putOneTkn (inAmtAmount,inPrAmount,autoStake) = {
446446     let cfg = getFactoryConfig()
447447     let stakingContract = valueOrErrorMessage(addressFromString(cfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
448448     let poolCfg = getPoolConfig()
449-    let amAssetId = cfg[idxAmtAssetId]
450-    let prAssetId = cfg[idxPriceAssetId]
451-    let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
452-    let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
449+    let amAssetId = poolCfg[idxAmtAssetId]
450+    let prAssetId = poolCfg[idxPriceAssetId]
451+    let amAssetDcm = parseIntValue(poolCfg[idxAmtAssetDcm])
452+    let prAssetDcm = parseIntValue(poolCfg[idxPriceAssetDcm])
453453     if ((size(i.payments) != 1))
454454         then throw("exactly 1 payment are expected")
455455         else {
456456             let pmt = value(i.payments[0])
457457             let pmtAssetId = value(pmt.assetId)
458458             let pmtAmt = pmt.amount
459459             let amAssetSwapX18 = toX18(inAmtAmount, amAssetDcm)
460460             let prAssetSwapX18 = toX18(inPrAmount, prAssetDcm)
461461             let inPrice = calcPriceBigInt(prAssetSwapX18, amAssetSwapX18)
462462             if (true)
463463                 then throw(((toBase58String(pmtAssetId) + " : ") + amAssetId))
464464                 else {
465465                     let isValid = if ((toBase58String(pmtAssetId) == amAssetId))
466466                         then {
467467                             let pmtAmtX18 = toX18(pmtAmt, amAssetDcm)
468468                             let diffByPriceAsset = (pmtAmtX18 - amAssetSwapX18)
469469                             let eqPriceAsset = fraction(diffByPriceAsset, inPrice, scale18)
470470                             let prAssetDiff = fraction((eqPriceAsset - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
471471                             if (true)
472472                                 then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqPriceAsset = ") + toString(eqPriceAsset)) + " diffByPriceAsset = ") + toString(diffByPriceAsset)))
473473                                 else true
474474                             }
475475                         else {
476476                             let pmtPrX18 = toX18(pmtAmt, prAssetDcm)
477477                             let diffByAmtAsset = (pmtPrX18 - prAssetSwapX18)
478478                             let eqAmtAsset = fraction(diffByAmtAsset, scale18, inPrice)
479479                             let amAssetDiff = fraction((eqAmtAsset - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
480480                             if (true)
481481                                 then throw(((((((("inAmtAmount = " + toString(amAssetSwapX18)) + " inPrAmount = ") + toString(prAssetSwapX18)) + " eqAmtAsset = ") + toString(eqAmtAsset)) + " diffByAmountAsset = ") + toString(diffByAmtAsset)))
482482                                 else true
483483                             }
484484                     let estPut = estimatePutOperation(toBase58String(i.transactionId), 0, inAmtAmount, fromBase58String(amAssetId), inPrAmount, fromBase58String(prAssetId), toString(i.caller), false, true, true)
485485                     let emitLpAmt = estPut._2
486486                     let lpAssetId = estPut._7
487487                     let status = parseIntValue(estPut._8)
488488                     if (if (if (isGlobalShutdown())
489489                         then true
490490                         else (status == PoolPutDisabled))
491491                         then true
492492                         else (status == PoolShutdown))
493493                         then throw(("Put operation is blocked by admin. Status = " + toString(status)))
494494                         else {
495495                             let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
496496                             if ((emitInv == emitInv))
497497                                 then {
498498                                     let lpTrnsfr = if (autoStake)
499499                                         then {
500500                                             let stakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
501501                                             if ((stakeInv == stakeInv))
502502                                                 then nil
503503                                                 else throw("Strict value is not equal to itself.")
504504                                             }
505505                                         else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
506506                                     (estPut._9 ++ lpTrnsfr)
507507                                     }
508508                                 else throw("Strict value is not equal to itself.")
509509                             }
510510                     }
511511             }
512512     }
513513 
514514 
515515 
516516 @Callable(i)
517517 func putForFree (maxSlippage) = if ((0 > maxSlippage))
518518     then throw("Invalid value passed")
519519     else {
520520         let estPut = commonPut(i, maxSlippage, false)
521521         estPut._9
522522         }
523523 
524524 
525525 
526526 @Callable(i)
527527 func get () = {
528528     let res = commonGet(i)
529529     let outAmtAmt = res._1
530530     let outPrAmt = res._2
531531     let pmtAmt = res._3
532532     let pmtAssetId = res._4
533533     let state = res._5
534534     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
535535     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
536536         then state
537537         else throw("Strict value is not equal to itself.")
538538     }
539539 
540540 
541541 
542542 @Callable(i)
543543 func getOneTkn (amAssetSwap,prAssetSwap,outAmount,outAssetId) = if ((size(i.payments) != 1))
544544     then throw("exactly 1 payment is expected")
545545     else {
546546         let cfg = getPoolConfig()
547547         let lpAssetId = cfg[idxPoolLPAssetId]
548548         let amAssetId = cfg[idxAmtAssetId]
549549         let prAssetId = cfg[idxPriceAssetId]
550550         let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
551551         let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
552552         let poolStatus = cfg[idxPoolStatus]
553553         if (if ((outAssetId != amAssetId))
554554             then (outAssetId != prAssetId)
555555             else false)
556556             then throw(("Incorrect out asset id passed: " + outAssetId))
557557             else {
558558                 let resultAssetId = if ((outAssetId == amAssetId))
559559                     then amAssetId
560560                     else prAssetId
561561                 let resultAmtAmount = if ((outAssetId == amAssetId))
562562                     then outAmount
563563                     else 0
564564                 let resultPrAmount = if ((outAssetId == prAssetId))
565565                     then outAmount
566566                     else 0
567567                 let pmt = value(i.payments[0])
568568                 let userAddress = i.caller
569569                 let txId58 = toBase58String(i.transactionId)
570570                 let pmtAssetId = value(pmt.assetId)
571571                 let pmtAmt = pmt.amount
572572                 if ((lpAssetId != toBase58String(pmtAssetId)))
573573                     then throw("Invalid asset passed.")
574574                     else {
575575                         let amAssetSwapX18 = toX18(amAssetSwap, amAssetDcm)
576576                         let prAssetSwapX18 = toX18(prAssetSwap, prAssetDcm)
577577                         let swapPriceX18 = calcPriceBigInt(prAssetSwapX18, amAssetSwapX18)
578578                         let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
579579                         let outAmAmt = r._1
580580                         let outPrAmt = r._2
581581                         let isValid = if ((outAssetId == amAssetId))
582582                             then {
583583                                 let prSwopPartInAmountAsset = (resultAmtAmount - outAmAmt)
584584                                 let convRes = fraction(toX18(prSwopPartInAmountAsset, amAssetDcm), swapPriceX18, scale18)
585585                                 let prAssetDiff = fraction((convRes - prAssetSwapX18), scale8BigInt, prAssetSwapX18)
586586                                 if (if ((prAssetDiff > calcError))
587587                                     then true
588588                                     else (-(calcError) > prAssetDiff))
589589                                     then throw(((("Slippage exeeded the value " + toString(calcError)) + " and equal to ") + toString(prAssetDiff)))
590590                                     else true
591591                                 }
592592                             else {
593593                                 let amSwopPartInPriceAsset = (resultPrAmount - outPrAmt)
594594                                 let convRes = fraction(toX18(amSwopPartInPriceAsset, amAssetDcm), scale18, swapPriceX18)
595595                                 let amAssetDiff = fraction((convRes - amAssetSwapX18), scale8BigInt, amAssetSwapX18)
596596                                 if (if ((amAssetDiff > calcError))
597597                                     then true
598598                                     else (-(calcError) > amAssetDiff))
599599                                     then throw(((("Slippage exeeded the value " + toString(calcError)) + " and equal to ") + toString(amAssetDiff)))
600600                                     else true
601601                                 }
602602                         let amBalance = getAccBalance(amAssetId)
603603                         let amBalanceX18 = toX18(amBalance, amAssetDcm)
604604                         let prBalance = getAccBalance(prAssetId)
605605                         let prBalanceX18 = toX18(prBalance, prAssetDcm)
606606                         let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
607607                         let curPrice = fromX18(curPriceX18, scale8)
608608                         let state = [ScriptTransfer(userAddress, outAmount, if ((resultAssetId == "WAVES"))
609609                             then unit
610610                             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)]
611611                         let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
612612                         if ((burn == burn))
613613                             then state
614614                             else throw("Strict value is not equal to itself.")
615615                         }
616616                 }
617617         }
618618 
619619 
620620 
621621 @Callable(i)
622622 func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
623623     let res = commonGet(i)
624624     let outAmAmt = res._1
625625     let outPrAmt = res._2
626626     let pmtAmt = res._3
627627     let pmtAssetId = res._4
628628     let state = res._5
629629     if ((noLessThenAmtAsset > outAmAmt))
630630         then throw(((("noLessThenAmtAsset failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
631631         else if ((noLessThenPriceAsset > outPrAmt))
632632             then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
633633             else {
634634                 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
635635                 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
636636                     then state
637637                     else throw("Strict value is not equal to itself.")
638638                 }
639639     }
640640 
641641 
642642 
643643 @Callable(i)
644644 func unstakeAndGet (amount) = {
645645     let checkPayments = if ((size(i.payments) != 0))
646646         then throw("No payments are expected")
647647         else true
648648     if ((checkPayments == checkPayments))
649649         then {
650650             let cfg = getPoolConfig()
651651             let factoryCfg = getFactoryConfig()
652652             let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
653653             let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
654654             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
655655             if ((unstakeInv == unstakeInv))
656656                 then {
657657                     let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
658658                     let poolStatus = parseIntValue(res._9)
659659                     let state = res._10
660660                     let checkPoolStatus = if (if (isGlobalShutdown())
661661                         then true
662662                         else (poolStatus == PoolShutdown))
663663                         then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
664664                         else true
665665                     if ((checkPoolStatus == checkPoolStatus))
666666                         then {
667667                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
668668                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
669669                                 then state
670670                                 else throw("Strict value is not equal to itself.")
671671                             }
672672                         else throw("Strict value is not equal to itself.")
673673                     }
674674                 else throw("Strict value is not equal to itself.")
675675             }
676676         else throw("Strict value is not equal to itself.")
677677     }
678678 
679679 
680680 
681681 @Callable(i)
682682 func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
683683     then throw("permissions denied")
684684     else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
685685 
686686 
687687 
688688 @Callable(i)
689689 func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
690690 
691691 
692692 
693693 @Callable(i)
694694 func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
695695 
696696 
697697 
698698 @Callable(i)
699699 func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
700700     let prices = calcPrices(amAmt, prAmt, lpAmt)
701701     $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
702702     }
703703 
704704 
705705 
706706 @Callable(i)
707707 func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
708708 
709709 
710710 
711711 @Callable(i)
712712 func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
713713 
714714 
715715 
716716 @Callable(i)
717717 func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
718718 
719719 
720720 
721721 @Callable(i)
722722 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))
723723 
724724 
725725 
726726 @Callable(i)
727727 func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
728728     let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
729729     $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
730730     }
731731 
732732 
733733 @Verifier(tx)
734734 func verify () = match tx {
735735     case order: Order => 
736736         let matcherPub = getMatcherPubOrFail()
737737         let orderValid = validateMatcherOrderAllowed(order)
738738         let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
739739         let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
740740         if (if (if (orderValid)
741741             then senderValid
742742             else false)
743743             then matcherValid
744744             else false)
745745             then true
746746             else throwOrderError(orderValid, senderValid, matcherValid)
747747     case _ => 
748748         let managerPublic = valueOrElse(getString(this, keyManagerPublicKey()), EMPTY)
749749         if ((managerPublic == EMPTY))
750750             then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
751751             else sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(managerPublic))
752752 }
753753 
github/deemru/w8io/169f3d6 
108.98 ms ◑