tx · 3tiitTK3UwkW2SiTQV9QTpUC3NyGALjNgNuvmdP4YHmC

3P85wJKhiQeTEZrLvvmkZgapHcQWcHFPJFZ:  -0.01000000 Waves

2021.10.04 15:51 [2796500] smart account 3P85wJKhiQeTEZrLvvmkZgapHcQWcHFPJFZ > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3tiitTK3UwkW2SiTQV9QTpUC3NyGALjNgNuvmdP4YHmC",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1633351969207,
    "version": 1,
    "sender": "3P85wJKhiQeTEZrLvvmkZgapHcQWcHFPJFZ",
    "senderPublicKey": "Ev26VHM5PgcWMx41mUgVEYw4uDh8euRUm7Kx1cEdgy2T",
    "proofs": [
        "3FUFXUMkP1UKWj3LVp8jMjj84icM7hi68v7bXQRTumpM6y538s1tDiEnEkqbp8b2by6XtgrgEVJG2xmjjKpxkS14"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2796500,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: DPP933bf78KSoAd84cEYLNG3d8e8Ab1s3F25VEZAP949

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 idxAmtAssetId = 4
29+
30+let idxPriceAssetId = 5
31+
32+let idxAmtAssetDcm = 6
33+
34+let idxPriceAssetDcm = 7
35+
36+let idxIAmtAssetId = 8
37+
38+let idxIPriceAssetId = 9
39+
40+let idxLPAssetDcm = 10
41+
42+let idxMatcherPublicKey = 11
43+
44+let idxPoolAmtAssetAmt = 1
45+
46+let idxPoolPriceAssetAmt = 2
47+
48+let idxPoolLPAssetAmt = 3
49+
50+let idxFactoryStakingContract = 1
51+
52+let idxFactorySlippageContract = 7
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 (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__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 keyAmtAsset () = "%s__amountAsset"
73+
74+
75+func keyPriceAsset () = "%s__priceAsset"
76+
77+
78+func keySlippagePriceAssetCumulative () = "%s__slippagePriceAssetCumulative"
79+
80+
81+func keySlippageAmountAssetCumulative () = "%s__slippageAmountAssetCumulative"
82+
83+
84+func keyKHistoric (h,timestamp) = makeString(["%s%s%d%d__K_history", toString(h), toString(timestamp)], SEP)
85+
86+
87+func keyFactoryConfig () = "%s__factoryConfig"
88+
89+
90+func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
91+
92+
93+func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
94+
95+
96+func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
97+
98+
99+func keyAllPoolsShutdown () = "%s__shutdown"
100+
101+
102+func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
103+
104+
105+let factoryContract = addressFromStringValue(valueOrErrorMessage(getString(this, keyFactoryContract()), "No Factory Acc found."))
106+
107+func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
108+
109+
110+func getPoolConfig () = {
111+    let amtAsset = valueOrErrorMessage(getString(this, keyAmtAsset()), "No config for amt asset found")
112+    let priceAsset = valueOrErrorMessage(getString(this, keyPriceAsset()), "No config for price asset found")
113+    let iPriceAsset = valueOrErrorMessage(getInteger(factoryContract, keyMappingsBaseAsset2internalId(priceAsset)), "No config for internal price asset found")
114+    let iAmtAsset = valueOrErrorMessage(getInteger(factoryContract, keyMappingsBaseAsset2internalId(amtAsset)), "No config for internal amt asset found")
115+    split(valueOrErrorMessage(getString(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), "No factory config found for pool assets."), SEP)
116+    }
117+
118+
119+func getFactoryConfig () = split(valueOrErrorMessage(getString(factoryContract, keyFactoryConfig()), "No factory config found."), SEP)
120+
121+
122+func dataPoolLiquidity (amtAssetLocked,priceAssetLocked,lpTokenLocked) = makeString(["%d%d%d", toString(amtAssetLocked), toString(priceAssetLocked), toString(lpTokenLocked)], SEP)
123+
124+
125+func getPoolLiquidity (iAmtAssetId,iPriceAssetId) = split(valueOrElse(getString(this, keyPoolLiquidity(iAmtAssetId, iPriceAssetId)), dataPoolLiquidity(0, 0, 0)), SEP)
126+
127+
128+func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%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)
129+
130+
131+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)
132+
133+
134+func getAccBalance (assetId) = if ((assetId == "WAVES"))
135+    then wavesBalance(this).available
136+    else assetBalance(this, fromBase58String(assetId))
137+
138+
139+func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
140+
141+
142+func toScaleBigInt (amt,resScale,curScale) = fraction(amt, resScale, curScale)
143+
144+
145+func calcPriceBigInt (priceAssetLockedAmt,amtAssetlLockedAmt,resultScale) = fraction(priceAssetLockedAmt, resultScale, amtAssetlLockedAmt)
146+
147+
148+func privateCalcPrice (amtAssetDcm,priceAssetDcm,amtAssetAmt,priceAssetAmt) = {
149+    let amtAssetAmtCasted = toScaleBigInt(toBigInt(amtAssetAmt), scale18, toBigInt(amtAssetDcm))
150+    let priceAssetAmtCasted = toScaleBigInt(toBigInt(priceAssetAmt), scale18, toBigInt(priceAssetDcm))
151+    toInt(calcPriceBigInt(priceAssetAmtCasted, amtAssetAmtCasted, scale8BigInt))
152+    }
153+
154+
155+func calcPrices (amtAssetAmt,priceAssetAmt,lpAmt) = {
156+    let cfg = getPoolConfig()
157+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
158+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
159+    let poolPrice = privateCalcPrice(amtAssetDcm, priceAssetDcm, amtAssetAmt, priceAssetAmt)
160+    let amtAssetPoolLockedAmt = toScaleBigInt(toBigInt(amtAssetAmt), scale18, toBigInt(amtAssetDcm))
161+    let priceAssetPoolLockedAmt = toScaleBigInt(toBigInt(priceAssetAmt), scale18, toBigInt(priceAssetDcm))
162+    let lpAmtScaled = toScaleBigInt(toBigInt(lpAmt), scale18, scale8BigInt)
163+    let lpPriceInAmtAsset = toInt(calcPriceBigInt(amtAssetPoolLockedAmt, lpAmtScaled, scale8BigInt))
164+    let lpPriceInPriceAsset = toInt(calcPriceBigInt(priceAssetPoolLockedAmt, lpAmtScaled, scale8BigInt))
165+[poolPrice, lpPriceInAmtAsset, lpPriceInPriceAsset]
166+    }
167+
168+
169+func estimateGetOperation (paymentLpAssetId,paymentLpAmt,userAddress) = {
170+    let poolConfigList = getPoolConfig()
171+    let lpAssetId = poolConfigList[idxPoolLPAssetId]
172+    let amtAssetId = poolConfigList[idxAmtAssetId]
173+    let priceAssetId = poolConfigList[idxPriceAssetId]
174+    let iAmtAssetId = poolConfigList[idxIAmtAssetId]
175+    let iPriceAssetId = poolConfigList[idxIPriceAssetId]
176+    let amtAssetDcm = parseIntValue(poolConfigList[idxAmtAssetDcm])
177+    let priceAssetDcm = parseIntValue(poolConfigList[idxPriceAssetDcm])
178+    let poolStatus = poolConfigList[idxPoolStatus]
179+    let poolLiquidityList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
180+    let poolLPBalance = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
181+    if ((lpAssetId != paymentLpAssetId))
182+        then throw("Invalid asset passed.")
183+        else {
184+            let amtAssetPoolLockedAmt = toScaleBigInt(toBigInt(getAccBalance(amtAssetId)), scale18, toBigInt(amtAssetDcm))
185+            let priceAssetPoolLockedAmt = toScaleBigInt(toBigInt(getAccBalance(priceAssetId)), scale18, toBigInt(priceAssetDcm))
186+            let curPrice = toInt(calcPriceBigInt(priceAssetPoolLockedAmt, amtAssetPoolLockedAmt, scale8BigInt))
187+            let paymentLpAmtBuf = toScaleBigInt(toBigInt(paymentLpAmt), scale18, scale8BigInt)
188+            let poolLPBalanceBuf = toScaleBigInt(toBigInt(poolLPBalance), scale18, scale8BigInt)
189+            let outAmtAssetAmt = fraction(amtAssetPoolLockedAmt, paymentLpAmtBuf, poolLPBalanceBuf)
190+            let outPriceAssetAmt = fraction(priceAssetPoolLockedAmt, paymentLpAmtBuf, poolLPBalanceBuf)
191+            let outAmtAssetAmtFinal = toInt(toScaleBigInt(outAmtAssetAmt, toBigInt(amtAssetDcm), scale18))
192+            let outPriceAssetAmtFinal = toInt(toScaleBigInt(outPriceAssetAmt, toBigInt(priceAssetDcm), scale18))
193+            $Tuple11(outAmtAssetAmtFinal, outPriceAssetAmtFinal, iAmtAssetId, iPriceAssetId, amtAssetId, priceAssetId, toInt(toScaleBigInt(amtAssetPoolLockedAmt, toBigInt(amtAssetDcm), scale18)), toInt(toScaleBigInt(priceAssetPoolLockedAmt, toBigInt(priceAssetDcm), scale18)), poolLPBalance, curPrice, poolStatus)
194+            }
195+    }
196+
197+
198+func estimatePutOperation (slippageTolerance,inAmtAssetAmt,inAmtAssetId,inPriceAssetAmt,inPriceAssetId,userAddress,isEvaluate) = {
199+    let cfg = getPoolConfig()
200+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
201+    let amtAssetId = cfg[idxAmtAssetId]
202+    let priceAssetId = cfg[idxPriceAssetId]
203+    let iAmtAssetId = cfg[idxIAmtAssetId]
204+    let iPriceAssetId = cfg[idxIPriceAssetId]
205+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
206+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
207+    let poolStatus = cfg[idxPoolStatus]
208+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
209+    let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
210+    if (if ((amtAssetId != inAmtAssetId))
211+        then true
212+        else (priceAssetId != inPriceAssetId))
213+        then throw("Invalid amt or price asset passed.")
214+        else {
215+            let accAmtAssetBalance = if (isEvaluate)
216+                then getAccBalance(amtAssetId)
217+                else (getAccBalance(amtAssetId) - inAmtAssetAmt)
218+            let accPriceAssetBalance = if (isEvaluate)
219+                then getAccBalance(priceAssetId)
220+                else (getAccBalance(priceAssetId) - inPriceAssetAmt)
221+            let amtAssetDcmBigInt = toBigInt(amtAssetDcm)
222+            let priceAssetDcmBigInt = toBigInt(priceAssetDcm)
223+            let inAmtAssetAmtCalc = toScaleBigInt(toBigInt(inAmtAssetAmt), scale18, amtAssetDcmBigInt)
224+            let inPriceAssetAmtCalc = toScaleBigInt(toBigInt(inPriceAssetAmt), scale18, priceAssetDcmBigInt)
225+            let userPrice = toInt(calcPriceBigInt(inPriceAssetAmtCalc, inAmtAssetAmtCalc, scale8BigInt))
226+            let amtAssetPoolLockedAmt = toScaleBigInt(toBigInt(accAmtAssetBalance), scale18, amtAssetDcmBigInt)
227+            let priceAssetPoolLockedAmt = toScaleBigInt(toBigInt(accPriceAssetBalance), scale18, priceAssetDcmBigInt)
228+            let curPrice = if ((poolLPBalance == 0))
229+                then 0
230+                else toInt(calcPriceBigInt(priceAssetPoolLockedAmt, amtAssetPoolLockedAmt, scale8BigInt))
231+            let slippage = if ((curPrice == 0))
232+                then 0
233+                else if ((curPrice > userPrice))
234+                    then fraction((curPrice - userPrice), scale8, curPrice)
235+                    else fraction((userPrice - curPrice), scale8, curPrice)
236+            if (if ((curPrice != 0))
237+                then (slippage > slippageTolerance)
238+                else false)
239+                then throw(((("Price slippage " + toString(slippage)) + " exceeded the passed limit of ") + toString(slippageTolerance)))
240+                else {
241+                    let res = if ((poolLPBalance == 0))
242+                        then {
243+                            let lpResultBuf = pow((inAmtAssetAmtCalc * inPriceAssetAmtCalc), 0, toBigInt(5), 1, 0, DOWN)
244+                            $Tuple4(toInt(toScaleBigInt(lpResultBuf, scale8BigInt, scale18)), toInt(toScaleBigInt(inAmtAssetAmtCalc, amtAssetDcmBigInt, scale18)), toInt(toScaleBigInt(inPriceAssetAmtCalc, priceAssetDcmBigInt, scale18)), toInt(calcPriceBigInt((priceAssetPoolLockedAmt + inPriceAssetAmtCalc), (amtAssetPoolLockedAmt + inAmtAssetAmtCalc), scale8BigInt)))
245+                            }
246+                        else {
247+                            let poolLPBalanceBuf = toScaleBigInt(toBigInt(poolLPBalance), scale18, scale8BigInt)
248+                            let curPriceScaled = toScaleBigInt(toBigInt(curPrice), scale18, scale8BigInt)
249+                            let pEqByA = fraction(curPriceScaled, inAmtAssetAmtCalc, scale18)
250+                            let resAssetsToPut = if ((pEqByA > inPriceAssetAmtCalc))
251+                                then $Tuple2(fraction(inPriceAssetAmtCalc, scale18, curPriceScaled), inPriceAssetAmtCalc)
252+                                else $Tuple2(inAmtAssetAmtCalc, pEqByA)
253+                            let lpResult = toInt(toScaleBigInt(fraction(poolLPBalanceBuf, resAssetsToPut._2, priceAssetPoolLockedAmt), scale8BigInt, scale18))
254+                            $Tuple4(lpResult, toInt(toScaleBigInt(resAssetsToPut._1, amtAssetDcmBigInt, scale18)), toInt(toScaleBigInt(resAssetsToPut._2, priceAssetDcmBigInt, scale18)), toInt(calcPriceBigInt((priceAssetPoolLockedAmt + resAssetsToPut._2), (amtAssetPoolLockedAmt + resAssetsToPut._1), scale8BigInt)))
255+                            }
256+                    if ((0 >= res._1))
257+                        then throw("Invalid calculations. LP calculated is less than zero.")
258+                        else $Tuple12(res._1, res._4, accAmtAssetBalance, accPriceAssetBalance, poolLPBalance, iAmtAssetId, iPriceAssetId, lpAssetId, slippage, poolStatus, res._2, res._3)
259+                    }
260+            }
261+    }
262+
263+
264+func validateMatcherOrderAllowed (order) = {
265+    let cfg = getPoolConfig()
266+    let amtAssetId = cfg[idxAmtAssetId]
267+    let priceAssetId = cfg[idxPriceAssetId]
268+    let poolStatus = parseIntValue(cfg[idxPoolStatus])
269+    let matcherPublicKeyStr = cfg[idxMatcherPublicKey]
270+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
271+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
272+    let accAmtAssetBalance = getAccBalance(amtAssetId)
273+    let accPriceAssetBalance = getAccBalance(priceAssetId)
274+    let curPrice = if ((order.orderType == Buy))
275+        then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
276+        else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
277+    if (!(sigVerify(order.bodyBytes, order.proofs[0], fromBase58String(matcherPublicKeyStr))))
278+        then throw("Incorrect order sender.")
279+        else {
280+            let orderAmtAsset = order.assetPair.amountAsset
281+            let orderAmtAssetStr = if ((orderAmtAsset == unit))
282+                then "WAVES"
283+                else toBase58String(value(orderAmtAsset))
284+            let orderPriceAsset = order.assetPair.priceAsset
285+            let orderPriceAssetStr = if ((orderPriceAsset == unit))
286+                then "WAVES"
287+                else toBase58String(value(orderPriceAsset))
288+            let orderPrice = order.price
289+            let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
290+            let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
291+            let isOrderPriceValid = if ((order.orderType == Buy))
292+                then (curPrice >= castedOrderPrice)
293+                else (castedOrderPrice >= curPrice)
294+            true
295+            }
296+    }
297+
298+
299+func commonGet (i) = {
300+    let pmtAmtAsset = value(i.payments[0])
301+    let pmtAssetId = value(pmtAmtAsset.assetId)
302+    let pmtAssetAmt = pmtAmtAsset.amount
303+    let res = estimateGetOperation(toBase58String(pmtAssetId), pmtAssetAmt, toString(i.caller))
304+    let outAmtAssetAmt = res._1
305+    let outPriceAssetAmt = res._2
306+    let iAmtAssetId = res._3
307+    let iPriceAssetId = res._4
308+    let amtAssetId = res._5
309+    let priceAssetId = res._6
310+    let poolAmtAssetBalance = res._7
311+    let poolPriceAssetBalance = res._8
312+    let poolLPBalance = res._9
313+    let curPrice = res._10
314+    let poolStatus = parseIntValue(res._11)
315+    if (if (isGlobalShutdown())
316+        then true
317+        else (poolStatus == PoolShutdown))
318+        then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
319+        else $Tuple5(outAmtAssetAmt, outPriceAssetAmt, pmtAssetAmt, pmtAssetId, [ScriptTransfer(i.caller, outAmtAssetAmt, if ((amtAssetId == "WAVES"))
320+            then unit
321+            else fromBase58String(amtAssetId)), ScriptTransfer(i.caller, outPriceAssetAmt, if ((priceAssetId == "WAVES"))
322+            then unit
323+            else fromBase58String(priceAssetId)), StringEntry(keyPoolLiquidity(iAmtAssetId, iPriceAssetId), dataPoolLiquidity((poolAmtAssetBalance - outAmtAssetAmt), (poolPriceAssetBalance - outPriceAssetAmt), (poolLPBalance - pmtAssetAmt))), StringEntry(keyGetActionByUser(toString(i.caller), toBase58String(i.transactionId)), dataGetActionInfo(outAmtAssetAmt, outPriceAssetAmt, pmtAssetAmt, curPrice, height, lastBlock.timestamp)), StringEntry(keyPriceLast(), ("%s__" + toString(curPrice))), StringEntry(keyPriceHistory(height, lastBlock.timestamp), ("%s__" + toString(curPrice)))])
324+    }
325+
326+
327+func commonPut (i,slippageTolerance,shouldAutoStake,emitLp) = {
328+    let pmtAmtAsset = value(i.payments[0])
329+    let inAmtAssetAmt = pmtAmtAsset.amount
330+    let inAmtAssetId = if (!(isDefined(pmtAmtAsset.assetId)))
331+        then fromBase58String("WAVES")
332+        else value(pmtAmtAsset.assetId)
333+    let pmtPriceAsset = value(i.payments[1])
334+    let inPriceAssetAmt = pmtPriceAsset.amount
335+    let inPriceAssetId = if (!(isDefined(pmtPriceAsset.assetId)))
336+        then fromBase58String("WAVES")
337+        else value(pmtPriceAsset.assetId)
338+    let estPut = estimatePutOperation(slippageTolerance, inAmtAssetAmt, toBase58String(inAmtAssetId), inPriceAssetAmt, toBase58String(inPriceAssetId), toString(i.caller), false)
339+    let outLpAmt = estPut._1
340+    let curPrice = estPut._2
341+    let poolAmtAssetBalance = estPut._3
342+    let poolPriceAssetBalance = estPut._4
343+    let poolLPBalance = estPut._5
344+    let iAmtAssetId = estPut._6
345+    let iPriceAssetId = estPut._7
346+    let lpAssetId = estPut._8
347+    let slippageCalc = estPut._9
348+    let poolStatus = parseIntValue(estPut._10)
349+    let realAmtAssetIn = estPut._11
350+    let realPriceAssetIn = estPut._12
351+    if (if (if (isGlobalShutdown())
352+        then true
353+        else (poolStatus == PoolPutDisabled))
354+        then true
355+        else (poolStatus == PoolShutdown))
356+        then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
357+        else {
358+            let lpAmtToEmit = if (!(emitLp))
359+                then 0
360+                else outLpAmt
361+            let diffInAmtAsset = (inAmtAssetAmt - realAmtAssetIn)
362+            let diffInPriceAsset = (inPriceAssetAmt - realPriceAssetIn)
363+            let slippageAmtAssetCum = valueOrElse(getInteger(this, keySlippageAmountAssetCumulative()), 0)
364+            let slippagePriceAssetCum = valueOrElse(getInteger(this, keySlippagePriceAssetCumulative()), 0)
365+            let dataStateWrite = [StringEntry(keyPriceLast(), ("%s__" + toString(curPrice))), StringEntry(keyPriceHistory(height, lastBlock.timestamp), ("%s__" + toString(curPrice))), StringEntry(keyPutActionByUser(toString(i.caller), toBase58String(i.transactionId)), dataPutActionInfo(realAmtAssetIn, realPriceAssetIn, lpAmtToEmit, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, diffInAmtAsset, diffInPriceAsset)), StringEntry(keyPoolLiquidity(iAmtAssetId, iPriceAssetId), dataPoolLiquidity((poolAmtAssetBalance + realAmtAssetIn), (poolPriceAssetBalance + realPriceAssetIn), (poolLPBalance + lpAmtToEmit)))]
366+            $Tuple9(lpAmtToEmit, lpAssetId, dataStateWrite, inAmtAssetAmt, realAmtAssetIn, inPriceAssetAmt, realPriceAssetIn, pmtAmtAsset.assetId, pmtPriceAsset.assetId)
367+            }
368+    }
369+
370+
371+@Callable(i)
372+func constructor (factoryContract) = if ((i.caller != this))
373+    then throw("permissions denied")
374+    else [StringEntry(keyFactoryContract(), factoryContract)]
375+
376+
377+
378+@Callable(i)
379+func put (slippageTolerance,shouldAutoStake) = {
380+    let factoryCfg = getFactoryConfig()
381+    let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
382+    let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
383+    let actions = commonPut(i, slippageTolerance, shouldAutoStake, true)
384+    let amtToEmit = actions._1
385+    let lpAssetId = actions._2
386+    let state = actions._3
387+    let inAmt = actions._4
388+    let realInAmt = actions._5
389+    let inPrice = actions._6
390+    let realInPrice = actions._7
391+    let prId = actions._8
392+    let amId = actions._9
393+    let diffInAmtAsset = (inAmt - realInAmt)
394+    let diffInPriceAsset = (inPrice - realInPrice)
395+    let slippageAmtAssetCum = valueOrElse(getInteger(this, keySlippageAmountAssetCumulative()), 0)
396+    let slippagePriceAssetCum = valueOrElse(getInteger(this, keySlippagePriceAssetCumulative()), 0)
397+    let emit = invoke(factoryContract, "emit", [actions._1], nil)
398+    if ((emit == emit))
399+        then {
400+            let dataAndSlippage = (state ++ (if ((inAmt > realInAmt))
401+                then {
402+                    let stake = invoke(slippageContract, "put", nil, [AttachedPayment(amId, diffInAmtAsset)])
403+                    if ((stake == stake))
404+                        then [IntegerEntry(keySlippageAmountAssetCumulative(), (slippageAmtAssetCum + diffInAmtAsset))]
405+                        else throw("Strict value is not equal to itself.")
406+                    }
407+                else (nil ++ (if ((inPrice > realInPrice))
408+                    then {
409+                        let stake = invoke(slippageContract, "put", nil, [AttachedPayment(prId, diffInPriceAsset)])
410+                        if ((stake == stake))
411+                            then [IntegerEntry(keySlippagePriceAssetCumulative(), (slippagePriceAssetCum + diffInPriceAsset))]
412+                            else throw("Strict value is not equal to itself.")
413+                        }
414+                    else nil))))
415+            let finalResults = if (shouldAutoStake)
416+                then {
417+                    let stake = invoke(staking, "stake", nil, [AttachedPayment(lpAssetId, amtToEmit)])
418+                    if ((stake == stake))
419+                        then dataAndSlippage
420+                        else throw("Strict value is not equal to itself.")
421+                    }
422+                else (dataAndSlippage :+ ScriptTransfer(i.caller, amtToEmit, lpAssetId))
423+            finalResults
424+            }
425+        else throw("Strict value is not equal to itself.")
426+    }
427+
428+
429+
430+@Callable(i)
431+func putForFree () = {
432+    let actions = commonPut(i, 0, false, false)
433+    actions._3
434+    }
435+
436+
437+
438+@Callable(i)
439+func get () = {
440+    let res = commonGet(i)
441+    let outAmtAssetAmt = res._1
442+    let outPriceAssetAmt = res._2
443+    let pmtAssetAmt = res._3
444+    let pmtAssetId = res._4
445+    let actions = res._5
446+    let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAssetAmt], [AttachedPayment(pmtAssetId, pmtAssetAmt)])
447+    if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
448+        then actions
449+        else throw("Strict value is not equal to itself.")
450+    }
451+
452+
453+
454+@Callable(i)
455+func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
456+    let res = commonGet(i)
457+    let outAmtAssetAmt = res._1
458+    let outPriceAssetAmt = res._2
459+    let pmtAssetAmt = res._3
460+    let pmtAssetId = res._4
461+    let actions = res._5
462+    if ((noLessThenAmtAsset > outAmtAssetAmt))
463+        then throw(((("noLessThenAmtAsset failed:  " + toString(outAmtAssetAmt)) + " < ") + toString(noLessThenAmtAsset)))
464+        else if ((noLessThenPriceAsset > outPriceAssetAmt))
465+            then throw(((("noLessThenPriceAsset failed: " + toString(outPriceAssetAmt)) + " < ") + toString(noLessThenPriceAsset)))
466+            else {
467+                let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAssetAmt], [AttachedPayment(pmtAssetId, pmtAssetAmt)])
468+                if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
469+                    then actions
470+                    else throw("Strict value is not equal to itself.")
471+                }
472+    }
473+
474+
475+
476+@Callable(i)
477+func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
478+    then throw("permissions denied")
479+    else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
480+
481+
482+
483+@Callable(i)
484+func statsREADONLY () = {
485+    let cfg = getPoolConfig()
486+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
487+    let amtAssetId = cfg[idxAmtAssetId]
488+    let priceAssetId = cfg[idxPriceAssetId]
489+    let iAmtAssetId = cfg[idxIAmtAssetId]
490+    let iPriceAssetId = cfg[idxIPriceAssetId]
491+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
492+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
493+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
494+    let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
495+    let accAmtAssetBalance = getAccBalance(amtAssetId)
496+    let accPriceAssetBalance = getAccBalance(priceAssetId)
497+    let pricesList = calcPrices(accAmtAssetBalance, accPriceAssetBalance, poolLPBalance)
498+    let curPrice = pricesList[0]
499+    let lpAmtAssetShare = pricesList[1]
500+    let lpPriceAssetShare = pricesList[2]
501+    let poolWeight = valueOrErrorMessage(getInteger(factoryContract, keyPoolWeight(toString(this))), "Pool doesn't have weight.")
502+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
503+    }
504+
505+
506+
507+@Callable(i)
508+func evaluatePutByAmtAssetREADONLY (slippageTolerance,inAmtAssetAmt,userAddress) = {
509+    let cfg = getPoolConfig()
510+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
511+    let amtAssetId = cfg[idxAmtAssetId]
512+    let priceAssetId = cfg[idxPriceAssetId]
513+    let iAmtAssetId = cfg[idxIAmtAssetId]
514+    let iPriceAssetId = cfg[idxIPriceAssetId]
515+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
516+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
517+    let poolStatus = cfg[idxPoolStatus]
518+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
519+    let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
520+    let accAmtAssetBalance = getAccBalance(amtAssetId)
521+    let accPriceAssetBalance = getAccBalance(priceAssetId)
522+    let amtAssetAmtScaled = toScaleBigInt(toBigInt(accAmtAssetBalance), scale18, toBigInt(amtAssetDcm))
523+    let priceAssetAmtScaled = toScaleBigInt(toBigInt(accPriceAssetBalance), scale18, toBigInt(priceAssetDcm))
524+    let curPrice = if ((poolLPBalance == 0))
525+        then toBigInt(0)
526+        else calcPriceBigInt(priceAssetAmtScaled, amtAssetAmtScaled, scale18)
527+    let inAmtAssetAmtScaled = toScaleBigInt(toBigInt(inAmtAssetAmt), scale18, toBigInt(amtAssetDcm))
528+    let inPriceAssetAmtCalc = fraction(inAmtAssetAmtScaled, curPrice, scale18)
529+    let inPriceAssetAmt = toInt(toScaleBigInt(inPriceAssetAmtCalc, toBigInt(priceAssetDcm), scale18))
530+    let estimatedPutResults = estimatePutOperation(slippageTolerance, inAmtAssetAmt, amtAssetId, inPriceAssetAmt, priceAssetId, userAddress, true)
531+    let outLpAmtCalc = estimatedPutResults._1
532+    let curPriceCalc = estimatedPutResults._2
533+    let poolAmtAssetBalanceCalc = estimatedPutResults._3
534+    let poolPriceAssetBalanceCAlc = estimatedPutResults._4
535+    let poolLPBalanceCalc = estimatedPutResults._5
536+    let poolStatusCalc = parseIntValue(estimatedPutResults._10)
537+    $Tuple2(nil, makeString(["%d%d%d%d%d%d", toString(outLpAmtCalc), toString(toInt(toScaleBigInt(curPrice, scale8BigInt, scale18))), toString(poolAmtAssetBalanceCalc), toString(poolPriceAssetBalanceCAlc), toString(poolLPBalanceCalc), toString(poolStatusCalc)], SEP))
538+    }
539+
540+
541+
542+@Callable(i)
543+func evaluatePutByPriceAssetREADONLY (slippageTolerance,inPriceAssetAmt,userAddress) = {
544+    let cfg = getPoolConfig()
545+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
546+    let amtAssetId = cfg[idxAmtAssetId]
547+    let priceAssetId = cfg[idxPriceAssetId]
548+    let iAmtAssetId = cfg[idxIAmtAssetId]
549+    let iPriceAssetId = cfg[idxIPriceAssetId]
550+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
551+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
552+    let poolStatus = cfg[idxPoolStatus]
553+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
554+    let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
555+    let accAmtAssetBalance = getAccBalance(amtAssetId)
556+    let accPriceAssetBalance = getAccBalance(priceAssetId)
557+    let amtAssetAmtScaled = toScaleBigInt(toBigInt(accAmtAssetBalance), scale18, toBigInt(amtAssetDcm))
558+    let priceAssetAmtScaled = toScaleBigInt(toBigInt(accPriceAssetBalance), scale18, toBigInt(priceAssetDcm))
559+    let curPrice = if ((poolLPBalance == 0))
560+        then toBigInt(0)
561+        else calcPriceBigInt(priceAssetAmtScaled, amtAssetAmtScaled, scale18)
562+    let inPriceAssetAmtScaled = toScaleBigInt(toBigInt(inPriceAssetAmt), scale18, toBigInt(priceAssetDcm))
563+    let inAmtAssetAmtCalc = fraction(inPriceAssetAmtScaled, scale18, curPrice)
564+    let inAmtAssetAmt = toInt(toScaleBigInt(inAmtAssetAmtCalc, toBigInt(amtAssetDcm), scale18))
565+    let estimatedPutResults = estimatePutOperation(slippageTolerance, inAmtAssetAmt, amtAssetId, inPriceAssetAmt, priceAssetId, userAddress, true)
566+    let outLpAmtCalc = estimatedPutResults._1
567+    let curPriceCalc = estimatedPutResults._2
568+    let poolAmtAssetBalanceCalc = estimatedPutResults._3
569+    let poolPriceAssetBalanceCAlc = estimatedPutResults._4
570+    let poolLPBalanceCalc = estimatedPutResults._5
571+    let poolStatusCalc = parseIntValue(estimatedPutResults._10)
572+    $Tuple2(nil, makeString(["%d%d%d%d%d%d", toString(outLpAmtCalc), toString(toInt(toScaleBigInt(curPrice, scale8BigInt, scale18))), toString(poolAmtAssetBalanceCalc), toString(poolPriceAssetBalanceCAlc), toString(poolLPBalanceCalc), toString(poolStatusCalc)], SEP))
573+    }
574+
575+
576+
577+@Callable(i)
578+func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmt,userAddress) = {
579+    let res = estimateGetOperation(paymentLpAssetId, paymentLpAmt, userAddress)
580+    let outAmtAssetAmt = res._1
581+    let outPriceAssetAmt = res._2
582+    let poolAmtAssetBalance = res._7
583+    let poolPriceAssetBalance = res._8
584+    let poolLPBalance = res._9
585+    let curPrice = res._10
586+    let poolStatus = parseIntValue(res._11)
587+    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(poolAmtAssetBalance), toString(poolPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(poolStatus)], SEP))
588+    }
589+
590+
591+@Verifier(tx)
592+func verify () = match tx {
593+    case order: Order => 
594+        validateMatcherOrderAllowed(order)
595+    case _ => 
596+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
597+}
598+
github/deemru/w8io/3ef1775 
43.15 ms ◑