2021.12.30 17:07 [2922137] smart account 3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HMsNAUgWAwQAP6joVHCQN3U69NEKrkqeRU6ggudJPkVa",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1640873305341,
    "version": 1,
    "sender": "3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz",
    "senderPublicKey": "DxhbzFs9BZTiN6kcnyybxmqPTV8xReD6Z5gWQ5AgRX8w",
    "proofs": [
        "zKyzn6fxNvnPK15vy1pM6ZXHdX83Mr8WApqWnneYJVWHzBePtR1atxFn5NKkouB3uWcwieQ4GMMPGPkwhBVQ59B"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2922137,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Fe7Ka9m3tcN3WUMrGxmQGWofdsPGBC5AH1kFWSnGYSUy
Next: 2WVpzTCmhvLfBtoS6Mm28z8Fyp1LTpg1UHAskLwH8Knf

Diff: 

OldNewDifferences
1010 let zeroBigInt = toBigInt(0)
1111 
1212 let oneBigInt = toBigInt(1)
13+
14+let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
1315 
1416 let Amult = "100"
1517 
110112 func keyPoolWeight (p) = ("%s%s__poolWeight__" + p)
111113 
112114 
113-func throwOrderError (orV,sendrV,matchV) = throw(((((("Failed: orderValid=" + toString(orV)) + " senderValid=") + toString(sendrV)) + " matcherValid=") + toString(matchV)))
115+func throwOrderError (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
114116 
115117 
116118 func asString (val) = match val {
121123 }
122124 
123125 
124-func getStringOrFail (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
126+func getStringOrFail (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
125127 
126128 
127-func getIntOrFail (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
129+func getIntOrFail (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
128130 
129131 
130132 let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactCntr()))
163165 func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
164166 
165167 
166-func validateAbsDiff (realAmt,expectedAmt,slippage) = {
167-    let diff = fraction((realAmt - expectedAmt), scale8BigInt, expectedAmt)
168-    let passed = ((slippage - abs(diff)) > zeroBigInt)
169-    if (!(passed))
170-        then throw(((("Too big slippage: " + toString(diff)) + " vs ") + toString(slippage)))
171-        else $Tuple2(passed, min([realAmt, expectedAmt]))
168+func validateAbsDiff (A1,A2,slippage) = {
169+    let diff = fraction((A1 - A2), scale8BigInt, A2)
170+    let pass = ((slippage - abs(diff)) > zeroBigInt)
171+    if (!(pass))
172+        then throw(("Big slpg: " + toString(diff)))
173+        else $Tuple2(pass, min([A1, A2]))
174+    }
175+
176+
177+func validateD (D1,D0,slpg) = {
178+    let diff = fraction(D0, scale8BigInt, D1)
179+    let fail = (slpg > diff)
180+    if (if (fail)
181+        then true
182+        else (D0 > D1))
183+        then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
184+        else fail
172185     }
173186 
174187 
194207 
195208 
196209 func calculatePrices (amAmt,prAmt,lpAmt) = {
197-    let prices = calcPrices(amAmt, prAmt, lpAmt)
198-[fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
210+    let p = calcPrices(amAmt, prAmt, lpAmt)
211+[fromX18(p[0], scale8), fromX18(p[1], scale8), fromX18(p[2], scale8)]
199212     }
200213 
201214 
206219     let prId = cfg[idxPrAsId]
207220     let amDcm = parseIntValue(cfg[idxAmtAsDcm])
208221     let prDcm = parseIntValue(cfg[idxPriceAsDcm])
209-    let poolStatus = cfg[idxPoolSt]
210-    let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Invalid LP id").quantity
222+    let sts = cfg[idxPoolSt]
223+    let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
211224     if ((lpId != pmtAssetId))
212-        then throw("Invalid pmt asset")
225+        then throw("Wrong pmt asset")
213226         else {
214227             let amBalance = getAccBalance(amId)
215228             let amBalanceX18 = toX18(amBalance, amDcm)
218231             let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
219232             let curPrice = fromX18(curPriceX18, scale8)
220233             let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
221-            let lpEmissionX18 = toX18(lpEmission, scale8)
222-            let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
223-            let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
234+            let lpEmissX18 = toX18(lpEmiss, scale8)
235+            let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
236+            let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
224237             let outAmAmt = fromX18(outAmAmtX18, amDcm)
225238             let outPrAmt = fromX18(outPrAmtX18, prDcm)
226239             let state = if ((txId58 == ""))
230243                     else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
231244                     then unit
232245                     else fromBase58String(prId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
233-            $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
246+            $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
234247             }
235248     }
236249 
244257     let inPrIdStr = cfg[idxIPriceAsId]
245258     let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
246259     let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
247-    let poolStatus = cfg[idxPoolSt]
260+    let sts = cfg[idxPoolSt]
248261     let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
249262     let amBalance = if (isEval)
250263         then getAccBalance(amIdStr)
310323                 else calcLpAmt
311324             let amDiff = (inAmAmt - calcAmAssetPmt)
312325             let prDiff = (inPrAmt - calcPrAssetPmt)
313-            let $t01564015985 = if (if (isOneAsset)
326+            let $t01582016165 = if (if (isOneAsset)
314327                 then (pmtId == amIdStr)
315328                 else false)
316329                 then $Tuple2(pmtAmt, 0)
319332                     else false)
320333                     then $Tuple2(0, pmtAmt)
321334                     else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
322-            let writeAmAmt = $t01564015985._1
323-            let writePrAmt = $t01564015985._2
335+            let writeAmAmt = $t01582016165._1
336+            let writePrAmt = $t01582016165._2
324337             let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
325-            $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
338+            $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
326339             }
327340     }
328341 
331344     let cfg = getPoolConfig()
332345     let amtAsId = cfg[idxAmAsId]
333346     let prAsId = cfg[idxPrAsId]
334-    let poolStatus = parseIntValue(cfg[idxPoolSt])
347+    let sts = parseIntValue(cfg[idxPoolSt])
335348     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
336349     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
337350     let accAmtAsBalance = getAccBalance(amtAsId)
342355     let curPrice = fromX18(curPriceX18, scale8)
343356     if (if (if (isGlobalShutdown())
344357         then true
345-        else (poolStatus == PoolMatcherDis))
358+        else (sts == PoolMatcherDis))
346359         then true
347-        else (poolStatus == PoolShutdown))
360+        else (sts == PoolShutdown))
348361         then throw("Admin blocked")
349362         else {
350363             let orAmtAsset = order.assetPair.amountAsset
381394         let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
382395         let outAmAmt = res._1
383396         let outPrAmt = res._2
384-        let poolStatus = parseIntValue(res._9)
397+        let sts = parseIntValue(res._9)
385398         let state = res._10
386399         if (if (isGlobalShutdown())
387400             then true
388-            else (poolStatus == PoolShutdown))
389-            then throw(("Admin blocked: " + toString(poolStatus)))
401+            else (sts == PoolShutdown))
402+            then throw(("Admin blocked: " + toString(sts)))
390403             else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
391404         }
392405 
393406 
394407 func commonPut (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,pmtAmt,pmtId) = {
395408     let r = estimatePutOperation(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp, isOneAsset, pmtAmt, pmtId)
396-    let status = parseIntValue(r._8)
409+    let sts = parseIntValue(r._8)
397410     if (if (if (isGlobalShutdown())
398411         then true
399-        else (status == PoolPutDis))
412+        else (sts == PoolPutDis))
400413         then true
401-        else (status == PoolShutdown))
402-        then throw(("Blocked:" + toString(status)))
414+        else (sts == PoolShutdown))
415+        then throw(("Blocked:" + toString(sts)))
403416         else r
404417     }
405418 
417430     let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
418431     let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
419432     if ((0 > slip))
420-        then throw("Invalid slippage")
433+        then throw("Wrong slippage")
421434         else if ((size(i.payments) != 2))
422435             then throw("2 pmnts expd")
423436             else {
465478 @Callable(i)
466479 func putOneTkn (amAssetPart,prAssetPart,outLp,slippage,autoStake) = {
467480     let cfg = getFactoryConfig()
468-    if (true)
469-        then throw("off")
470-        else {
471-            let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
472-            let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
473-            let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
474-            let poolCfg = getPoolConfig()
475-            let amId = poolCfg[idxAmAsId]
476-            let prId = poolCfg[idxPrAsId]
477-            let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
478-            let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
479-            if (if (if (if ((0 >= slippage))
480-                then true
481-                else (0 >= amAssetPart))
482-                then true
483-                else (0 >= prAssetPart))
484-                then true
485-                else (0 >= outLp))
486-                then throw("Wrong params")
487-                else if ((size(i.payments) != 1))
488-                    then throw("1 pmnt expd")
481+    let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
482+    let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
483+    let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
484+    let poolCfg = getPoolConfig()
485+    let amId = poolCfg[idxAmAsId]
486+    let prId = poolCfg[idxPrAsId]
487+    let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
488+    let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
489+    if (if (if (if ((0 >= slippage))
490+        then true
491+        else (0 >= amAssetPart))
492+        then true
493+        else (0 >= prAssetPart))
494+        then true
495+        else (0 >= outLp))
496+        then throw("Wrong params")
497+        else if ((size(i.payments) != 1))
498+            then throw("1 pmnt expd")
499+            else {
500+                let pmt = value(i.payments[0])
501+                let pmtAssetId = toBase58String(value(pmt.assetId))
502+                let pmtAmt = pmt.amount
503+                if (if (if ((amAssetPart > pmtAmt))
504+                    then true
505+                    else (prAssetPart > pmtAmt))
506+                    then true
507+                    else (10000000 > pmtAmt))
508+                    then throw("Wrong pmt amt")
489509                     else {
490-                        let pmt = value(i.payments[0])
491-                        let pmtAssetId = toBase58String(value(pmt.assetId))
492-                        let pmtAmt = pmt.amount
493-                        if (if (if ((amAssetPart > pmtAmt))
494-                            then true
495-                            else (prAssetPart > pmtAmt))
496-                            then true
497-                            else (10000000 > pmtAmt))
498-                            then throw("Wrong pmt amt")
499-                            else {
500-                                let amBalance = getAccBalance(amId)
501-                                let prBalance = getAccBalance(prId)
502-                                let $t02378824168 = if ((pmtAssetId == amId))
503-                                    then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
504-                                    else if ((pmtAssetId == prId))
505-                                        then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
506-                                        else throw("wrong pmtAssetId")
507-                                let amBalanceNow = $t02378824168._1
508-                                let prBalanceNow = $t02378824168._2
509-                                let virtSwapInAm = $t02378824168._3
510-                                let virtSwapOutPr = $t02378824168._4
511-                                let virtSwapInPr = $t02378824168._5
512-                                let virtSwapOutAm = $t02378824168._6
513-                                let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
514-                                let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
515-                                let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), toBigInt(1000))
516-                                if ((D0vsD1 == D0vsD1))
510+                        let amBalance = getAccBalance(amId)
511+                        let prBalance = getAccBalance(prId)
512+                        let $t02390624286 = if ((pmtAssetId == amId))
513+                            then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
514+                            else if ((pmtAssetId == prId))
515+                                then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
516+                                else throw("wrong pmtAssetId")
517+                        let amBalanceNow = $t02390624286._1
518+                        let prBalanceNow = $t02390624286._2
519+                        let virtSwapInAm = $t02390624286._3
520+                        let virtSwapOutPr = $t02390624286._4
521+                        let virtSwapInPr = $t02390624286._5
522+                        let virtSwapOutAm = $t02390624286._6
523+                        let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
524+                        let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
525+                        let D0vsD1 = validateD(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), slippage4D)
526+                        if ((D0vsD1 == D0vsD1))
527+                            then {
528+                                let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
529+                                let estimLP = estPut._2
530+                                let lpAssetId = estPut._7
531+                                let state = estPut._9
532+                                let amDiff = estPut._10
533+                                let prDiff = estPut._11
534+                                let lpCalcRes = validateAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
535+                                let emitLpAmt = toInt(lpCalcRes._2)
536+                                let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
537+                                if ((emitInv == emitInv))
517538                                     then {
518-                                        let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), 50000000000, true, true, pmtAmt, pmtAssetId)
519-                                        let estimLP = estPut._2
520-                                        let lpAssetId = estPut._7
521-                                        let state = estPut._9
522-                                        let amDiff = estPut._10
523-                                        let prDiff = estPut._11
524-                                        let lpCalcRes = validateAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
525-                                        let emitLpAmt = toInt(lpCalcRes._2)
526-                                        let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
527-                                        if ((emitInv == emitInv))
539+                                        let slippageAInv = if ((amDiff > 0))
540+                                            then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
541+                                            else nil
542+                                        if ((slippageAInv == slippageAInv))
528543                                             then {
529-                                                let slippageAInv = if ((amDiff > 0))
530-                                                    then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
544+                                                let slippagePInv = if ((prDiff > 0))
545+                                                    then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
531546                                                     else nil
532-                                                if ((slippageAInv == slippageAInv))
547+                                                if ((slippagePInv == slippagePInv))
533548                                                     then {
534-                                                        let slippagePInv = if ((prDiff > 0))
535-                                                            then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
536-                                                            else nil
537-                                                        if ((slippagePInv == slippagePInv))
549+                                                        let lpTrnsfr = if (autoStake)
538550                                                             then {
539-                                                                let lpTrnsfr = if (autoStake)
540-                                                                    then {
541-                                                                        let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
542-                                                                        if ((slpStakeInv == slpStakeInv))
543-                                                                            then nil
544-                                                                            else throw("Strict value is not equal to itself.")
545-                                                                        }
546-                                                                    else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
547-                                                                (state ++ lpTrnsfr)
551+                                                                let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
552+                                                                if ((slpStakeInv == slpStakeInv))
553+                                                                    then nil
554+                                                                    else throw("Strict value is not equal to itself.")
548555                                                                 }
549-                                                            else throw("Strict value is not equal to itself.")
556+                                                            else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
557+                                                        (state ++ lpTrnsfr)
550558                                                         }
551559                                                     else throw("Strict value is not equal to itself.")
552560                                                 }
554562                                         }
555563                                     else throw("Strict value is not equal to itself.")
556564                                 }
565+                            else throw("Strict value is not equal to itself.")
557566                         }
558-            }
567+                }
559568     }
560569 
561570 
562571 
563572 @Callable(i)
564-func putForFree (maxSlippage) = if ((0 > maxSlippage))
565-    then throw("Invalid slippage")
573+func putForFree (maxSlpg) = if ((0 > maxSlpg))
574+    then throw("Wrong slpg")
566575     else if ((size(i.payments) != 2))
567576         then throw("2 pmnts expd")
568577         else {
569-            let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlippage, false, false, 0, "")
578+            let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, 0, "")
570579             estPut._9
571580             }
572581 
589598 
590599 
591600 @Callable(i)
592-func getOneTkn (amAssetSwap,prAssetSwap,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
601+func getOneTkn (exchResult,notUsed,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
593602     then throw("1 pmnt expd")
594-    else if (true)
595-        then throw("off")
596-        else {
597-            let cfg = getPoolConfig()
598-            let lpId = cfg[idxLPAsId]
599-            let amId = cfg[idxAmAsId]
600-            let prId = cfg[idxPrAsId]
601-            let amDcm = parseIntValue(cfg[idxAmtAsDcm])
602-            let prDcm = parseIntValue(cfg[idxPriceAsDcm])
603-            let poolStatus = cfg[idxPoolSt]
604-            let fcfg = getFactoryConfig()
605-            let gwxCntr = valueOrErrorMessage(addressFromString(fcfg[idxFactGwxRewCntr]), "Wr sl addr")
606-            let pmt = value(i.payments[0])
607-            let userAddress = i.caller
608-            let txId58 = toBase58String(i.transactionId)
609-            let pmtAssetId = value(pmt.assetId)
610-            let pmtAmt = pmt.amount
611-            if (if (if (if ((0 > slippage))
603+    else {
604+        let cfg = getPoolConfig()
605+        let lpId = cfg[idxLPAsId]
606+        let amId = cfg[idxAmAsId]
607+        let prId = cfg[idxPrAsId]
608+        let amDcm = parseIntValue(cfg[idxAmtAsDcm])
609+        let prDcm = parseIntValue(cfg[idxPriceAsDcm])
610+        let sts = cfg[idxPoolSt]
611+        let fcfg = getFactoryConfig()
612+        let gwxCntr = valueOrErrorMessage(addressFromString(fcfg[idxFactGwxRewCntr]), "Wr sl addr")
613+        let pmt = value(i.payments[0])
614+        let userAddress = i.caller
615+        let txId58 = toBase58String(i.transactionId)
616+        let pmtAssetId = value(pmt.assetId)
617+        let pmtAmt = pmt.amount
618+        if ((1000000000 > pmtAmt))
619+            then throw("Min payment is 10 LP")
620+            else if (if (if ((0 > slippage))
612621                 then true
613-                else (0 > amAssetSwap))
614-                then true
615-                else (0 > prAssetSwap))
622+                else (0 > exchResult))
616623                 then true
617624                 else (0 > outAmount))
618625                 then throw("Wrong params")
619626                 else if ((lpId != toBase58String(pmtAssetId)))
620-                    then throw("Invalid LP")
627+                    then throw("Wrong LP")
621628                     else {
622629                         let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
623630                         let estimAmAmt = r._1
624631                         let estimPrAmt = r._2
625632                         let amBalance = getAccBalance(amId)
626633                         let prBalance = getAccBalance(prId)
627-                        let $t02865029134 = if ((outAssetId == amId))
628-                            then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), (outAmount - estimAmAmt), prAssetSwap, 0, 0, (estimAmAmt + amAssetSwap))
634+                        let $t02878029237 = if ((outAssetId == amId))
635+                            then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), exchResult, estimPrAmt, 0, 0, (estimAmAmt + exchResult))
629636                             else if ((outAssetId == prId))
630-                                then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, (outAmount - estimPrAmt), amAssetSwap, (estimPrAmt + prAssetSwap))
637+                                then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, exchResult, estimAmAmt, (estimPrAmt + exchResult))
631638                                 else throw("wrong outAssetId")
632-                        let amBalanceNow = $t02865029134._1
633-                        let prBalanceNow = $t02865029134._2
634-                        let virtSwapInAm = $t02865029134._3
635-                        let virtSwapOutPr = $t02865029134._4
636-                        let virtSwapInPr = $t02865029134._5
637-                        let virtSwapOutAm = $t02865029134._6
638-                        let totalGet = $t02865029134._7
639+                        let amBalanceNow = $t02878029237._1
640+                        let prBalanceNow = $t02878029237._2
641+                        let virtSwapInAm = $t02878029237._3
642+                        let virtSwapOutPr = $t02878029237._4
643+                        let virtSwapInPr = $t02878029237._5
644+                        let virtSwapOutAm = $t02878029237._6
645+                        let totalGet = $t02878029237._7
639646                         if (if ((0 > virtSwapInAm))
640647                             then true
641648                             else (0 > virtSwapInPr))
642-                            then throw("Invalid calc")
649+                            then throw("Wrong calc")
643650                             else {
644651                                 let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
645652                                 let D1 = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
646-                                let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), toBigInt(1000))
653+                                let D0vsD1 = validateD(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), slippage4D)
647654                                 if ((D0vsD1 == D0vsD1))
648655                                     then {
649656                                         let amount2Return = validateAbsDiff(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
650657                                         if ((amount2Return == amount2Return))
651658                                             then {
652-                                                let $t02988630000 = if ((outAssetId == amId))
659+                                                let $t02997630090 = if ((outAssetId == amId))
653660                                                     then $Tuple2(toInt(amount2Return._2), 0)
654661                                                     else $Tuple2(0, toInt(amount2Return._2))
655-                                                let outAm = $t02988630000._1
656-                                                let outPr = $t02988630000._2
662+                                                let outAm = $t02997630090._1
663+                                                let outPr = $t02997630090._2
657664                                                 let curPriceX18 = calcPriceBigInt(toX18(prBalance, prDcm), toX18(amBalance, amDcm))
658665                                                 let curPrice = fromX18(curPriceX18, scale8)
659666                                                 let state = [ScriptTransfer(userAddress, (outAm + outPr), if ((outAssetId == "WAVES"))
673680                                     else throw("Strict value is not equal to itself.")
674681                                 }
675682                         }
676-            }
683+        }
677684 
678685 
679686 
709716             let cfg = getPoolConfig()
710717             let factoryCfg = getFactoryConfig()
711718             let lpAssetId = fromBase58String(cfg[idxLPAsId])
712-            let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
713-            let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
719+            let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
720+            let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
714721             if ((unstakeInv == unstakeInv))
715722                 then {
716723                     let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
717-                    let poolStatus = parseIntValue(r._9)
724+                    let sts = parseIntValue(r._9)
718725                     let state = r._10
719-                    let checkPoolStatus = if (if (isGlobalShutdown())
726+                    let v = if (if (isGlobalShutdown())
720727                         then true
721-                        else (poolStatus == PoolShutdown))
722-                        then throw(("Blocked: " + toString(poolStatus)))
728+                        else (sts == PoolShutdown))
729+                        then throw(("Blocked: " + toString(sts)))
723730                         else true
724-                    if ((checkPoolStatus == checkPoolStatus))
731+                    if ((v == v))
725732                         then {
726733                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
727734                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let scale8 = 100000000
55 
66 let scale8BigInt = toBigInt(100000000)
77 
88 let scale18 = toBigInt(1000000000000000000)
99 
1010 let zeroBigInt = toBigInt(0)
1111 
1212 let oneBigInt = toBigInt(1)
13+
14+let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
1315 
1416 let Amult = "100"
1517 
1618 let Dconv = "1"
1719 
1820 let SEP = "__"
1921 
2022 let EMPTY = ""
2123 
2224 let PoolActive = 1
2325 
2426 let PoolPutDis = 2
2527 
2628 let PoolMatcherDis = 3
2729 
2830 let PoolShutdown = 4
2931 
3032 let idxPoolAddress = 1
3133 
3234 let idxPoolSt = 2
3335 
3436 let idxLPAsId = 3
3537 
3638 let idxAmAsId = 4
3739 
3840 let idxPrAsId = 5
3941 
4042 let idxAmtAsDcm = 6
4143 
4244 let idxPriceAsDcm = 7
4345 
4446 let idxIAmtAsId = 8
4547 
4648 let idxIPriceAsId = 9
4749 
4850 let idxFactStakCntr = 1
4951 
5052 let idxFactSlippCntr = 7
5153 
5254 let idxFactGwxRewCntr = 10
5355 
5456 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
5557 
5658 
5759 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
5860 
5961 
6062 func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
6163 
6264 
6365 func abs (val) = if ((zeroBigInt > val))
6466     then -(val)
6567     else val
6668 
6769 
6870 func keyFactCntr () = "%s__factoryContract"
6971 
7072 
7173 func keyManPubKey () = "%s__managerPublicKey"
7274 
7375 
7476 func keyPriceLast () = "%s%s__price__last"
7577 
7678 
7779 func keyPriceHistory (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
7880 
7981 
8082 func keyPutActionByUser (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
8183 
8284 
8385 func keyGetActionByUser (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
8486 
8587 
8688 func keyAmtAsset () = "%s__amountAsset"
8789 
8890 
8991 func keyPriceAsset () = "%s__priceAsset"
9092 
9193 
9294 func keyAmplificator () = "%s__amp"
9395 
9496 
9597 func keyFactoryConfig () = "%s__factoryConfig"
9698 
9799 
98100 func keyMatcherPub () = "%s%s__matcher__publicKey"
99101 
100102 
101103 func keyPoolConfig (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
102104 
103105 
104106 func keyMappingsBaseAsset2internalId (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
105107 
106108 
107109 func keyAllPoolsShutdown () = "%s__shutdown"
108110 
109111 
110112 func keyPoolWeight (p) = ("%s%s__poolWeight__" + p)
111113 
112114 
113-func throwOrderError (orV,sendrV,matchV) = throw(((((("Failed: orderValid=" + toString(orV)) + " senderValid=") + toString(sendrV)) + " matcherValid=") + toString(matchV)))
115+func throwOrderError (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
114116 
115117 
116118 func asString (val) = match val {
117119     case valStr: String => 
118120         valStr
119121     case _ => 
120122         throw("fail cast to String")
121123 }
122124 
123125 
124-func getStringOrFail (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
126+func getStringOrFail (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
125127 
126128 
127-func getIntOrFail (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
129+func getIntOrFail (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
128130 
129131 
130132 let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactCntr()))
131133 
132134 let A = getStringOrFail(this, keyAmplificator())
133135 
134136 func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
135137 
136138 
137139 func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
138140 
139141 
140142 func getPoolConfig () = {
141143     let amtAs = getStringOrFail(this, keyAmtAsset())
142144     let priceAs = getStringOrFail(this, keyPriceAsset())
143145     let iPriceAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAs))
144146     let iAmtAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAs))
145147     split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAs), toString(iPriceAs))), SEP)
146148     }
147149 
148150 
149151 func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
150152 
151153 
152154 func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
153155 
154156 
155157 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)
156158 
157159 
158160 func getAccBalance (assetId) = if ((assetId == "WAVES"))
159161     then wavesBalance(this).available
160162     else assetBalance(this, fromBase58String(assetId))
161163 
162164 
163165 func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
164166 
165167 
166-func validateAbsDiff (realAmt,expectedAmt,slippage) = {
167-    let diff = fraction((realAmt - expectedAmt), scale8BigInt, expectedAmt)
168-    let passed = ((slippage - abs(diff)) > zeroBigInt)
169-    if (!(passed))
170-        then throw(((("Too big slippage: " + toString(diff)) + " vs ") + toString(slippage)))
171-        else $Tuple2(passed, min([realAmt, expectedAmt]))
168+func validateAbsDiff (A1,A2,slippage) = {
169+    let diff = fraction((A1 - A2), scale8BigInt, A2)
170+    let pass = ((slippage - abs(diff)) > zeroBigInt)
171+    if (!(pass))
172+        then throw(("Big slpg: " + toString(diff)))
173+        else $Tuple2(pass, min([A1, A2]))
174+    }
175+
176+
177+func validateD (D1,D0,slpg) = {
178+    let diff = fraction(D0, scale8BigInt, D1)
179+    let fail = (slpg > diff)
180+    if (if (fail)
181+        then true
182+        else (D0 > D1))
183+        then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
184+        else fail
172185     }
173186 
174187 
175188 func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
176189     let amtAsAmtX18 = toX18(amAmt, amAssetDcm)
177190     let prAsAmtX18 = toX18(prAmt, prAssetDcm)
178191     calcPriceBigInt(prAsAmtX18, amtAsAmtX18)
179192     }
180193 
181194 
182195 func calcPrices (amAmt,prAmt,lpAmt) = {
183196     let cfg = getPoolConfig()
184197     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
185198     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
186199     let priceX18 = privateCalcPrice(amtAsDcm, prAsDcm, amAmt, prAmt)
187200     let amAmtX18 = toX18(amAmt, amtAsDcm)
188201     let prAmtX18 = toX18(prAmt, prAsDcm)
189202     let lpAmtX18 = toX18(lpAmt, scale8)
190203     let lpPrInAmAsX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
191204     let lpPrInPrAsX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
192205 [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
193206     }
194207 
195208 
196209 func calculatePrices (amAmt,prAmt,lpAmt) = {
197-    let prices = calcPrices(amAmt, prAmt, lpAmt)
198-[fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
210+    let p = calcPrices(amAmt, prAmt, lpAmt)
211+[fromX18(p[0], scale8), fromX18(p[1], scale8), fromX18(p[2], scale8)]
199212     }
200213 
201214 
202215 func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
203216     let cfg = getPoolConfig()
204217     let lpId = cfg[idxLPAsId]
205218     let amId = cfg[idxAmAsId]
206219     let prId = cfg[idxPrAsId]
207220     let amDcm = parseIntValue(cfg[idxAmtAsDcm])
208221     let prDcm = parseIntValue(cfg[idxPriceAsDcm])
209-    let poolStatus = cfg[idxPoolSt]
210-    let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Invalid LP id").quantity
222+    let sts = cfg[idxPoolSt]
223+    let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
211224     if ((lpId != pmtAssetId))
212-        then throw("Invalid pmt asset")
225+        then throw("Wrong pmt asset")
213226         else {
214227             let amBalance = getAccBalance(amId)
215228             let amBalanceX18 = toX18(amBalance, amDcm)
216229             let prBalance = getAccBalance(prId)
217230             let prBalanceX18 = toX18(prBalance, prDcm)
218231             let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
219232             let curPrice = fromX18(curPriceX18, scale8)
220233             let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
221-            let lpEmissionX18 = toX18(lpEmission, scale8)
222-            let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
223-            let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
234+            let lpEmissX18 = toX18(lpEmiss, scale8)
235+            let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
236+            let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
224237             let outAmAmt = fromX18(outAmAmtX18, amDcm)
225238             let outPrAmt = fromX18(outPrAmtX18, prDcm)
226239             let state = if ((txId58 == ""))
227240                 then nil
228241                 else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
229242                     then unit
230243                     else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
231244                     then unit
232245                     else fromBase58String(prId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
233-            $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
246+            $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
234247             }
235248     }
236249 
237250 
238251 func estimatePutOperation (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,pmtAmt,pmtId) = {
239252     let cfg = getPoolConfig()
240253     let lpId = fromBase58String(cfg[idxLPAsId])
241254     let amIdStr = cfg[idxAmAsId]
242255     let prIdStr = cfg[idxPrAsId]
243256     let inAmIdStr = cfg[idxIAmtAsId]
244257     let inPrIdStr = cfg[idxIPriceAsId]
245258     let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
246259     let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
247-    let poolStatus = cfg[idxPoolSt]
260+    let sts = cfg[idxPoolSt]
248261     let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
249262     let amBalance = if (isEval)
250263         then getAccBalance(amIdStr)
251264         else if (if (isOneAsset)
252265             then (pmtId == amIdStr)
253266             else false)
254267             then (getAccBalance(amIdStr) - pmtAmt)
255268             else if (isOneAsset)
256269                 then getAccBalance(amIdStr)
257270                 else (getAccBalance(amIdStr) - inAmAmt)
258271     let prBalance = if (isEval)
259272         then getAccBalance(prIdStr)
260273         else if (if (isOneAsset)
261274             then (pmtId == prIdStr)
262275             else false)
263276             then (getAccBalance(prIdStr) - pmtAmt)
264277             else if (isOneAsset)
265278                 then getAccBalance(prIdStr)
266279                 else (getAccBalance(prIdStr) - inPrAmt)
267280     let inAmAssetAmtX18 = toX18(inAmAmt, amtDcm)
268281     let inPrAssetAmtX18 = toX18(inPrAmt, priceDcm)
269282     let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
270283     let amBalanceX18 = toX18(amBalance, amtDcm)
271284     let prBalanceX18 = toX18(prBalance, priceDcm)
272285     let res = if ((lpEm == 0))
273286         then {
274287             let curPriceX18 = zeroBigInt
275288             let slippageX18 = zeroBigInt
276289             let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
277290             $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtDcm), fromX18(inPrAssetAmtX18, priceDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
278291             }
279292         else {
280293             let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
281294             let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
282295             let slippageX18 = toX18(slippage, scale8)
283296             if (if ((curPriceX18 != zeroBigInt))
284297                 then (slippageRealX18 > slippageX18)
285298                 else false)
286299                 then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
287300                 else {
288301                     let lpEmissionX18 = toX18(lpEm, scale8)
289302                     let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
290303                     let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
291304                     let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
292305                         then $Tuple2(amViaPrX18, inPrAssetAmtX18)
293306                         else $Tuple2(inAmAssetAmtX18, prViaAmX18)
294307                     let expAmtAssetAmtX18 = expectedAmts._1
295308                     let expPriceAssetAmtX18 = expectedAmts._2
296309                     let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
297310                     $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtDcm), fromX18(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
298311                     }
299312             }
300313     let calcLpAmt = res._1
301314     let calcAmAssetPmt = res._2
302315     let calcPrAssetPmt = res._3
303316     let curPrice = fromX18(res._4, scale8)
304317     let slippageCalc = fromX18(res._5, scale8)
305318     if ((0 >= calcLpAmt))
306319         then throw("LP <= 0")
307320         else {
308321             let emitLpAmt = if (!(emitLp))
309322                 then 0
310323                 else calcLpAmt
311324             let amDiff = (inAmAmt - calcAmAssetPmt)
312325             let prDiff = (inPrAmt - calcPrAssetPmt)
313-            let $t01564015985 = if (if (isOneAsset)
326+            let $t01582016165 = if (if (isOneAsset)
314327                 then (pmtId == amIdStr)
315328                 else false)
316329                 then $Tuple2(pmtAmt, 0)
317330                 else if (if (isOneAsset)
318331                     then (pmtId == prIdStr)
319332                     else false)
320333                     then $Tuple2(0, pmtAmt)
321334                     else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
322-            let writeAmAmt = $t01564015985._1
323-            let writePrAmt = $t01564015985._2
335+            let writeAmAmt = $t01582016165._1
336+            let writePrAmt = $t01582016165._2
324337             let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
325-            $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
338+            $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
326339             }
327340     }
328341 
329342 
330343 func validateMatcherOrderAllowed (order) = {
331344     let cfg = getPoolConfig()
332345     let amtAsId = cfg[idxAmAsId]
333346     let prAsId = cfg[idxPrAsId]
334-    let poolStatus = parseIntValue(cfg[idxPoolSt])
347+    let sts = parseIntValue(cfg[idxPoolSt])
335348     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
336349     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
337350     let accAmtAsBalance = getAccBalance(amtAsId)
338351     let accPrAsBalance = getAccBalance(prAsId)
339352     let curPriceX18 = if ((order.orderType == Buy))
340353         then privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
341354         else privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
342355     let curPrice = fromX18(curPriceX18, scale8)
343356     if (if (if (isGlobalShutdown())
344357         then true
345-        else (poolStatus == PoolMatcherDis))
358+        else (sts == PoolMatcherDis))
346359         then true
347-        else (poolStatus == PoolShutdown))
360+        else (sts == PoolShutdown))
348361         then throw("Admin blocked")
349362         else {
350363             let orAmtAsset = order.assetPair.amountAsset
351364             let orAmtAsStr = if ((orAmtAsset == unit))
352365                 then "WAVES"
353366                 else toBase58String(value(orAmtAsset))
354367             let orPrAsset = order.assetPair.priceAsset
355368             let orPrAsStr = if ((orPrAsset == unit))
356369                 then "WAVES"
357370                 else toBase58String(value(orPrAsset))
358371             if (if ((orAmtAsStr != amtAsId))
359372                 then true
360373                 else (orPrAsStr != prAsId))
361374                 then throw("Wr assets")
362375                 else {
363376                     let orderPrice = order.price
364377                     let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
365378                     let castOrderPrice = toScale(orderPrice, scale8, priceDcm)
366379                     let isOrderPriceValid = if ((order.orderType == Buy))
367380                         then (curPrice >= castOrderPrice)
368381                         else (castOrderPrice >= curPrice)
369382                     true
370383                     }
371384             }
372385     }
373386 
374387 
375388 func commonGet (i) = if ((size(i.payments) != 1))
376389     then throw("1 pmnt exp")
377390     else {
378391         let pmt = value(i.payments[0])
379392         let pmtAssetId = value(pmt.assetId)
380393         let pmtAmt = pmt.amount
381394         let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
382395         let outAmAmt = res._1
383396         let outPrAmt = res._2
384-        let poolStatus = parseIntValue(res._9)
397+        let sts = parseIntValue(res._9)
385398         let state = res._10
386399         if (if (isGlobalShutdown())
387400             then true
388-            else (poolStatus == PoolShutdown))
389-            then throw(("Admin blocked: " + toString(poolStatus)))
401+            else (sts == PoolShutdown))
402+            then throw(("Admin blocked: " + toString(sts)))
390403             else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
391404         }
392405 
393406 
394407 func commonPut (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,pmtAmt,pmtId) = {
395408     let r = estimatePutOperation(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp, isOneAsset, pmtAmt, pmtId)
396-    let status = parseIntValue(r._8)
409+    let sts = parseIntValue(r._8)
397410     if (if (if (isGlobalShutdown())
398411         then true
399-        else (status == PoolPutDis))
412+        else (sts == PoolPutDis))
400413         then true
401-        else (status == PoolShutdown))
402-        then throw(("Blocked:" + toString(status)))
414+        else (sts == PoolShutdown))
415+        then throw(("Blocked:" + toString(sts)))
403416         else r
404417     }
405418 
406419 
407420 @Callable(i)
408421 func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
409422     then throw("denied")
410423     else [StringEntry(keyFactCntr(), factoryContract), StringEntry(keyManPubKey(), managerPublicKey)]
411424 
412425 
413426 
414427 @Callable(i)
415428 func put (slip,autoStake) = {
416429     let factCfg = getFactoryConfig()
417430     let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
418431     let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
419432     if ((0 > slip))
420-        then throw("Invalid slippage")
433+        then throw("Wrong slippage")
421434         else if ((size(i.payments) != 2))
422435             then throw("2 pmnts expd")
423436             else {
424437                 let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, 0, "")
425438                 let emitLpAmt = estPut._2
426439                 let lpAssetId = estPut._7
427440                 let state = estPut._9
428441                 let amDiff = estPut._10
429442                 let prDiff = estPut._11
430443                 let amId = estPut._12
431444                 let prId = estPut._13
432445                 let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
433446                 if ((emitInv == emitInv))
434447                     then {
435448                         let slippageAInv = if ((amDiff > 0))
436449                             then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
437450                             else nil
438451                         if ((slippageAInv == slippageAInv))
439452                             then {
440453                                 let slippagePInv = if ((prDiff > 0))
441454                                     then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
442455                                     else nil
443456                                 if ((slippagePInv == slippagePInv))
444457                                     then {
445458                                         let lpTrnsfr = if (autoStake)
446459                                             then {
447460                                                 let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
448461                                                 if ((slpStakeInv == slpStakeInv))
449462                                                     then nil
450463                                                     else throw("Strict value is not equal to itself.")
451464                                                 }
452465                                             else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
453466                                         (state ++ lpTrnsfr)
454467                                         }
455468                                     else throw("Strict value is not equal to itself.")
456469                                 }
457470                             else throw("Strict value is not equal to itself.")
458471                         }
459472                     else throw("Strict value is not equal to itself.")
460473                 }
461474     }
462475 
463476 
464477 
465478 @Callable(i)
466479 func putOneTkn (amAssetPart,prAssetPart,outLp,slippage,autoStake) = {
467480     let cfg = getFactoryConfig()
468-    if (true)
469-        then throw("off")
470-        else {
471-            let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
472-            let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
473-            let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
474-            let poolCfg = getPoolConfig()
475-            let amId = poolCfg[idxAmAsId]
476-            let prId = poolCfg[idxPrAsId]
477-            let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
478-            let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
479-            if (if (if (if ((0 >= slippage))
480-                then true
481-                else (0 >= amAssetPart))
482-                then true
483-                else (0 >= prAssetPart))
484-                then true
485-                else (0 >= outLp))
486-                then throw("Wrong params")
487-                else if ((size(i.payments) != 1))
488-                    then throw("1 pmnt expd")
481+    let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
482+    let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
483+    let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
484+    let poolCfg = getPoolConfig()
485+    let amId = poolCfg[idxAmAsId]
486+    let prId = poolCfg[idxPrAsId]
487+    let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
488+    let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
489+    if (if (if (if ((0 >= slippage))
490+        then true
491+        else (0 >= amAssetPart))
492+        then true
493+        else (0 >= prAssetPart))
494+        then true
495+        else (0 >= outLp))
496+        then throw("Wrong params")
497+        else if ((size(i.payments) != 1))
498+            then throw("1 pmnt expd")
499+            else {
500+                let pmt = value(i.payments[0])
501+                let pmtAssetId = toBase58String(value(pmt.assetId))
502+                let pmtAmt = pmt.amount
503+                if (if (if ((amAssetPart > pmtAmt))
504+                    then true
505+                    else (prAssetPart > pmtAmt))
506+                    then true
507+                    else (10000000 > pmtAmt))
508+                    then throw("Wrong pmt amt")
489509                     else {
490-                        let pmt = value(i.payments[0])
491-                        let pmtAssetId = toBase58String(value(pmt.assetId))
492-                        let pmtAmt = pmt.amount
493-                        if (if (if ((amAssetPart > pmtAmt))
494-                            then true
495-                            else (prAssetPart > pmtAmt))
496-                            then true
497-                            else (10000000 > pmtAmt))
498-                            then throw("Wrong pmt amt")
499-                            else {
500-                                let amBalance = getAccBalance(amId)
501-                                let prBalance = getAccBalance(prId)
502-                                let $t02378824168 = if ((pmtAssetId == amId))
503-                                    then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
504-                                    else if ((pmtAssetId == prId))
505-                                        then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
506-                                        else throw("wrong pmtAssetId")
507-                                let amBalanceNow = $t02378824168._1
508-                                let prBalanceNow = $t02378824168._2
509-                                let virtSwapInAm = $t02378824168._3
510-                                let virtSwapOutPr = $t02378824168._4
511-                                let virtSwapInPr = $t02378824168._5
512-                                let virtSwapOutAm = $t02378824168._6
513-                                let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
514-                                let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
515-                                let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), toBigInt(1000))
516-                                if ((D0vsD1 == D0vsD1))
510+                        let amBalance = getAccBalance(amId)
511+                        let prBalance = getAccBalance(prId)
512+                        let $t02390624286 = if ((pmtAssetId == amId))
513+                            then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
514+                            else if ((pmtAssetId == prId))
515+                                then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
516+                                else throw("wrong pmtAssetId")
517+                        let amBalanceNow = $t02390624286._1
518+                        let prBalanceNow = $t02390624286._2
519+                        let virtSwapInAm = $t02390624286._3
520+                        let virtSwapOutPr = $t02390624286._4
521+                        let virtSwapInPr = $t02390624286._5
522+                        let virtSwapOutAm = $t02390624286._6
523+                        let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
524+                        let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
525+                        let D0vsD1 = validateD(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), slippage4D)
526+                        if ((D0vsD1 == D0vsD1))
527+                            then {
528+                                let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
529+                                let estimLP = estPut._2
530+                                let lpAssetId = estPut._7
531+                                let state = estPut._9
532+                                let amDiff = estPut._10
533+                                let prDiff = estPut._11
534+                                let lpCalcRes = validateAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
535+                                let emitLpAmt = toInt(lpCalcRes._2)
536+                                let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
537+                                if ((emitInv == emitInv))
517538                                     then {
518-                                        let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), 50000000000, true, true, pmtAmt, pmtAssetId)
519-                                        let estimLP = estPut._2
520-                                        let lpAssetId = estPut._7
521-                                        let state = estPut._9
522-                                        let amDiff = estPut._10
523-                                        let prDiff = estPut._11
524-                                        let lpCalcRes = validateAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
525-                                        let emitLpAmt = toInt(lpCalcRes._2)
526-                                        let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
527-                                        if ((emitInv == emitInv))
539+                                        let slippageAInv = if ((amDiff > 0))
540+                                            then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
541+                                            else nil
542+                                        if ((slippageAInv == slippageAInv))
528543                                             then {
529-                                                let slippageAInv = if ((amDiff > 0))
530-                                                    then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
544+                                                let slippagePInv = if ((prDiff > 0))
545+                                                    then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
531546                                                     else nil
532-                                                if ((slippageAInv == slippageAInv))
547+                                                if ((slippagePInv == slippagePInv))
533548                                                     then {
534-                                                        let slippagePInv = if ((prDiff > 0))
535-                                                            then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
536-                                                            else nil
537-                                                        if ((slippagePInv == slippagePInv))
549+                                                        let lpTrnsfr = if (autoStake)
538550                                                             then {
539-                                                                let lpTrnsfr = if (autoStake)
540-                                                                    then {
541-                                                                        let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
542-                                                                        if ((slpStakeInv == slpStakeInv))
543-                                                                            then nil
544-                                                                            else throw("Strict value is not equal to itself.")
545-                                                                        }
546-                                                                    else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
547-                                                                (state ++ lpTrnsfr)
551+                                                                let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
552+                                                                if ((slpStakeInv == slpStakeInv))
553+                                                                    then nil
554+                                                                    else throw("Strict value is not equal to itself.")
548555                                                                 }
549-                                                            else throw("Strict value is not equal to itself.")
556+                                                            else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
557+                                                        (state ++ lpTrnsfr)
550558                                                         }
551559                                                     else throw("Strict value is not equal to itself.")
552560                                                 }
553561                                             else throw("Strict value is not equal to itself.")
554562                                         }
555563                                     else throw("Strict value is not equal to itself.")
556564                                 }
565+                            else throw("Strict value is not equal to itself.")
557566                         }
558-            }
567+                }
559568     }
560569 
561570 
562571 
563572 @Callable(i)
564-func putForFree (maxSlippage) = if ((0 > maxSlippage))
565-    then throw("Invalid slippage")
573+func putForFree (maxSlpg) = if ((0 > maxSlpg))
574+    then throw("Wrong slpg")
566575     else if ((size(i.payments) != 2))
567576         then throw("2 pmnts expd")
568577         else {
569-            let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlippage, false, false, 0, "")
578+            let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, 0, "")
570579             estPut._9
571580             }
572581 
573582 
574583 
575584 @Callable(i)
576585 func get () = {
577586     let res = commonGet(i)
578587     let outAmtAmt = res._1
579588     let outPrAmt = res._2
580589     let pmtAmt = res._3
581590     let pmtAssetId = res._4
582591     let state = res._5
583592     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
584593     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
585594         then state
586595         else throw("Strict value is not equal to itself.")
587596     }
588597 
589598 
590599 
591600 @Callable(i)
592-func getOneTkn (amAssetSwap,prAssetSwap,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
601+func getOneTkn (exchResult,notUsed,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
593602     then throw("1 pmnt expd")
594-    else if (true)
595-        then throw("off")
596-        else {
597-            let cfg = getPoolConfig()
598-            let lpId = cfg[idxLPAsId]
599-            let amId = cfg[idxAmAsId]
600-            let prId = cfg[idxPrAsId]
601-            let amDcm = parseIntValue(cfg[idxAmtAsDcm])
602-            let prDcm = parseIntValue(cfg[idxPriceAsDcm])
603-            let poolStatus = cfg[idxPoolSt]
604-            let fcfg = getFactoryConfig()
605-            let gwxCntr = valueOrErrorMessage(addressFromString(fcfg[idxFactGwxRewCntr]), "Wr sl addr")
606-            let pmt = value(i.payments[0])
607-            let userAddress = i.caller
608-            let txId58 = toBase58String(i.transactionId)
609-            let pmtAssetId = value(pmt.assetId)
610-            let pmtAmt = pmt.amount
611-            if (if (if (if ((0 > slippage))
603+    else {
604+        let cfg = getPoolConfig()
605+        let lpId = cfg[idxLPAsId]
606+        let amId = cfg[idxAmAsId]
607+        let prId = cfg[idxPrAsId]
608+        let amDcm = parseIntValue(cfg[idxAmtAsDcm])
609+        let prDcm = parseIntValue(cfg[idxPriceAsDcm])
610+        let sts = cfg[idxPoolSt]
611+        let fcfg = getFactoryConfig()
612+        let gwxCntr = valueOrErrorMessage(addressFromString(fcfg[idxFactGwxRewCntr]), "Wr sl addr")
613+        let pmt = value(i.payments[0])
614+        let userAddress = i.caller
615+        let txId58 = toBase58String(i.transactionId)
616+        let pmtAssetId = value(pmt.assetId)
617+        let pmtAmt = pmt.amount
618+        if ((1000000000 > pmtAmt))
619+            then throw("Min payment is 10 LP")
620+            else if (if (if ((0 > slippage))
612621                 then true
613-                else (0 > amAssetSwap))
614-                then true
615-                else (0 > prAssetSwap))
622+                else (0 > exchResult))
616623                 then true
617624                 else (0 > outAmount))
618625                 then throw("Wrong params")
619626                 else if ((lpId != toBase58String(pmtAssetId)))
620-                    then throw("Invalid LP")
627+                    then throw("Wrong LP")
621628                     else {
622629                         let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
623630                         let estimAmAmt = r._1
624631                         let estimPrAmt = r._2
625632                         let amBalance = getAccBalance(amId)
626633                         let prBalance = getAccBalance(prId)
627-                        let $t02865029134 = if ((outAssetId == amId))
628-                            then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), (outAmount - estimAmAmt), prAssetSwap, 0, 0, (estimAmAmt + amAssetSwap))
634+                        let $t02878029237 = if ((outAssetId == amId))
635+                            then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), exchResult, estimPrAmt, 0, 0, (estimAmAmt + exchResult))
629636                             else if ((outAssetId == prId))
630-                                then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, (outAmount - estimPrAmt), amAssetSwap, (estimPrAmt + prAssetSwap))
637+                                then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, exchResult, estimAmAmt, (estimPrAmt + exchResult))
631638                                 else throw("wrong outAssetId")
632-                        let amBalanceNow = $t02865029134._1
633-                        let prBalanceNow = $t02865029134._2
634-                        let virtSwapInAm = $t02865029134._3
635-                        let virtSwapOutPr = $t02865029134._4
636-                        let virtSwapInPr = $t02865029134._5
637-                        let virtSwapOutAm = $t02865029134._6
638-                        let totalGet = $t02865029134._7
639+                        let amBalanceNow = $t02878029237._1
640+                        let prBalanceNow = $t02878029237._2
641+                        let virtSwapInAm = $t02878029237._3
642+                        let virtSwapOutPr = $t02878029237._4
643+                        let virtSwapInPr = $t02878029237._5
644+                        let virtSwapOutAm = $t02878029237._6
645+                        let totalGet = $t02878029237._7
639646                         if (if ((0 > virtSwapInAm))
640647                             then true
641648                             else (0 > virtSwapInPr))
642-                            then throw("Invalid calc")
649+                            then throw("Wrong calc")
643650                             else {
644651                                 let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
645652                                 let D1 = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
646-                                let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), toBigInt(1000))
653+                                let D0vsD1 = validateD(parseBigIntValue(asString(D1)), parseBigIntValue(asString(D0)), slippage4D)
647654                                 if ((D0vsD1 == D0vsD1))
648655                                     then {
649656                                         let amount2Return = validateAbsDiff(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
650657                                         if ((amount2Return == amount2Return))
651658                                             then {
652-                                                let $t02988630000 = if ((outAssetId == amId))
659+                                                let $t02997630090 = if ((outAssetId == amId))
653660                                                     then $Tuple2(toInt(amount2Return._2), 0)
654661                                                     else $Tuple2(0, toInt(amount2Return._2))
655-                                                let outAm = $t02988630000._1
656-                                                let outPr = $t02988630000._2
662+                                                let outAm = $t02997630090._1
663+                                                let outPr = $t02997630090._2
657664                                                 let curPriceX18 = calcPriceBigInt(toX18(prBalance, prDcm), toX18(amBalance, amDcm))
658665                                                 let curPrice = fromX18(curPriceX18, scale8)
659666                                                 let state = [ScriptTransfer(userAddress, (outAm + outPr), if ((outAssetId == "WAVES"))
660667                                                     then unit
661668                                                     else fromBase58String(outAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
662669                                                 if ((state == state))
663670                                                     then {
664671                                                         let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
665672                                                         if ((burn == burn))
666673                                                             then state
667674                                                             else throw("Strict value is not equal to itself.")
668675                                                         }
669676                                                     else throw("Strict value is not equal to itself.")
670677                                                 }
671678                                             else throw("Strict value is not equal to itself.")
672679                                         }
673680                                     else throw("Strict value is not equal to itself.")
674681                                 }
675682                         }
676-            }
683+        }
677684 
678685 
679686 
680687 @Callable(i)
681688 func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
682689     let res = commonGet(i)
683690     let outAmAmt = res._1
684691     let outPrAmt = res._2
685692     let pmtAmt = res._3
686693     let pmtAssetId = res._4
687694     let state = res._5
688695     if ((noLessThenAmtAsset > outAmAmt))
689696         then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
690697         else if ((noLessThenPriceAsset > outPrAmt))
691698             then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
692699             else {
693700                 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
694701                 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
695702                     then state
696703                     else throw("Strict value is not equal to itself.")
697704                 }
698705     }
699706 
700707 
701708 
702709 @Callable(i)
703710 func unstakeAndGet (amount) = {
704711     let checkPayments = if ((size(i.payments) != 0))
705712         then throw("No pmnts expd")
706713         else true
707714     if ((checkPayments == checkPayments))
708715         then {
709716             let cfg = getPoolConfig()
710717             let factoryCfg = getFactoryConfig()
711718             let lpAssetId = fromBase58String(cfg[idxLPAsId])
712-            let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
713-            let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
719+            let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
720+            let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
714721             if ((unstakeInv == unstakeInv))
715722                 then {
716723                     let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
717-                    let poolStatus = parseIntValue(r._9)
724+                    let sts = parseIntValue(r._9)
718725                     let state = r._10
719-                    let checkPoolStatus = if (if (isGlobalShutdown())
726+                    let v = if (if (isGlobalShutdown())
720727                         then true
721-                        else (poolStatus == PoolShutdown))
722-                        then throw(("Blocked: " + toString(poolStatus)))
728+                        else (sts == PoolShutdown))
729+                        then throw(("Blocked: " + toString(sts)))
723730                         else true
724-                    if ((checkPoolStatus == checkPoolStatus))
731+                    if ((v == v))
725732                         then {
726733                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
727734                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
728735                                 then state
729736                                 else throw("Strict value is not equal to itself.")
730737                             }
731738                         else throw("Strict value is not equal to itself.")
732739                     }
733740                 else throw("Strict value is not equal to itself.")
734741             }
735742         else throw("Strict value is not equal to itself.")
736743     }
737744 
738745 
739746 
740747 @Callable(i)
741748 func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
742749     then throw("denied")
743750     else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
744751 
745752 
746753 
747754 @Callable(i)
748755 func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
749756 
750757 
751758 
752759 @Callable(i)
753760 func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
754761 
755762 
756763 
757764 @Callable(i)
758765 func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
759766     let prices = calcPrices(amAmt, prAmt, lpAmt)
760767     $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
761768     }
762769 
763770 
764771 
765772 @Callable(i)
766773 func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
767774 
768775 
769776 
770777 @Callable(i)
771778 func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
772779 
773780 
774781 
775782 @Callable(i)
776783 func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
777784 
778785 
779786 
780787 @Callable(i)
781788 func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,usrAddr,isEval,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, usrAddr, isEval, emitLp, false, 0, ""))
782789 
783790 
784791 
785792 @Callable(i)
786793 func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
787794     let res = estimateGetOperation(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
788795     $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
789796     }
790797 
791798 
792799 @Verifier(tx)
793800 func verify () = match tx {
794801     case order: Order => 
795802         let mtchPub = getMatcherPubOrFail()
796803         let orV = validateMatcherOrderAllowed(order)
797804         let sndrV = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
798805         let mtchV = sigVerify(order.bodyBytes, order.proofs[1], mtchPub)
799806         if (if (if (orV)
800807             then sndrV
801808             else false)
802809             then mtchV
803810             else false)
804811             then true
805812             else throwOrderError(orV, sndrV, mtchV)
806813     case _ => 
807814         let admin = valueOrElse(getString(this, keyManPubKey()), EMPTY)
808815         if ((admin == EMPTY))
809816             then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
810817             else sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(admin))
811818 }
812819 
github/deemru/w8io/786bc32 
128.86 ms ◑