tx · CeftPtPctkMfhkkuebUVxHcircebAfkRrZyWUfHJVLKQ

3N2rcyriCEdhEj4exvjYdSW3afoRPa54PJL:  -0.01000000 Waves

2021.09.29 14:47 [1724207] smart account 3N2rcyriCEdhEj4exvjYdSW3afoRPa54PJL > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CeftPtPctkMfhkkuebUVxHcircebAfkRrZyWUfHJVLKQ",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1632916025516,
    "version": 1,
    "sender": "3N2rcyriCEdhEj4exvjYdSW3afoRPa54PJL",
    "senderPublicKey": "HcYUcARjSQ9s6sNtiBY85skwJEowirwR4zUZmdVFtQq3",
    "proofs": [
        "zngaSN46Kk7MqMDDiHYiYzX2TRSpC3dACckZ8PzZ46he6Ka5UjGLLPwaJbU4SeF2jTKRRJrHxQD5FGu7X2chKsU"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1724207,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 5yztQop6MHd879EdnPTmsMAy4dSVWYuuAiroMT8kVFYd

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let lPdecimals = 8
5+
6+let scale8 = 100000000
7+
8+let scale8BigInt = toBigInt(100000000)
9+
10+let scale18 = toBigInt(1000000000000000000)
11+
12+let SEP = "__"
13+
14+let PoolActive = 1
15+
16+let PoolPutDisabled = 2
17+
18+let PoolMatcherDisabled = 3
19+
20+let PoolShutdown = 4
21+
22+let idxPoolAddress = 1
23+
24+let idxPoolStatus = 2
25+
26+let idxPoolLPAssetId = 3
27+
28+let idxAmountAssetId = 4
29+
30+let idxPriceAssetId = 5
31+
32+let idxAmountAssetDecimals = 6
33+
34+let idxPriceAssetDecimals = 7
35+
36+let idxAmountAssetInternalId = 8
37+
38+let idxPriceAssetInternalId = 9
39+
40+let idxLPAssetDecimals = 10
41+
42+let idxMatcherPublicKey = 11
43+
44+let idxPoolAmountAssetAmt = 1
45+
46+let idxPoolPriceAssetAmt = 2
47+
48+let idxPoolLPAssetAmt = 3
49+
50+let idxFactoryStakingContract = 1
51+
52+let idxFactoryBoostingConfig = 2
53+
54+func keyFactoryContract () = "%s__factoryContract"
55+
56+
57+func keyPriceLast () = "%s%s__price__last"
58+
59+
60+func keyPriceHistory (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
61+
62+
63+func keyPoolLiquidity (internalAmountAsset,internalPriceAsset) = (((("%d%d%s__" + internalAmountAsset) + "__") + internalPriceAsset) + "__locked")
64+
65+
66+func keyPutActionByUser (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
67+
68+
69+func keyGetActionByUser (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
70+
71+
72+func keyAmountAsset () = "%s__amountAsset"
73+
74+
75+func keyPriceAsset () = "%s__priceAsset"
76+
77+
78+func keyKCurrent () = "%s%s__K_current"
79+
80+
81+func keyKHistoric (h,timestamp) = makeString(["%s%s%d%d__K_history", toString(h), toString(timestamp)], SEP)
82+
83+
84+func keyFactoryConfig () = "%s__factoryConfig"
85+
86+
87+func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
88+
89+
90+func keyPoolConfig (amountAssetInternal,priceAssetInternal) = (((("%d%d%s__" + amountAssetInternal) + "__") + priceAssetInternal) + "__config")
91+
92+
93+func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
94+
95+
96+func keyAllPoolsShutdown () = "%s__shutdown"
97+
98+
99+func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
100+
101+
102+let factoryContract = addressFromStringValue(valueOrErrorMessage(getString(this, keyFactoryContract()), "No Factory Account found."))
103+
104+func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
105+
106+
107+func getPoolConfig () = {
108+    let poolAmountAsset = valueOrErrorMessage(getString(this, keyAmountAsset()), "No config for amount asset found")
109+    let poolPriceAsset = valueOrErrorMessage(getString(this, keyPriceAsset()), "No config for price asset found")
110+    let poolPriceAssetInternal = valueOrErrorMessage(getInteger(factoryContract, keyMappingsBaseAsset2internalId(poolPriceAsset)), "No config for internal price asset found")
111+    let poolAmountAssetInternal = valueOrErrorMessage(getInteger(factoryContract, keyMappingsBaseAsset2internalId(poolAmountAsset)), "No config for internal amount asset found")
112+    split(valueOrErrorMessage(getString(factoryContract, keyPoolConfig(toString(poolAmountAssetInternal), toString(poolPriceAssetInternal))), "No factory config found for pool assets."), SEP)
113+    }
114+
115+
116+func getFactoryConfig () = split(valueOrErrorMessage(getString(factoryContract, keyFactoryConfig()), "No factory config found."), SEP)
117+
118+
119+func getPoolLiquidity (amountAssetInternalId,priceAssetInternalId) = {
120+    let currentPoolLiquidityValue = getString(this, keyPoolLiquidity(amountAssetInternalId, priceAssetInternalId))
121+    if (isDefined(currentPoolLiquidityValue))
122+        then split(value(currentPoolLiquidityValue), SEP)
123+        else ["", "0", "0", "0"]
124+    }
125+
126+
127+func dataPoolLiquidity (amountAssetLocked,priceAssetLocked,lpTokenLocked) = makeString(["%d%d%d", toString(amountAssetLocked), toString(priceAssetLocked), toString(lpTokenLocked)], SEP)
128+
129+
130+func dataPutActionInfo (inAmountAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d%d", toString(inAmountAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp)], SEP)
131+
132+
133+func dataGetActionInfo (outAmountAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmountAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
134+
135+
136+func privateCastToScaleOf (amount,resultScale,currentScale) = fraction(amount, resultScale, currentScale)
137+
138+
139+func privateBigIntCastToScaleOf (amount,resultScale,currentScale) = fraction(amount, resultScale, currentScale)
140+
141+
142+func calculatePrice (priceAssetLockedAmt,amountAssetlLockedAmt) = fraction(priceAssetLockedAmt, scale8, amountAssetlLockedAmt)
143+
144+
145+func calculatePriceBigInt (priceAssetLockedAmt,amountAssetlLockedAmt) = toInt(fraction(priceAssetLockedAmt, scale8BigInt, amountAssetlLockedAmt))
146+
147+
148+func privateCalculatePrice (amoutAssetDecimals,priceAssetDecimals,amountAssetAmt,priceAssetAmt) = {
149+    let amountAssetAmtCasted = privateCastToScaleOf(amountAssetAmt, scale8, amoutAssetDecimals)
150+    let priceAssetAmtCasted = privateCastToScaleOf(priceAssetAmt, scale8, priceAssetDecimals)
151+    calculatePrice(priceAssetAmtCasted, amountAssetAmtCasted)
152+    }
153+
154+
155+func privateGetAccountBalance (assetId) = if ((assetId == "WAVES"))
156+    then wavesBalance(this).available
157+    else assetBalance(this, fromBase58String(assetId))
158+
159+
160+func calculatePrices (amountAssetAmt,priceAssetAmt,lpAmount) = {
161+    let poolConfigDataList = getPoolConfig()
162+    let amoutAssetDecimals = parseIntValue(poolConfigDataList[idxAmountAssetDecimals])
163+    let priceAssetDecimals = parseIntValue(poolConfigDataList[idxPriceAssetDecimals])
164+    let poolPrice = privateCalculatePrice(amoutAssetDecimals, priceAssetDecimals, amountAssetAmt, priceAssetAmt)
165+    let amountAssetPoolLockedAmt = privateCastToScaleOf(amountAssetAmt, scale8, amoutAssetDecimals)
166+    let priceAssetPoolLockedAmt = privateCastToScaleOf(priceAssetAmt, scale8, priceAssetDecimals)
167+    let lpPriceInAmountAsset = calculatePrice(amountAssetPoolLockedAmt, lpAmount)
168+    let lpPriceInPriceAsset = calculatePrice(priceAssetPoolLockedAmt, lpAmount)
169+[poolPrice, lpPriceInAmountAsset, lpPriceInPriceAsset]
170+    }
171+
172+
173+func privateEstimateGetOperation (paymentLpAssetId,paymentLpAmount,userAddress) = {
174+    let poolConfigList = getPoolConfig()
175+    let lpAssetId = poolConfigList[idxPoolLPAssetId]
176+    let amountAssetId = poolConfigList[idxAmountAssetId]
177+    let priceAssetId = poolConfigList[idxPriceAssetId]
178+    let amountAssetInternalId = poolConfigList[idxAmountAssetInternalId]
179+    let priceAssetInternalId = poolConfigList[idxPriceAssetInternalId]
180+    let amoutAssetDecimals = parseIntValue(poolConfigList[idxAmountAssetDecimals])
181+    let priceAssetDecimals = parseIntValue(poolConfigList[idxPriceAssetDecimals])
182+    let poolStatus = poolConfigList[idxPoolStatus]
183+    let poolLiquidityList = getPoolLiquidity(amountAssetInternalId, priceAssetInternalId)
184+    let poolLPBalance = parseIntValue(poolLiquidityList[idxPoolLPAssetAmt])
185+    let poolAmountAssetBalance = parseIntValue(poolLiquidityList[idxPoolAmountAssetAmt])
186+    let poolPriceAssetBalance = parseIntValue(poolLiquidityList[idxPoolPriceAssetAmt])
187+    if ((lpAssetId != paymentLpAssetId))
188+        then throw("Invalid asset passed.")
189+        else {
190+            let amountAssetPoolLockedAmt = privateBigIntCastToScaleOf(toBigInt(privateGetAccountBalance(amountAssetId)), scale18, toBigInt(amoutAssetDecimals))
191+            let priceAssetPoolLockedAmt = privateBigIntCastToScaleOf(toBigInt(privateGetAccountBalance(priceAssetId)), scale18, toBigInt(priceAssetDecimals))
192+            let currentPrice = calculatePriceBigInt(priceAssetPoolLockedAmt, amountAssetPoolLockedAmt)
193+            let paymentLpAmountBuf = privateBigIntCastToScaleOf(toBigInt(paymentLpAmount), scale18, scale8BigInt)
194+            let poolLPBalanceBuf = privateBigIntCastToScaleOf(toBigInt(poolLPBalance), scale18, scale8BigInt)
195+            let outAmountAssetAmt = fraction(amountAssetPoolLockedAmt, paymentLpAmountBuf, poolLPBalanceBuf)
196+            let outPriceAssetAmt = fraction(priceAssetPoolLockedAmt, paymentLpAmountBuf, poolLPBalanceBuf)
197+            let outAmountAssetAmtFinal = toInt(privateBigIntCastToScaleOf(outAmountAssetAmt, toBigInt(amoutAssetDecimals), scale18))
198+            let outPriceAssetAmtFinal = toInt(privateBigIntCastToScaleOf(outPriceAssetAmt, toBigInt(priceAssetDecimals), scale18))
199+            $Tuple11(outAmountAssetAmtFinal, outPriceAssetAmtFinal, amountAssetInternalId, priceAssetInternalId, amountAssetId, priceAssetId, poolAmountAssetBalance, poolPriceAssetBalance, poolLPBalance, currentPrice, poolStatus)
200+            }
201+    }
202+
203+
204+func privateEstimatePutOperation (slippageTolerance,inAmountAssetAmt,inAmountAssetId,inPriceAssetAmt,inPriceAssetId,userAddress,isEvaluate) = {
205+    let poolConfigDataList = getPoolConfig()
206+    let lpAssetId = fromBase58String(poolConfigDataList[idxPoolLPAssetId])
207+    let amountAssetId = poolConfigDataList[idxAmountAssetId]
208+    let priceAssetId = poolConfigDataList[idxPriceAssetId]
209+    let amountAssetInternalId = poolConfigDataList[idxAmountAssetInternalId]
210+    let priceAssetInternalId = poolConfigDataList[idxPriceAssetInternalId]
211+    let amoutAssetDecimals = parseIntValue(poolConfigDataList[idxAmountAssetDecimals])
212+    let priceAssetDecimals = parseIntValue(poolConfigDataList[idxPriceAssetDecimals])
213+    let poolStatus = poolConfigDataList[idxPoolStatus]
214+    let poolLiquidityDataList = getPoolLiquidity(amountAssetInternalId, priceAssetInternalId)
215+    let poolAmountAssetBalance = parseIntValue(poolLiquidityDataList[idxPoolAmountAssetAmt])
216+    let poolPriceAssetBalance = parseIntValue(poolLiquidityDataList[idxPoolPriceAssetAmt])
217+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
218+    if (if ((amountAssetId != inAmountAssetId))
219+        then true
220+        else (priceAssetId != inPriceAssetId))
221+        then throw("Invalid amount or price asset passed.")
222+        else {
223+            let accountAmountAssetBalance = if (isEvaluate)
224+                then privateGetAccountBalance(amountAssetId)
225+                else (privateGetAccountBalance(amountAssetId) - inAmountAssetAmt)
226+            let accountPriceAssetBalance = if (isEvaluate)
227+                then privateGetAccountBalance(priceAssetId)
228+                else (privateGetAccountBalance(priceAssetId) - inPriceAssetAmt)
229+            let amoutAssetDecimalsBigInt = toBigInt(amoutAssetDecimals)
230+            let priceAssetDecimalsBigInt = toBigInt(priceAssetDecimals)
231+            let inAmountAssetAmtCalculated = privateBigIntCastToScaleOf(toBigInt(inAmountAssetAmt), scale18, amoutAssetDecimalsBigInt)
232+            let inPriceAssetAmtCalculated = privateBigIntCastToScaleOf(toBigInt(inPriceAssetAmt), scale18, priceAssetDecimalsBigInt)
233+            let userPrice = calculatePriceBigInt(inPriceAssetAmtCalculated, inAmountAssetAmtCalculated)
234+            let amountAssetPoolLockedAmt = privateBigIntCastToScaleOf(toBigInt(accountAmountAssetBalance), scale18, amoutAssetDecimalsBigInt)
235+            let priceAssetPoolLockedAmt = privateBigIntCastToScaleOf(toBigInt(accountPriceAssetBalance), scale18, priceAssetDecimalsBigInt)
236+            let curentPrice = if ((poolLPBalance == 0))
237+                then 0
238+                else calculatePriceBigInt(priceAssetPoolLockedAmt, amountAssetPoolLockedAmt)
239+            let slippage = if ((curentPrice == 0))
240+                then 0
241+                else if ((curentPrice > userPrice))
242+                    then fraction((curentPrice - userPrice), 100, curentPrice)
243+                    else fraction((userPrice - curentPrice), 100, curentPrice)
244+            if (if ((curentPrice != 0))
245+                then ((slippage * scale8) > slippageTolerance)
246+                else false)
247+                then throw(((("Price slippage " + toString((slippage * scale8))) + " exceeded the passed limit of ") + toString(slippageTolerance)))
248+                else {
249+                    let finalPrice = calculatePriceBigInt((priceAssetPoolLockedAmt + inPriceAssetAmtCalculated), (amountAssetPoolLockedAmt + inAmountAssetAmtCalculated))
250+                    let outLpAmount = if ((poolLPBalance == 0))
251+                        then {
252+                            let lpResultBuf = pow((inAmountAssetAmtCalculated * inPriceAssetAmtCalculated), 0, toBigInt(5), 1, 0, DOWN)
253+                            toInt(privateBigIntCastToScaleOf(lpResultBuf, scale8BigInt, scale18))
254+                            }
255+                        else {
256+                            let poolLPBalanceBuf = privateBigIntCastToScaleOf(toBigInt(poolLPBalance), scale18, scale8BigInt)
257+                            let lpAmtByAmountAsset = toInt(privateBigIntCastToScaleOf(fraction(poolLPBalanceBuf, inAmountAssetAmtCalculated, amountAssetPoolLockedAmt), scale8BigInt, scale18))
258+                            let lpAmtByPriceAsset = toInt(privateBigIntCastToScaleOf(fraction(poolLPBalanceBuf, inPriceAssetAmtCalculated, priceAssetPoolLockedAmt), scale8BigInt, scale18))
259+                            if ((lpAmtByPriceAsset > lpAmtByAmountAsset))
260+                                then lpAmtByAmountAsset
261+                                else lpAmtByPriceAsset
262+                            }
263+                    if ((0 >= outLpAmount))
264+                        then throw("Invalid calculations. LP calculated is less than zero.")
265+                        else $Tuple10(outLpAmount, finalPrice, poolAmountAssetBalance, poolPriceAssetBalance, poolLPBalance, amountAssetInternalId, priceAssetInternalId, lpAssetId, slippage, poolStatus)
266+                    }
267+            }
268+    }
269+
270+
271+func validateMatcherOrderAllowed (order) = {
272+    let poolConfigDataList = getPoolConfig()
273+    let amountAssetId = poolConfigDataList[idxAmountAssetId]
274+    let priceAssetId = poolConfigDataList[idxPriceAssetId]
275+    let poolStatus = parseIntValue(poolConfigDataList[idxPoolStatus])
276+    let matcherPublicKeyStr = poolConfigDataList[idxMatcherPublicKey]
277+    let amountAssetDecimals = parseIntValue(poolConfigDataList[idxAmountAssetDecimals])
278+    let priceAssetDecimals = parseIntValue(poolConfigDataList[idxPriceAssetDecimals])
279+    let accountAmountAssetBalance = privateGetAccountBalance(amountAssetId)
280+    let accountPriceAssetBalance = privateGetAccountBalance(priceAssetId)
281+    let currentPrice = if ((order.orderType == Buy))
282+        then privateCalculatePrice(amountAssetDecimals, priceAssetDecimals, (accountAmountAssetBalance + order.amount), accountPriceAssetBalance)
283+        else privateCalculatePrice(amountAssetDecimals, priceAssetDecimals, (accountAmountAssetBalance + order.amount), accountPriceAssetBalance)
284+    let isPoolStatusValid = if (if (if (isGlobalShutdown())
285+        then true
286+        else (poolStatus == PoolMatcherDisabled))
287+        then true
288+        else (poolStatus == PoolShutdown))
289+        then false
290+        else true
291+    let isValidMatcherSign = true
292+    let orderAmountAsset = order.assetPair.amountAsset
293+    let orderAmountAssetStr = if ((orderAmountAsset == unit))
294+        then "WAVES"
295+        else toBase58String(value(orderAmountAsset))
296+    let orderPriceAsset = order.assetPair.priceAsset
297+    let orderPriceAssetStr = if ((orderPriceAsset == unit))
298+        then "WAVES"
299+        else toBase58String(value(orderPriceAsset))
300+    let isValidAssetPair = if (if ((orderAmountAssetStr != amountAssetId))
301+        then true
302+        else (orderPriceAssetStr != priceAssetId))
303+        then false
304+        else true
305+    let orderPrice = order.price
306+    let priceDecimals = fraction(scale8, priceAssetDecimals, amountAssetDecimals)
307+    let castedOrderPrice = privateCastToScaleOf(orderPrice, scale8, priceDecimals)
308+    let isOrderPriceValid = if ((order.orderType == Buy))
309+        then (currentPrice >= castedOrderPrice)
310+        else (castedOrderPrice >= currentPrice)
311+    if (if (if (isValidAssetPair)
312+        then isValidMatcherSign
313+        else false)
314+        then isPoolStatusValid
315+        else false)
316+        then isOrderPriceValid
317+        else false
318+    }
319+
320+
321+@Callable(i)
322+func constructor (factoryContract) = if ((i.caller != this))
323+    then throw("permissions denied")
324+    else [StringEntry(keyFactoryContract(), factoryContract)]
325+
326+
327+
328+@Callable(i)
329+func put (slippageTolerance,shouldAutoStake) = {
330+    let factoryConfigList = getFactoryConfig()
331+    let stakingContract = valueOrErrorMessage(addressFromString(factoryConfigList[idxFactoryStakingContract]), "Error. Incorrect staking address.")
332+    let pmtAmountAsset = value(i.payments[0])
333+    let inAmountAssetAmt = pmtAmountAsset.amount
334+    let inAmountAssetId = if (!(isDefined(pmtAmountAsset.assetId)))
335+        then fromBase58String("WAVES")
336+        else value(pmtAmountAsset.assetId)
337+    let pmtPriceAsset = value(i.payments[1])
338+    let inPriceAssetAmt = pmtPriceAsset.amount
339+    let inPriceAssetId = if (!(isDefined(pmtPriceAsset.assetId)))
340+        then fromBase58String("WAVES")
341+        else value(pmtPriceAsset.assetId)
342+    let estimatedPutResults = privateEstimatePutOperation(slippageTolerance, inAmountAssetAmt, toBase58String(inAmountAssetId), inPriceAssetAmt, toBase58String(inPriceAssetId), toString(i.caller), false)
343+    let outLpAmount = estimatedPutResults._1
344+    let curentPrice = estimatedPutResults._2
345+    let poolAmountAssetBalance = estimatedPutResults._3
346+    let poolPriceAssetBalance = estimatedPutResults._4
347+    let poolLPBalance = estimatedPutResults._5
348+    let amountAssetInternalId = estimatedPutResults._6
349+    let priceAssetInternalId = estimatedPutResults._7
350+    let lpAssetId = estimatedPutResults._8
351+    let slippageCalculated = estimatedPutResults._9
352+    let poolStatus = parseIntValue(estimatedPutResults._10)
353+    if (if (if (isGlobalShutdown())
354+        then true
355+        else (poolStatus == PoolPutDisabled))
356+        then true
357+        else (poolStatus == PoolShutdown))
358+        then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
359+        else {
360+            let emitLPAssetOnFactory = invoke(factoryContract, "emit", [outLpAmount], nil)
361+            if ((emitLPAssetOnFactory == emitLPAssetOnFactory))
362+                then if ((emitLPAssetOnFactory != "success"))
363+                    then throw("LP asset reissue failed during emit call on factory.")
364+                    else {
365+                        let results = [StringEntry(keyPriceLast(), ("%s__" + toString(curentPrice))), StringEntry(keyPriceHistory(height, lastBlock.timestamp), ("%s__" + toString(curentPrice))), StringEntry(keyPutActionByUser(toString(i.caller), toBase58String(i.transactionId)), dataPutActionInfo(inAmountAssetAmt, inPriceAssetAmt, outLpAmount, curentPrice, slippageTolerance, slippageCalculated, height, lastBlock.timestamp)), StringEntry(keyPoolLiquidity(amountAssetInternalId, priceAssetInternalId), dataPoolLiquidity((poolAmountAssetBalance + inAmountAssetAmt), (poolPriceAssetBalance + inPriceAssetAmt), (poolLPBalance + outLpAmount)))]
366+                        if (shouldAutoStake)
367+                            then {
368+                                let stake = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, outLpAmount)])
369+                                if ((stake == stake))
370+                                    then results
371+                                    else throw("Strict value is not equal to itself.")
372+                                }
373+                            else (results :+ ScriptTransfer(i.caller, outLpAmount, lpAssetId))
374+                        }
375+                else throw("Strict value is not equal to itself.")
376+            }
377+    }
378+
379+
380+
381+@Callable(i)
382+func get () = {
383+    let pmtAmountAsset = value(i.payments[0])
384+    let pmtAssetId = value(pmtAmountAsset.assetId)
385+    let pmtAssetAmount = pmtAmountAsset.amount
386+    let results = privateEstimateGetOperation(toBase58String(pmtAssetId), pmtAssetAmount, toString(i.caller))
387+    let outAmountAssetAmt = results._1
388+    let outPriceAssetAmt = results._2
389+    let amountAssetInternalId = results._3
390+    let priceAssetInternalId = results._4
391+    let amountAssetId = results._5
392+    let priceAssetId = results._6
393+    let poolAmountAssetBalance = results._7
394+    let poolPriceAssetBalance = results._8
395+    let poolLPBalance = results._9
396+    let currentPrice = results._10
397+    let poolStatus = parseIntValue(results._11)
398+    if (if (isGlobalShutdown())
399+        then true
400+        else (poolStatus == PoolShutdown))
401+        then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
402+        else {
403+            let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAssetAmount], [AttachedPayment(pmtAssetId, pmtAssetAmount)])
404+            if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
405+                then if ((burnLPAssetOnFactory != "success"))
406+                    then throw("LP asset burn failed during emit call on factory.")
407+                    else [ScriptTransfer(i.caller, outAmountAssetAmt, if ((amountAssetId == "WAVES"))
408+                        then unit
409+                        else fromBase58String(amountAssetId)), ScriptTransfer(i.caller, outPriceAssetAmt, fromBase58String(priceAssetId)), StringEntry(keyPoolLiquidity(amountAssetInternalId, priceAssetInternalId), dataPoolLiquidity((poolAmountAssetBalance - outAmountAssetAmt), (poolPriceAssetBalance - outPriceAssetAmt), (poolLPBalance - pmtAssetAmount))), StringEntry(keyGetActionByUser(toString(i.caller), toBase58String(i.transactionId)), dataGetActionInfo(outAmountAssetAmt, outPriceAssetAmt, pmtAssetAmount, currentPrice, height, lastBlock.timestamp)), StringEntry(keyPriceLast(), ("%s__" + toString(currentPrice))), StringEntry(keyPriceHistory(height, lastBlock.timestamp), ("%s__" + toString(currentPrice)))]
410+                else throw("Strict value is not equal to itself.")
411+            }
412+    }
413+
414+
415+
416+@Callable(i)
417+func activate (amountAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
418+    then throw("permissions denied")
419+    else $Tuple2([StringEntry(keyAmountAsset(), amountAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
420+
421+
422+
423+@Callable(i)
424+func statsREADONLY () = {
425+    let poolConfigDataList = getPoolConfig()
426+    let lpAssetId = fromBase58String(poolConfigDataList[idxPoolLPAssetId])
427+    let amountAssetId = poolConfigDataList[idxAmountAssetId]
428+    let priceAssetId = poolConfigDataList[idxPriceAssetId]
429+    let amountAssetInternalId = poolConfigDataList[idxAmountAssetInternalId]
430+    let priceAssetInternalId = poolConfigDataList[idxPriceAssetInternalId]
431+    let amoutAssetDecimals = parseIntValue(poolConfigDataList[idxAmountAssetDecimals])
432+    let priceAssetDecimals = parseIntValue(poolConfigDataList[idxPriceAssetDecimals])
433+    let poolLiquidityDataList = getPoolLiquidity(amountAssetInternalId, priceAssetInternalId)
434+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
435+    let accountAmountAssetBalance = privateGetAccountBalance(amountAssetId)
436+    let accountPriceAssetBalance = privateGetAccountBalance(priceAssetId)
437+    let pricesList = calculatePrices(accountAmountAssetBalance, accountPriceAssetBalance, poolLPBalance)
438+    let currentPrice = pricesList[0]
439+    let lpAmountAssetShare = pricesList[1]
440+    let lpPriceAssetShare = pricesList[2]
441+    let poolWeight = valueOrErrorMessage(getInteger(factoryContract, keyPoolWeight(toString(this))), "Pool doesn't have weight.")
442+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accountAmountAssetBalance), toString(accountPriceAssetBalance), toString(poolLPBalance), toString(currentPrice), toString(lpAmountAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
443+    }
444+
445+
446+
447+@Callable(i)
448+func evaluatePutByAmountAssetREADONLY (slippageTolerance,inAmountAssetAmt,userAddress) = {
449+    let poolConfigDataList = getPoolConfig()
450+    let lpAssetId = fromBase58String(poolConfigDataList[idxPoolLPAssetId])
451+    let amountAssetId = poolConfigDataList[idxAmountAssetId]
452+    let priceAssetId = poolConfigDataList[idxPriceAssetId]
453+    let amountAssetInternalId = poolConfigDataList[idxAmountAssetInternalId]
454+    let priceAssetInternalId = poolConfigDataList[idxPriceAssetInternalId]
455+    let amoutAssetDecimals = parseIntValue(poolConfigDataList[idxAmountAssetDecimals])
456+    let priceAssetDecimals = parseIntValue(poolConfigDataList[idxPriceAssetDecimals])
457+    let poolStatus = poolConfigDataList[idxPoolStatus]
458+    let poolLiquidityDataList = getPoolLiquidity(amountAssetInternalId, priceAssetInternalId)
459+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
460+    let accountAmountAssetBalance = privateGetAccountBalance(amountAssetId)
461+    let accountPriceAssetBalance = privateGetAccountBalance(priceAssetId)
462+    let accountAmountAssetBalanceCasted = privateCastToScaleOf(accountAmountAssetBalance, scale8, amoutAssetDecimals)
463+    let accountPriceAssetBalanceCasted = privateCastToScaleOf(accountPriceAssetBalance, scale8, priceAssetDecimals)
464+    let curentPrice = if ((poolLPBalance == 0))
465+        then 0
466+        else calculatePrice(accountPriceAssetBalanceCasted, accountAmountAssetBalanceCasted)
467+    let inPriceAssetAmtCalculated = fraction(inAmountAssetAmt, curentPrice, scale8)
468+    let inPriceAssetAmt = privateCastToScaleOf(inPriceAssetAmtCalculated, priceAssetDecimals, scale8)
469+    let estimatedPutResults = privateEstimatePutOperation(slippageTolerance, inAmountAssetAmt, amountAssetId, inPriceAssetAmt, priceAssetId, userAddress, true)
470+    let outLpAmountCalc = estimatedPutResults._1
471+    let curentPriceCalc = estimatedPutResults._2
472+    let poolAmountAssetBalanceCalc = estimatedPutResults._3
473+    let poolPriceAssetBalanceCAlc = estimatedPutResults._4
474+    let poolLPBalanceCalc = estimatedPutResults._5
475+    let poolStatusCalc = parseIntValue(estimatedPutResults._10)
476+    $Tuple2(nil, makeString(["%d%d%d%d%d%d", toString(outLpAmountCalc), toString(curentPrice), toString(poolAmountAssetBalanceCalc), toString(poolPriceAssetBalanceCAlc), toString(poolLPBalanceCalc), toString(poolStatusCalc)], SEP))
477+    }
478+
479+
480+
481+@Callable(i)
482+func evaluatePutByPriceAssetREADONLY (slippageTolerance,inPriceAssetAmt,userAddress) = {
483+    let poolConfigDataList = getPoolConfig()
484+    let lpAssetId = fromBase58String(poolConfigDataList[idxPoolLPAssetId])
485+    let amountAssetId = poolConfigDataList[idxAmountAssetId]
486+    let priceAssetId = poolConfigDataList[idxPriceAssetId]
487+    let amountAssetInternalId = poolConfigDataList[idxAmountAssetInternalId]
488+    let priceAssetInternalId = poolConfigDataList[idxPriceAssetInternalId]
489+    let amoutAssetDecimals = parseIntValue(poolConfigDataList[idxAmountAssetDecimals])
490+    let priceAssetDecimals = parseIntValue(poolConfigDataList[idxPriceAssetDecimals])
491+    let poolStatus = poolConfigDataList[idxPoolStatus]
492+    let poolLiquidityDataList = getPoolLiquidity(amountAssetInternalId, priceAssetInternalId)
493+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
494+    let accountAmountAssetBalance = privateGetAccountBalance(amountAssetId)
495+    let accountPriceAssetBalance = privateGetAccountBalance(priceAssetId)
496+    let accountAmountAssetBalanceCasted = privateCastToScaleOf(accountAmountAssetBalance, scale8, amoutAssetDecimals)
497+    let accountPriceAssetBalanceCasted = privateCastToScaleOf(accountPriceAssetBalance, scale8, priceAssetDecimals)
498+    let inPriceAssetAmtCalculatedTuple = privateCastToScaleOf(inPriceAssetAmt, scale8, priceAssetDecimals)
499+    let curentPrice = if ((poolLPBalance == 0))
500+        then 0
501+        else calculatePrice(accountPriceAssetBalanceCasted, accountAmountAssetBalanceCasted)
502+    let inAmountAssetAmtCalculated = fraction(inPriceAssetAmtCalculatedTuple, scale8, curentPrice)
503+    let inAmountAssetAmt = privateCastToScaleOf(inAmountAssetAmtCalculated, amoutAssetDecimals, scale8)
504+    let estimatedPutResults = privateEstimatePutOperation(slippageTolerance, inAmountAssetAmt, amountAssetId, inPriceAssetAmt, priceAssetId, userAddress, true)
505+    let outLpAmountCalc = estimatedPutResults._1
506+    let curentPriceCalc = estimatedPutResults._2
507+    let poolAmountAssetBalanceCalc = estimatedPutResults._3
508+    let poolPriceAssetBalanceCAlc = estimatedPutResults._4
509+    let poolLPBalanceCalc = estimatedPutResults._5
510+    let poolStatusCalc = parseIntValue(estimatedPutResults._10)
511+    $Tuple2(nil, makeString(["%d%d%d%d%d%d", toString(outLpAmountCalc), toString(curentPrice), toString(poolAmountAssetBalanceCalc), toString(poolPriceAssetBalanceCAlc), toString(poolLPBalanceCalc), toString(poolStatusCalc)], SEP))
512+    }
513+
514+
515+
516+@Callable(i)
517+func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmount,userAddress) = {
518+    let results = privateEstimateGetOperation(paymentLpAssetId, paymentLpAmount, userAddress)
519+    let outAmountAssetAmt = results._1
520+    let outPriceAssetAmt = results._2
521+    let poolAmountAssetBalance = results._7
522+    let poolPriceAssetBalance = results._8
523+    let poolLPBalance = results._9
524+    let currentPrice = results._10
525+    let poolStatus = parseIntValue(results._11)
526+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmountAssetAmt), toString(outPriceAssetAmt), toString(poolAmountAssetBalance), toString(poolPriceAssetBalance), toString(poolLPBalance), toString(currentPrice), toString(poolStatus)], SEP))
527+    }
528+
529+
530+
531+@Callable(i)
532+func hashREADONLY () = $Tuple2(nil, toBase64String(value(scriptHash(this))))
533+
534+
535+@Verifier(tx)
536+func verify () = match tx {
537+    case order: Order => 
538+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
539+    case _ => 
540+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
541+}
542+
github/deemru/w8io/3ef1775 
45.78 ms ◑