tx · 2jfr3NyKxaeZgr5FXvQRkq7cHc9LJxtrigJWvvzjpWGB

3N22BYqtPzVTSgJBrhE8yYUSZPRCmkXmtcP:  -0.05000000 Waves

2021.10.01 14:32 [1727068] smart account 3N22BYqtPzVTSgJBrhE8yYUSZPRCmkXmtcP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2jfr3NyKxaeZgr5FXvQRkq7cHc9LJxtrigJWvvzjpWGB",
    "fee": 5000000,
    "feeAssetId": null,
    "timestamp": 1633087963452,
    "version": 2,
    "chainId": 84,
    "sender": "3N22BYqtPzVTSgJBrhE8yYUSZPRCmkXmtcP",
    "senderPublicKey": "2uZLPvTfcSdSqd6m8q85ZpiWEmxSkGWzb5ocbziqSzCj",
    "proofs": [
        "23tbfCwLyfZnfngbfwGm33DAVDjmbLzmpoVxSCrF6yLYLaa21sjsfKeBbgqjXHbpEvF9UYKUYjLT2PLkd3uH5zXM"
    ],
    "script": "base64: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",
    "height": 1727068,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: HMnEQZCZ9DyuF4EzMDsFjJy5tbXed9cCB5xVGa6gQpXz
Next: none

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4-func keyAccumulatedFee () = "%s__accumulatedFee"
5-
4+let lPdecimals = 8
65 
76 let scale8 = 100000000
87 
9-let BUFSCALE = toBigInt(1000000000000000000)
8+let scale8BigInt = toBigInt(100000000)
109 
11-func convertPriceAssetIntoIdoAsset (priceAssetAmount,priceAssetMULT,price,priceMULT,idoAssetMULT) = {
12-    let bPriceMULT = toBigInt(priceAssetMULT)
13-    let bPriceAssetBUF = fraction(toBigInt(priceAssetAmount), BUFSCALE, bPriceMULT)
14-    let bAmountAssetBUF = fraction(bPriceAssetBUF, bPriceMULT, toBigInt(price))
15-    toInt(fraction(bAmountAssetBUF, toBigInt(idoAssetMULT), BUFSCALE))
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 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 (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 = parseIntValue(poolLiquidityList[idxPoolLPAssetAmt])
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(amtAssetPoolLockedAmt), toInt(priceAssetPoolLockedAmt), 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 = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
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 estimateThis (slippageTolerance,inAmtAssetAmt,inAmtAssetId,inPriceAssetAmt,inPriceAssetId,userAddress,isEvaluate) = {
265+    let cfg = getPoolConfig()
266+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
267+    let amtAssetId = cfg[idxAmtAssetId]
268+    let priceAssetId = cfg[idxPriceAssetId]
269+    let iAmtAssetId = cfg[idxIAmtAssetId]
270+    let iPriceAssetId = cfg[idxIPriceAssetId]
271+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
272+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
273+    let poolStatus = cfg[idxPoolStatus]
274+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
275+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
276+    if (if ((amtAssetId != inAmtAssetId))
277+        then true
278+        else (priceAssetId != inPriceAssetId))
279+        then throw("Invalid amt or price asset passed.")
280+        else {
281+            let accAmtAssetBalance = if (isEvaluate)
282+                then getAccBalance(amtAssetId)
283+                else (getAccBalance(amtAssetId) - inAmtAssetAmt)
284+            let accPriceAssetBalance = if (isEvaluate)
285+                then getAccBalance(priceAssetId)
286+                else (getAccBalance(priceAssetId) - inPriceAssetAmt)
287+            let amtAssetDcmBigInt = toBigInt(amtAssetDcm)
288+            let priceAssetDcmBigInt = toBigInt(priceAssetDcm)
289+            let inAmtAssetAmtCalc = toScaleBigInt(toBigInt(inAmtAssetAmt), scale18, amtAssetDcmBigInt)
290+            let inPriceAssetAmtCalc = toScaleBigInt(toBigInt(inPriceAssetAmt), scale18, priceAssetDcmBigInt)
291+            let userPrice = toInt(calcPriceBigInt(inPriceAssetAmtCalc, inAmtAssetAmtCalc, scale8BigInt))
292+            let amtAssetPoolLockedAmt = toScaleBigInt(toBigInt(accAmtAssetBalance), scale18, amtAssetDcmBigInt)
293+            let priceAssetPoolLockedAmt = toScaleBigInt(toBigInt(accPriceAssetBalance), scale18, priceAssetDcmBigInt)
294+            let curPrice = if ((poolLPBalance == 0))
295+                then 0
296+                else toInt(calcPriceBigInt(priceAssetPoolLockedAmt, amtAssetPoolLockedAmt, scale8BigInt))
297+            let slippage = if ((curPrice == 0))
298+                then 0
299+                else if ((curPrice > userPrice))
300+                    then fraction((curPrice - userPrice), scale8, curPrice)
301+                    else fraction((userPrice - curPrice), scale8, curPrice)
302+            if (if ((curPrice != 0))
303+                then (slippage > slippageTolerance)
304+                else false)
305+                then throw(((("Price slippage " + toString(slippage)) + " exceeded the passed limit of ") + toString(slippageTolerance)))
306+                else $Tuple12(1, 1, 1, 1, 1, "", "", "", 1, "", 1, 1)
307+            }
308+    }
309+
310+
311+func validateMatcherOrderAllowed (order) = {
312+    let cfg = getPoolConfig()
313+    let amtAssetId = cfg[idxAmtAssetId]
314+    let priceAssetId = cfg[idxPriceAssetId]
315+    let poolStatus = parseIntValue(cfg[idxPoolStatus])
316+    let matcherPublicKeyStr = cfg[idxMatcherPublicKey]
317+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
318+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
319+    let accAmtAssetBalance = getAccBalance(amtAssetId)
320+    let accPriceAssetBalance = getAccBalance(priceAssetId)
321+    let curPrice = if ((order.orderType == Buy))
322+        then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
323+        else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
324+    if (if (if (isGlobalShutdown())
325+        then true
326+        else (poolStatus == PoolMatcherDisabled))
327+        then true
328+        else (poolStatus == PoolShutdown))
329+        then throw("Exchange operations disabled")
330+        else if (!(sigVerify(order.bodyBytes, order.proofs[0], fromBase58String(matcherPublicKeyStr))))
331+            then throw("Incorrect order sender.")
332+            else {
333+                let orderAmtAsset = order.assetPair.amountAsset
334+                let orderAmtAssetStr = if ((orderAmtAsset == unit))
335+                    then "WAVES"
336+                    else toBase58String(value(orderAmtAsset))
337+                let orderPriceAsset = order.assetPair.priceAsset
338+                let orderPriceAssetStr = if ((orderPriceAsset == unit))
339+                    then "WAVES"
340+                    else toBase58String(value(orderPriceAsset))
341+                if (if ((orderAmtAssetStr != amtAssetId))
342+                    then true
343+                    else (orderPriceAssetStr != priceAssetId))
344+                    then throw("Wrong order assets.")
345+                    else {
346+                        let orderPrice = order.price
347+                        let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
348+                        let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
349+                        let isOrderPriceValid = if ((order.orderType == Buy))
350+                            then (curPrice >= castedOrderPrice)
351+                            else (castedOrderPrice >= curPrice)
352+                        if (!(isOrderPriceValid))
353+                            then throw("Order price leads to K decrease.")
354+                            else true
355+                        }
356+                }
16357     }
17358 
18359 
19360 @Callable(i)
20-func ordinal () = {
21-    let amountAssetAmt = 1000000000000000
22-    let priceAssetAmt = 30000000000000000
23-    let bAmountAssetBUF = fraction(toBigInt(amountAssetAmt), BUFSCALE, toBigInt(scale8))
24-    let bPriceAssetBUF = fraction(toBigInt(priceAssetAmt), BUFSCALE, toBigInt(scale8))
25-    let partABigInt = pow((bAmountAssetBUF * bPriceAssetBUF), 0, toBigInt(5), 1, 0, DOWN)
26-    let result2 = fraction(partABigInt, toBigInt(scale8), BUFSCALE)
27-[IntegerEntry("bigInt", toInt(result2))]
361+func constructor (factoryContract) = if ((i.caller != this))
362+    then throw("permissions denied")
363+    else [StringEntry(keyFactoryContract(), factoryContract)]
364+
365+
366+
367+@Callable(i)
368+func put (slippageTolerance,shouldAutoStake) = {
369+    let factoryConfigList = getFactoryConfig()
370+    let stakingContract = valueOrErrorMessage(addressFromString(factoryConfigList[idxFactoryStakingContract]), "Error. Incorrect staking address.")
371+    let pmtAmtAsset = value(i.payments[0])
372+    let inAmtAssetAmt = pmtAmtAsset.amount
373+    let inAmtAssetId = if (!(isDefined(pmtAmtAsset.assetId)))
374+        then fromBase58String("WAVES")
375+        else value(pmtAmtAsset.assetId)
376+    let pmtPriceAsset = value(i.payments[1])
377+    let inPriceAssetAmt = pmtPriceAsset.amount
378+    let inPriceAssetId = if (!(isDefined(pmtPriceAsset.assetId)))
379+        then fromBase58String("WAVES")
380+        else value(pmtPriceAsset.assetId)
381+    let estimatedPutResults = estimatePutOperation(slippageTolerance, inAmtAssetAmt, toBase58String(inAmtAssetId), inPriceAssetAmt, toBase58String(inPriceAssetId), toString(i.caller), false)
382+    let outLpAmt = estimatedPutResults._1
383+    let curPrice = estimatedPutResults._2
384+    let poolAmtAssetBalance = estimatedPutResults._3
385+    let poolPriceAssetBalance = estimatedPutResults._4
386+    let poolLPBalance = estimatedPutResults._5
387+    let iAmtAssetId = estimatedPutResults._6
388+    let iPriceAssetId = estimatedPutResults._7
389+    let lpAssetId = estimatedPutResults._8
390+    let slippageCalc = estimatedPutResults._9
391+    let poolStatus = parseIntValue(estimatedPutResults._10)
392+    let realAmtAssetIn = estimatedPutResults._11
393+    let realPriceAssetIn = estimatedPutResults._12
394+    if (if (if (isGlobalShutdown())
395+        then true
396+        else (poolStatus == PoolPutDisabled))
397+        then true
398+        else (poolStatus == PoolShutdown))
399+        then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
400+        else {
401+            let emitLPAssetOnFactory = invoke(factoryContract, "emit", [outLpAmt], nil)
402+            if ((emitLPAssetOnFactory == emitLPAssetOnFactory))
403+                then if ((emitLPAssetOnFactory != "success"))
404+                    then throw("LP asset reissue failed during emit call on factory.")
405+                    else {
406+                        let diffInAmtAsset = (inAmtAssetAmt - realAmtAssetIn)
407+                        let diffInPriceAsset = (inPriceAssetAmt - realPriceAssetIn)
408+                        let slippageAmtAssetCum = valueOrElse(getInteger(this, keySlippageAmountAssetCumulative()), 0)
409+                        let slippagePriceAssetCum = valueOrElse(getInteger(this, keySlippagePriceAssetCumulative()), 0)
410+                        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, outLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, diffInAmtAsset, diffInPriceAsset)), StringEntry(keyPoolLiquidity(iAmtAssetId, iPriceAssetId), dataPoolLiquidity((poolAmtAssetBalance + realAmtAssetIn), (poolPriceAssetBalance + realPriceAssetIn), (poolLPBalance + outLpAmt)))]
411+                        let finalResults = if (shouldAutoStake)
412+                            then {
413+                                let stake = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, outLpAmt)])
414+                                if ((stake == stake))
415+                                    then dataStateWrite
416+                                    else throw("Strict value is not equal to itself.")
417+                                }
418+                            else (dataStateWrite :+ ScriptTransfer(i.caller, outLpAmt, lpAssetId))
419+                        (finalResults ++ (if ((inAmtAssetAmt > realAmtAssetIn))
420+                            then [ScriptTransfer(i.caller, diffInAmtAsset, pmtAmtAsset.assetId), IntegerEntry(keySlippageAmountAssetCumulative(), (slippageAmtAssetCum + diffInAmtAsset))]
421+                            else (nil ++ (if ((inPriceAssetAmt > realPriceAssetIn))
422+                                then [ScriptTransfer(i.caller, diffInPriceAsset, pmtPriceAsset.assetId), IntegerEntry(keySlippagePriceAssetCumulative(), (slippagePriceAssetCum + diffInPriceAsset))]
423+                                else nil))))
424+                        }
425+                else throw("Strict value is not equal to itself.")
426+            }
28427     }
29428 
30429 
31430 
32431 @Callable(i)
33-func ordinal2 () = {
34-    let amountAssetAmt = 1000000000
35-    let priceAssetAmt = 30000000000
36-    let partA = pow(amountAssetAmt, 0, 5, 1, 0, DOWN)
37-    let partB = pow(priceAssetAmt, 0, 5, 1, 0, DOWN)
38-    let result = (partA * partB)
39-[IntegerEntry("ordinal", result)]
432+func get () = {
433+    let pmtAmtAsset = value(i.payments[0])
434+    let pmtAssetId = value(pmtAmtAsset.assetId)
435+    let pmtAssetAmt = pmtAmtAsset.amount
436+    let res = estimateGetOperation(toBase58String(pmtAssetId), pmtAssetAmt, toString(i.caller))
437+    let outAmtAssetAmt = res._1
438+    let outPriceAssetAmt = res._2
439+    let iAmtAssetId = res._3
440+    let iPriceAssetId = res._4
441+    let amtAssetId = res._5
442+    let priceAssetId = res._6
443+    let poolAmtAssetBalance = res._7
444+    let poolPriceAssetBalance = res._8
445+    let poolLPBalance = res._9
446+    let curPrice = res._10
447+    let poolStatus = parseIntValue(res._11)
448+    if (if (isGlobalShutdown())
449+        then true
450+        else (poolStatus == PoolShutdown))
451+        then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
452+        else {
453+            let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAssetAmt], [AttachedPayment(pmtAssetId, pmtAssetAmt)])
454+            if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
455+                then if ((burnLPAssetOnFactory != "success"))
456+                    then throw("LP asset burn failed during emit call on factory.")
457+                    else [ScriptTransfer(i.caller, outAmtAssetAmt, if ((amtAssetId == "WAVES"))
458+                        then unit
459+                        else fromBase58String(amtAssetId)), ScriptTransfer(i.caller, outPriceAssetAmt, 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)))]
460+                else throw("Strict value is not equal to itself.")
461+            }
40462     }
41463 
42464 
43465 
44466 @Callable(i)
45-func callMeDapp (stringParam1) = {
46-    let caller = i.caller
47-[StringEntry("stringParam1", stringParam1), BooleanEntry("boolParam2", false)]
467+func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
468+    then throw("permissions denied")
469+    else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
470+
471+
472+
473+@Callable(i)
474+func statsREADONLY () = {
475+    let cfg = getPoolConfig()
476+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
477+    let amtAssetId = cfg[idxAmtAssetId]
478+    let priceAssetId = cfg[idxPriceAssetId]
479+    let iAmtAssetId = cfg[idxIAmtAssetId]
480+    let iPriceAssetId = cfg[idxIPriceAssetId]
481+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
482+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
483+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
484+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
485+    let accAmtAssetBalance = getAccBalance(amtAssetId)
486+    let accPriceAssetBalance = getAccBalance(priceAssetId)
487+    let pricesList = calcPrices(accAmtAssetBalance, accPriceAssetBalance, poolLPBalance)
488+    let curPrice = pricesList[0]
489+    let lpAmtAssetShare = pricesList[1]
490+    let lpPriceAssetShare = pricesList[2]
491+    let poolWeight = valueOrErrorMessage(getInteger(factoryContract, keyPoolWeight(toString(this))), "Pool doesn't have weight.")
492+    $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))
48493     }
49494 
50495 
51496 
52497 @Callable(i)
53-func callMe (stringParam1,boolParam2,binaryParam3,intParam4,argsStr) = {
54-    let caller = i.caller
55-[StringEntry("stringParam1", stringParam1), BooleanEntry("boolParam2", boolParam2), BinaryEntry("binaryParam3", binaryParam3), IntegerEntry("intParam4", intParam4), StringEntry("listStringParam1", argsStr[0]), StringEntry("listStringParam2", argsStr[1])]
498+func evaluatePutByAmtAssetREADONLY (slippageTolerance,inAmtAssetAmt,userAddress) = {
499+    let cfg = getPoolConfig()
500+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
501+    let amtAssetId = cfg[idxAmtAssetId]
502+    let priceAssetId = cfg[idxPriceAssetId]
503+    let iAmtAssetId = cfg[idxIAmtAssetId]
504+    let iPriceAssetId = cfg[idxIPriceAssetId]
505+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
506+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
507+    let poolStatus = cfg[idxPoolStatus]
508+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
509+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
510+    let accAmtAssetBalance = getAccBalance(amtAssetId)
511+    let accPriceAssetBalance = getAccBalance(priceAssetId)
512+    let amtAssetAmtScaled = toScaleBigInt(toBigInt(accAmtAssetBalance), scale18, toBigInt(amtAssetDcm))
513+    let priceAssetAmtScaled = toScaleBigInt(toBigInt(accPriceAssetBalance), scale18, toBigInt(priceAssetDcm))
514+    let curPrice = if ((poolLPBalance == 0))
515+        then toBigInt(0)
516+        else calcPriceBigInt(priceAssetAmtScaled, amtAssetAmtScaled, scale18)
517+    let inAmtAssetAmtScaled = toScaleBigInt(toBigInt(inAmtAssetAmt), scale18, toBigInt(amtAssetDcm))
518+    let inPriceAssetAmtCalc = fraction(inAmtAssetAmtScaled, curPrice, scale18)
519+    let inPriceAssetAmt = toInt(toScaleBigInt(inPriceAssetAmtCalc, toBigInt(priceAssetDcm), scale18))
520+    let estimatedPutResults = estimatePutOperation(slippageTolerance, inAmtAssetAmt, amtAssetId, inPriceAssetAmt, priceAssetId, userAddress, true)
521+    let outLpAmtCalc = estimatedPutResults._1
522+    let curPriceCalc = estimatedPutResults._2
523+    let poolAmtAssetBalanceCalc = estimatedPutResults._3
524+    let poolPriceAssetBalanceCAlc = estimatedPutResults._4
525+    let poolLPBalanceCalc = estimatedPutResults._5
526+    let poolStatusCalc = parseIntValue(estimatedPutResults._10)
527+    $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))
56528     }
57529 
58530 
59531 
60532 @Callable(i)
61-func callMe2 (stringParam1,boolParam2,binaryParam3,intParam4,argsStr,argsInt,argsBool,argsBinary) = {
62-    let caller = i.caller
63-[StringEntry("stringParam1", stringParam1), BooleanEntry("boolParam2", boolParam2), BinaryEntry("binaryParam3", binaryParam3), IntegerEntry("intParam4", intParam4), StringEntry("listStringParam1", argsStr[0]), StringEntry("listStringParam2", argsStr[1]), IntegerEntry("listIntParam1", argsInt[0]), IntegerEntry("listIntParam2", argsInt[1]), BooleanEntry("listBoolParam1", argsBool[0]), BooleanEntry("listBoolParam2", argsBool[1]), BinaryEntry("listBinaryParam3", argsBinary[0]), BinaryEntry("listBinaryParam3", argsBinary[1])]
533+func evaluatePutByPriceAssetREADONLY (slippageTolerance,inPriceAssetAmt,userAddress) = {
534+    let cfg = getPoolConfig()
535+    let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
536+    let amtAssetId = cfg[idxAmtAssetId]
537+    let priceAssetId = cfg[idxPriceAssetId]
538+    let iAmtAssetId = cfg[idxIAmtAssetId]
539+    let iPriceAssetId = cfg[idxIPriceAssetId]
540+    let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
541+    let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
542+    let poolStatus = cfg[idxPoolStatus]
543+    let poolLiquidityDataList = getPoolLiquidity(iAmtAssetId, iPriceAssetId)
544+    let poolLPBalance = parseIntValue(poolLiquidityDataList[idxPoolLPAssetAmt])
545+    let accAmtAssetBalance = getAccBalance(amtAssetId)
546+    let accPriceAssetBalance = getAccBalance(priceAssetId)
547+    let amtAssetAmtScaled = toScaleBigInt(toBigInt(accAmtAssetBalance), scale18, toBigInt(amtAssetDcm))
548+    let priceAssetAmtScaled = toScaleBigInt(toBigInt(accPriceAssetBalance), scale18, toBigInt(priceAssetDcm))
549+    let curPrice = if ((poolLPBalance == 0))
550+        then toBigInt(0)
551+        else calcPriceBigInt(priceAssetAmtScaled, amtAssetAmtScaled, scale18)
552+    let inPriceAssetAmtScaled = toScaleBigInt(toBigInt(inPriceAssetAmt), scale18, toBigInt(priceAssetDcm))
553+    let inAmtAssetAmtCalc = fraction(inPriceAssetAmtScaled, scale18, curPrice)
554+    let inAmtAssetAmt = toInt(toScaleBigInt(inAmtAssetAmtCalc, toBigInt(amtAssetDcm), scale18))
555+    let estimatedPutResults = estimatePutOperation(slippageTolerance, inAmtAssetAmt, amtAssetId, inPriceAssetAmt, priceAssetId, userAddress, true)
556+    let outLpAmtCalc = estimatedPutResults._1
557+    let curPriceCalc = estimatedPutResults._2
558+    let poolAmtAssetBalanceCalc = estimatedPutResults._3
559+    let poolPriceAssetBalanceCAlc = estimatedPutResults._4
560+    let poolLPBalanceCalc = estimatedPutResults._5
561+    let poolStatusCalc = parseIntValue(estimatedPutResults._10)
562+    $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))
563+    }
564+
565+
566+
567+@Callable(i)
568+func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmt,userAddress) = {
569+    let res = estimateGetOperation(paymentLpAssetId, paymentLpAmt, userAddress)
570+    let outAmtAssetAmt = res._1
571+    let outPriceAssetAmt = res._2
572+    let poolAmtAssetBalance = res._7
573+    let poolPriceAssetBalance = res._8
574+    let poolLPBalance = res._9
575+    let curPrice = res._10
576+    let poolStatus = parseIntValue(res._11)
577+    $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))
64578     }
65579 
66580 
67581 @Verifier(tx)
68-func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
582+func verify () = match tx {
583+    case order: Order => 
584+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
585+    case _ => 
586+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
587+}
69588 
github/deemru/w8io/169f3d6 
78.07 ms ◑