tx · 7e3Qg9sCxTQoFxxYp7dyZbaRRvwyZ8atfPVeRTRnS6NX

3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT:  -0.01400000 Waves

2021.12.27 21:49 [1853038] smart account 3NAefciWv6f9fWvEXdGgpHfanJFG8HqfjuT > SELF 0.00000000 Waves

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

View: original | compacted
Prev: CdNSm91huzFCj4t5WrkKB1m7yFCzsYFi3Gf8eB3ErswK
Next: HMuTWWd5aC9c7iaMCLMYCH1EdrenMV2FnTXsjZcYs5yR

Diff: 

OldNewDifferences
205205     let prDcm = parseIntValue(cfg[idxPriceAsDcm])
206206     let poolStatus = cfg[idxPoolSt]
207207     let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Invalid LP id").quantity
208-    if ((lpId != pmtAssetId))
209-        then throw("Invalid pmt asset")
210-        else {
211-            let amBalance = getAccBalance(amId)
212-            let amBalanceX18 = toX18(amBalance, amDcm)
213-            let prBalance = getAccBalance(prId)
214-            let prBalanceX18 = toX18(prBalance, prDcm)
215-            let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
216-            let curPrice = fromX18(curPriceX18, scale8)
217-            let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
218-            let lpEmissionX18 = toX18(lpEmission, scale8)
219-            let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
220-            let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
221-            let outAmAmt = fromX18(outAmAmtX18, amDcm)
222-            let outPrAmt = fromX18(outPrAmtX18, prDcm)
223-            let state = if ((txId58 == ""))
224-                then nil
225-                else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
226-                    then unit
227-                    else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
228-                    then unit
229-                    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)]
230-            $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
231-            }
208+    if (true)
209+        then throw(("lpEmission=" + toString(lpEmission)))
210+        else if ((lpId != pmtAssetId))
211+            then throw("Invalid pmt asset")
212+            else {
213+                let amBalance = getAccBalance(amId)
214+                let amBalanceX18 = toX18(amBalance, amDcm)
215+                let prBalance = getAccBalance(prId)
216+                let prBalanceX18 = toX18(prBalance, prDcm)
217+                let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
218+                let curPrice = fromX18(curPriceX18, scale8)
219+                let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
220+                let lpEmissionX18 = toX18(lpEmission, scale8)
221+                let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
222+                let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
223+                let outAmAmt = fromX18(outAmAmtX18, amDcm)
224+                let outPrAmt = fromX18(outPrAmtX18, prDcm)
225+                let state = if ((txId58 == ""))
226+                    then nil
227+                    else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
228+                        then unit
229+                        else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
230+                        then unit
231+                        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)]
232+                $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
233+                }
232234     }
233235 
234236 
475477                 let pmtAmt = pmt.amount
476478                 let amBalance = getAccBalance(amId)
477479                 let prBalance = getAccBalance(prId)
478-                let $t02322223602 = if ((pmtAssetId == amId))
480+                let $t02322023600 = if ((pmtAssetId == amId))
479481                     then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
480482                     else if ((pmtAssetId == prId))
481483                         then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
482484                         else throw("wrong pmtAssetId")
483-                let amBalanceNow = $t02322223602._1
484-                let prBalanceNow = $t02322223602._2
485-                let virtSwapInAm = $t02322223602._3
486-                let virtSwapOutPr = $t02322223602._4
487-                let virtSwapInPr = $t02322223602._5
488-                let virtSwapOutAm = $t02322223602._6
485+                let amBalanceNow = $t02322023600._1
486+                let prBalanceNow = $t02322023600._2
487+                let virtSwapInAm = $t02322023600._3
488+                let virtSwapOutPr = $t02322023600._4
489+                let virtSwapInPr = $t02322023600._5
490+                let virtSwapOutAm = $t02322023600._6
489491                 let dCur = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
490492                 let dNew = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
491493                 let dCurBIG = parseBigIntValue(asString(dCur))
606608                             let estimPrAmt = r._2
607609                             let amBalance = getAccBalance(amId)
608610                             let prBalance = getAccBalance(prId)
609-                            let $t02826828752 = if ((outAssetId == amId))
611+                            let $t02826628750 = if ((outAssetId == amId))
610612                                 then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), (outAmount - estimAmAmt), prAssetSwap, 0, 0, (estimAmAmt + amAssetSwap))
611613                                 else if ((outAssetId == prId))
612614                                     then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, (outAmount - estimPrAmt), amAssetSwap, (estimPrAmt + prAssetSwap))
613615                                     else throw("wrong outAssetId")
614-                            let amBalanceNow = $t02826828752._1
615-                            let prBalanceNow = $t02826828752._2
616-                            let virtSwapInAm = $t02826828752._3
617-                            let virtSwapOutPr = $t02826828752._4
618-                            let virtSwapInPr = $t02826828752._5
619-                            let virtSwapOutAm = $t02826828752._6
620-                            let totalGet = $t02826828752._7
616+                            let amBalanceNow = $t02826628750._1
617+                            let prBalanceNow = $t02826628750._2
618+                            let virtSwapInAm = $t02826628750._3
619+                            let virtSwapOutPr = $t02826628750._4
620+                            let virtSwapInPr = $t02826628750._5
621+                            let virtSwapOutAm = $t02826628750._6
622+                            let totalGet = $t02826628750._7
621623                             let invLeft = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
622624                             let invRight = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
623-                            if (true)
624-                                then throw(((("invLeft=" + asString(invLeft)) + " invRight=") + asString(invRight)))
625-                                else {
626-                                    let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))
627-                                    if ((D0vsD1 == D0vsD1))
625+                            let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))
626+                            if ((D0vsD1 == D0vsD1))
627+                                then {
628+                                    let amount2Return = validateAbsDiff(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
629+                                    if ((amount2Return == amount2Return))
628630                                         then {
629-                                            let amount2Return = validateAbsDiff(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
630-                                            if ((amount2Return == amount2Return))
631+                                            let resultTuple = if ((outAssetId == amId))
632+                                                then $Tuple2(toInt(amount2Return._2), 0)
633+                                                else $Tuple2(0, toInt(amount2Return._2))
634+                                            let curPriceX18 = calcPriceBigInt(toX18(prBalance, prDcm), toX18(amBalance, amDcm))
635+                                            let curPrice = fromX18(curPriceX18, scale8)
636+                                            let state = [ScriptTransfer(userAddress, if ((resultAssetId == amId))
637+                                                then resultTuple._1
638+                                                else resultTuple._2, if ((resultAssetId == "WAVES"))
639+                                                then unit
640+                                                else fromBase58String(resultAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(resultTuple._1, resultTuple._2, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
641+                                            if ((state == state))
631642                                                 then {
632-                                                    let resultTuple = if ((outAssetId == amId))
633-                                                        then $Tuple2(toInt(amount2Return._2), 0)
634-                                                        else $Tuple2(0, toInt(amount2Return._2))
635-                                                    let curPriceX18 = calcPriceBigInt(toX18(prBalance, prDcm), toX18(amBalance, amDcm))
636-                                                    let curPrice = fromX18(curPriceX18, scale8)
637-                                                    let state = [ScriptTransfer(userAddress, if ((resultAssetId == amId))
638-                                                        then resultTuple._1
639-                                                        else resultTuple._2, if ((resultAssetId == "WAVES"))
640-                                                        then unit
641-                                                        else fromBase58String(resultAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(resultTuple._1, resultTuple._2, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
642-                                                    if ((state == state))
643-                                                        then {
644-                                                            let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
645-                                                            if ((burn == burn))
646-                                                                then state
647-                                                                else throw("Strict value is not equal to itself.")
648-                                                            }
643+                                                    let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
644+                                                    if ((burn == burn))
645+                                                        then state
649646                                                         else throw("Strict value is not equal to itself.")
650647                                                     }
651648                                                 else throw("Strict value is not equal to itself.")
652649                                             }
653650                                         else throw("Strict value is not equal to itself.")
654651                                     }
652+                                else throw("Strict value is not equal to itself.")
655653                             }
656654                 }
657655         }

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)
1313 
1414 let A = "50"
1515 
1616 let Amult = "100000000"
1717 
1818 let Dconv = "1"
1919 
2020 let SEP = "__"
2121 
2222 let EMPTY = ""
2323 
2424 let PoolActive = 1
2525 
2626 let PoolPutDis = 2
2727 
2828 let PoolMatcherDis = 3
2929 
3030 let PoolShutdown = 4
3131 
3232 let idxPoolAddress = 1
3333 
3434 let idxPoolSt = 2
3535 
3636 let idxLPAsId = 3
3737 
3838 let idxAmAsId = 4
3939 
4040 let idxPrAsId = 5
4141 
4242 let idxAmtAsDcm = 6
4343 
4444 let idxPriceAsDcm = 7
4545 
4646 let idxIAmtAsId = 8
4747 
4848 let idxIPriceAsId = 9
4949 
5050 let idxFactStakCntr = 1
5151 
5252 let idxFactSlippCntr = 7
5353 
5454 let idxFactGwxRewCntr = 10
5555 
5656 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
5757 
5858 
5959 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
6060 
6161 
6262 func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
6363 
6464 
6565 func abs (val) = if ((zeroBigInt > val))
6666     then -(val)
6767     else val
6868 
6969 
7070 func keyFactCntr () = "%s__factoryContract"
7171 
7272 
7373 func keyManPubKey () = "%s__managerPublicKey"
7474 
7575 
7676 func keyPriceLast () = "%s%s__price__last"
7777 
7878 
7979 func keyPriceHistory (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
8080 
8181 
8282 func keyPutActionByUser (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
8383 
8484 
8585 func keyGetActionByUser (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
8686 
8787 
8888 func keyAmtAsset () = "%s__amountAsset"
8989 
9090 
9191 func keyPriceAsset () = "%s__priceAsset"
9292 
9393 
9494 func keyFactoryConfig () = "%s__factoryConfig"
9595 
9696 
9797 func keyMatcherPub () = "%s%s__matcher__publicKey"
9898 
9999 
100100 func keyPoolConfig (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
101101 
102102 
103103 func keyMappingsBaseAsset2internalId (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
104104 
105105 
106106 func keyAllPoolsShutdown () = "%s__shutdown"
107107 
108108 
109109 func keyPoolWeight (p) = ("%s%s__poolWeight__" + p)
110110 
111111 
112112 func throwOrderError (orV,sendrV,matchV) = throw(((((("Failed: orderValid=" + toString(orV)) + " senderValid=") + toString(sendrV)) + " matcherValid=") + toString(matchV)))
113113 
114114 
115115 func asString (val) = match val {
116116     case valStr: String => 
117117         valStr
118118     case _ => 
119119         throw("fail cast to String")
120120 }
121121 
122122 
123123 func getStringOrFail (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
124124 
125125 
126126 func getIntOrFail (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " is not defined"], ""))
127127 
128128 
129129 let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactCntr()))
130130 
131131 func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
132132 
133133 
134134 func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
135135 
136136 
137137 func getPoolConfig () = {
138138     let amtAs = getStringOrFail(this, keyAmtAsset())
139139     let priceAs = getStringOrFail(this, keyPriceAsset())
140140     let iPriceAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAs))
141141     let iAmtAs = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAs))
142142     split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAs), toString(iPriceAs))), SEP)
143143     }
144144 
145145 
146146 func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
147147 
148148 
149149 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)
150150 
151151 
152152 func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
153153 
154154 
155155 func getAccBalance (assetId) = if ((assetId == "WAVES"))
156156     then wavesBalance(this).available
157157     else assetBalance(this, fromBase58String(assetId))
158158 
159159 
160160 func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
161161 
162162 
163163 func validateAbsDiff (realAmt,expectedAmt,slippage) = {
164164     let diff = fraction((realAmt - expectedAmt), scale8BigInt, expectedAmt)
165165     let passed = ((slippage - abs(diff)) > zeroBigInt)
166166     if (!(passed))
167167         then throw(((("Too big slippage: " + toString(diff)) + " vs ") + toString(slippage)))
168168         else $Tuple2(passed, min([realAmt, expectedAmt]))
169169     }
170170 
171171 
172172 func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
173173     let amtAsAmtX18 = toX18(amAmt, amAssetDcm)
174174     let prAsAmtX18 = toX18(prAmt, prAssetDcm)
175175     calcPriceBigInt(prAsAmtX18, amtAsAmtX18)
176176     }
177177 
178178 
179179 func calcPrices (amAmt,prAmt,lpAmt) = {
180180     let cfg = getPoolConfig()
181181     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
182182     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
183183     let priceX18 = privateCalcPrice(amtAsDcm, prAsDcm, amAmt, prAmt)
184184     let amAmtX18 = toX18(amAmt, amtAsDcm)
185185     let prAmtX18 = toX18(prAmt, prAsDcm)
186186     let lpAmtX18 = toX18(lpAmt, scale8)
187187     let lpPrInAmAsX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
188188     let lpPrInPrAsX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
189189 [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
190190     }
191191 
192192 
193193 func calculatePrices (amAmt,prAmt,lpAmt) = {
194194     let prices = calcPrices(amAmt, prAmt, lpAmt)
195195 [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
196196     }
197197 
198198 
199199 func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
200200     let cfg = getPoolConfig()
201201     let lpId = cfg[idxLPAsId]
202202     let amId = cfg[idxAmAsId]
203203     let prId = cfg[idxPrAsId]
204204     let amDcm = parseIntValue(cfg[idxAmtAsDcm])
205205     let prDcm = parseIntValue(cfg[idxPriceAsDcm])
206206     let poolStatus = cfg[idxPoolSt]
207207     let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Invalid LP id").quantity
208-    if ((lpId != pmtAssetId))
209-        then throw("Invalid pmt asset")
210-        else {
211-            let amBalance = getAccBalance(amId)
212-            let amBalanceX18 = toX18(amBalance, amDcm)
213-            let prBalance = getAccBalance(prId)
214-            let prBalanceX18 = toX18(prBalance, prDcm)
215-            let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
216-            let curPrice = fromX18(curPriceX18, scale8)
217-            let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
218-            let lpEmissionX18 = toX18(lpEmission, scale8)
219-            let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
220-            let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
221-            let outAmAmt = fromX18(outAmAmtX18, amDcm)
222-            let outPrAmt = fromX18(outPrAmtX18, prDcm)
223-            let state = if ((txId58 == ""))
224-                then nil
225-                else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
226-                    then unit
227-                    else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
228-                    then unit
229-                    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)]
230-            $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
231-            }
208+    if (true)
209+        then throw(("lpEmission=" + toString(lpEmission)))
210+        else if ((lpId != pmtAssetId))
211+            then throw("Invalid pmt asset")
212+            else {
213+                let amBalance = getAccBalance(amId)
214+                let amBalanceX18 = toX18(amBalance, amDcm)
215+                let prBalance = getAccBalance(prId)
216+                let prBalanceX18 = toX18(prBalance, prDcm)
217+                let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
218+                let curPrice = fromX18(curPriceX18, scale8)
219+                let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
220+                let lpEmissionX18 = toX18(lpEmission, scale8)
221+                let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
222+                let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
223+                let outAmAmt = fromX18(outAmAmtX18, amDcm)
224+                let outPrAmt = fromX18(outPrAmtX18, prDcm)
225+                let state = if ((txId58 == ""))
226+                    then nil
227+                    else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
228+                        then unit
229+                        else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
230+                        then unit
231+                        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)]
232+                $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
233+                }
232234     }
233235 
234236 
235237 func estimatePutOperation (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,pmtAmt,pmtId) = {
236238     let cfg = getPoolConfig()
237239     let lpId = fromBase58String(cfg[idxLPAsId])
238240     let amIdStr = cfg[idxAmAsId]
239241     let prIdStr = cfg[idxPrAsId]
240242     let inAmIdStr = cfg[idxIAmtAsId]
241243     let inPrIdStr = cfg[idxIPriceAsId]
242244     let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
243245     let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
244246     let poolStatus = cfg[idxPoolSt]
245247     let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
246248     let amBalance = if (isEval)
247249         then getAccBalance(amIdStr)
248250         else if (if (isOneAsset)
249251             then (pmtId == amIdStr)
250252             else false)
251253             then (getAccBalance(amIdStr) - pmtAmt)
252254             else if (isOneAsset)
253255                 then getAccBalance(amIdStr)
254256                 else (getAccBalance(amIdStr) - inAmAmt)
255257     let prBalance = if (isEval)
256258         then getAccBalance(prIdStr)
257259         else if (if (isOneAsset)
258260             then (pmtId == prIdStr)
259261             else false)
260262             then (getAccBalance(prIdStr) - pmtAmt)
261263             else if (isOneAsset)
262264                 then getAccBalance(prIdStr)
263265                 else (getAccBalance(prIdStr) - inPrAmt)
264266     let inAmAssetAmtX18 = toX18(inAmAmt, amtDcm)
265267     let inPrAssetAmtX18 = toX18(inPrAmt, priceDcm)
266268     let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
267269     let amBalanceX18 = toX18(amBalance, amtDcm)
268270     let prBalanceX18 = toX18(prBalance, priceDcm)
269271     let res = if ((lpEm == 0))
270272         then {
271273             let curPriceX18 = zeroBigInt
272274             let slippageX18 = zeroBigInt
273275             let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
274276             $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtDcm), fromX18(inPrAssetAmtX18, priceDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
275277             }
276278         else {
277279             let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
278280             let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
279281             let slippageX18 = toX18(slippage, scale8)
280282             if (if ((curPriceX18 != zeroBigInt))
281283                 then (slippageRealX18 > slippageX18)
282284                 else false)
283285                 then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
284286                 else {
285287                     let lpEmissionX18 = toX18(lpEm, scale8)
286288                     let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
287289                     let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
288290                     let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
289291                         then $Tuple2(amViaPrX18, inPrAssetAmtX18)
290292                         else $Tuple2(inAmAssetAmtX18, prViaAmX18)
291293                     let expAmtAssetAmtX18 = expectedAmts._1
292294                     let expPriceAssetAmtX18 = expectedAmts._2
293295                     let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
294296                     $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtDcm), fromX18(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
295297                     }
296298             }
297299     let calcLpAmt = res._1
298300     let calcAmAssetPmt = res._2
299301     let calcPrAssetPmt = res._3
300302     let curPrice = fromX18(res._4, scale8)
301303     let slippageCalc = fromX18(res._5, scale8)
302304     if ((0 >= calcLpAmt))
303305         then throw("LP <= 0")
304306         else {
305307             let emitLpAmt = if (!(emitLp))
306308                 then 0
307309                 else calcLpAmt
308310             let amDiff = (inAmAmt - calcAmAssetPmt)
309311             let prDiff = (inPrAmt - calcPrAssetPmt)
310312             let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
311313             $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, poolStatus, commonState, amDiff, prDiff, inAmId, inPrId)
312314             }
313315     }
314316 
315317 
316318 func validateMatcherOrderAllowed (order) = {
317319     let cfg = getPoolConfig()
318320     let amtAsId = cfg[idxAmAsId]
319321     let prAsId = cfg[idxPrAsId]
320322     let poolStatus = parseIntValue(cfg[idxPoolSt])
321323     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
322324     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
323325     let accAmtAsBalance = getAccBalance(amtAsId)
324326     let accPrAsBalance = getAccBalance(prAsId)
325327     let curPriceX18 = if ((order.orderType == Buy))
326328         then privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
327329         else privateCalcPrice(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
328330     let curPrice = fromX18(curPriceX18, scale8)
329331     if (if (if (isGlobalShutdown())
330332         then true
331333         else (poolStatus == PoolMatcherDis))
332334         then true
333335         else (poolStatus == PoolShutdown))
334336         then throw("Admin blocked")
335337         else {
336338             let orAmtAsset = order.assetPair.amountAsset
337339             let orAmtAsStr = if ((orAmtAsset == unit))
338340                 then "WAVES"
339341                 else toBase58String(value(orAmtAsset))
340342             let orPrAsset = order.assetPair.priceAsset
341343             let orPrAsStr = if ((orPrAsset == unit))
342344                 then "WAVES"
343345                 else toBase58String(value(orPrAsset))
344346             if (if ((orAmtAsStr != amtAsId))
345347                 then true
346348                 else (orPrAsStr != prAsId))
347349                 then throw("Wr assets")
348350                 else {
349351                     let orderPrice = order.price
350352                     let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
351353                     let castOrderPrice = toScale(orderPrice, scale8, priceDcm)
352354                     let isOrderPriceValid = if ((order.orderType == Buy))
353355                         then (curPrice >= castOrderPrice)
354356                         else (castOrderPrice >= curPrice)
355357                     true
356358                     }
357359             }
358360     }
359361 
360362 
361363 func commonGet (i) = if ((size(i.payments) != 1))
362364     then throw("1 pmnt expected")
363365     else {
364366         let pmt = value(i.payments[0])
365367         let pmtAssetId = value(pmt.assetId)
366368         let pmtAmt = pmt.amount
367369         let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
368370         let outAmAmt = res._1
369371         let outPrAmt = res._2
370372         let poolStatus = parseIntValue(res._9)
371373         let state = res._10
372374         if (if (isGlobalShutdown())
373375             then true
374376             else (poolStatus == PoolShutdown))
375377             then throw(("Admion blocked: " + toString(poolStatus)))
376378             else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
377379         }
378380 
379381 
380382 func commonPut (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,pmtAmt,pmtId) = {
381383     let r = estimatePutOperation(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp, isOneAsset, pmtAmt, pmtId)
382384     let status = parseIntValue(r._8)
383385     if (if (if (isGlobalShutdown())
384386         then true
385387         else (status == PoolPutDis))
386388         then true
387389         else (status == PoolShutdown))
388390         then throw(("Admin blocked: " + toString(status)))
389391         else r
390392     }
391393 
392394 
393395 @Callable(i)
394396 func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
395397     then throw("permission denied")
396398     else [StringEntry(keyFactCntr(), factoryContract), StringEntry(keyManPubKey(), managerPublicKey)]
397399 
398400 
399401 
400402 @Callable(i)
401403 func put (slip,autoStake) = {
402404     let factCfg = getFactoryConfig()
403405     let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
404406     let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
405407     if ((0 > slip))
406408         then throw("Invalid slippage.")
407409         else if ((size(i.payments) != 2))
408410             then throw("2 pmnts expected")
409411             else {
410412                 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, "")
411413                 let emitLpAmt = estPut._2
412414                 let lpAssetId = estPut._7
413415                 let state = estPut._9
414416                 let amDiff = estPut._10
415417                 let prDiff = estPut._11
416418                 let amId = estPut._12
417419                 let prId = estPut._13
418420                 let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
419421                 if ((emitInv == emitInv))
420422                     then {
421423                         let slippageAInv = if ((amDiff > 0))
422424                             then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
423425                             else nil
424426                         if ((slippageAInv == slippageAInv))
425427                             then {
426428                                 let slippagePInv = if ((prDiff > 0))
427429                                     then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
428430                                     else nil
429431                                 if ((slippagePInv == slippagePInv))
430432                                     then {
431433                                         let lpTrnsfr = if (autoStake)
432434                                             then {
433435                                                 let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
434436                                                 if ((slpStakeInv == slpStakeInv))
435437                                                     then nil
436438                                                     else throw("Strict value is not equal to itself.")
437439                                                 }
438440                                             else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
439441                                         (state ++ lpTrnsfr)
440442                                         }
441443                                     else throw("Strict value is not equal to itself.")
442444                                 }
443445                             else throw("Strict value is not equal to itself.")
444446                         }
445447                     else throw("Strict value is not equal to itself.")
446448                 }
447449     }
448450 
449451 
450452 
451453 @Callable(i)
452454 func putOneTkn (amAssetPart,prAssetPart,outLp,slippage,autoStake) = {
453455     let cfg = getFactoryConfig()
454456     let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
455457     let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
456458     let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
457459     let poolCfg = getPoolConfig()
458460     let amId = poolCfg[idxAmAsId]
459461     let prId = poolCfg[idxPrAsId]
460462     let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
461463     let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
462464     if (if (if (if ((0 >= slippage))
463465         then true
464466         else (0 >= amAssetPart))
465467         then true
466468         else (0 >= prAssetPart))
467469         then true
468470         else (0 >= outLp))
469471         then throw("Wrong params")
470472         else if ((size(i.payments) != 1))
471473             then throw("1 pmnt expected")
472474             else {
473475                 let pmt = value(i.payments[0])
474476                 let pmtAssetId = toBase58String(value(pmt.assetId))
475477                 let pmtAmt = pmt.amount
476478                 let amBalance = getAccBalance(amId)
477479                 let prBalance = getAccBalance(prId)
478-                let $t02322223602 = if ((pmtAssetId == amId))
480+                let $t02322023600 = if ((pmtAssetId == amId))
479481                     then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
480482                     else if ((pmtAssetId == prId))
481483                         then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
482484                         else throw("wrong pmtAssetId")
483-                let amBalanceNow = $t02322223602._1
484-                let prBalanceNow = $t02322223602._2
485-                let virtSwapInAm = $t02322223602._3
486-                let virtSwapOutPr = $t02322223602._4
487-                let virtSwapInPr = $t02322223602._5
488-                let virtSwapOutAm = $t02322223602._6
485+                let amBalanceNow = $t02322023600._1
486+                let prBalanceNow = $t02322023600._2
487+                let virtSwapInAm = $t02322023600._3
488+                let virtSwapOutPr = $t02322023600._4
489+                let virtSwapInPr = $t02322023600._5
490+                let virtSwapOutAm = $t02322023600._6
489491                 let dCur = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
490492                 let dNew = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
491493                 let dCurBIG = parseBigIntValue(asString(dCur))
492494                 let dNewBIG = parseBigIntValue(asString(dNew))
493495                 let D0vsD1 = validateAbsDiff(dNewBIG, dCurBIG, toBigInt(1000))
494496                 if ((D0vsD1 == D0vsD1))
495497                     then {
496498                         let estPut = commonPut(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), 50000000000, true, true, pmtAmt, pmtAssetId)
497499                         let estimLP = estPut._2
498500                         let lpAssetId = estPut._7
499501                         let state = estPut._9
500502                         let amDiff = estPut._10
501503                         let prDiff = estPut._11
502504                         let lpCalcRes = validateAbsDiff(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
503505                         let emitLpAmt = toInt(lpCalcRes._2)
504506                         let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
505507                         if ((emitInv == emitInv))
506508                             then {
507509                                 let slippageAInv = if ((amDiff > 0))
508510                                     then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
509511                                     else nil
510512                                 if ((slippageAInv == slippageAInv))
511513                                     then {
512514                                         let slippagePInv = if ((prDiff > 0))
513515                                             then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
514516                                             else nil
515517                                         if ((slippagePInv == slippagePInv))
516518                                             then {
517519                                                 let lpTrnsfr = if (autoStake)
518520                                                     then {
519521                                                         let slpStakeInv = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
520522                                                         if ((slpStakeInv == slpStakeInv))
521523                                                             then nil
522524                                                             else throw("Strict value is not equal to itself.")
523525                                                         }
524526                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
525527                                                 (state ++ lpTrnsfr)
526528                                                 }
527529                                             else throw("Strict value is not equal to itself.")
528530                                         }
529531                                     else throw("Strict value is not equal to itself.")
530532                                 }
531533                             else throw("Strict value is not equal to itself.")
532534                         }
533535                     else throw("Strict value is not equal to itself.")
534536                 }
535537     }
536538 
537539 
538540 
539541 @Callable(i)
540542 func putForFree (maxSlippage) = if ((0 > maxSlippage))
541543     then throw("Invalid slippage")
542544     else if ((size(i.payments) != 2))
543545         then throw("2 payments expected")
544546         else {
545547             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, "")
546548             estPut._9
547549             }
548550 
549551 
550552 
551553 @Callable(i)
552554 func get () = {
553555     let res = commonGet(i)
554556     let outAmtAmt = res._1
555557     let outPrAmt = res._2
556558     let pmtAmt = res._3
557559     let pmtAssetId = res._4
558560     let state = res._5
559561     let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
560562     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
561563         then state
562564         else throw("Strict value is not equal to itself.")
563565     }
564566 
565567 
566568 
567569 @Callable(i)
568570 func getOneTkn (amAssetSwap,prAssetSwap,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
569571     then throw("1 payment expected")
570572     else {
571573         let cfg = getPoolConfig()
572574         let lpId = cfg[idxLPAsId]
573575         let amId = cfg[idxAmAsId]
574576         let prId = cfg[idxPrAsId]
575577         let amDcm = parseIntValue(cfg[idxAmtAsDcm])
576578         let prDcm = parseIntValue(cfg[idxPriceAsDcm])
577579         let poolStatus = cfg[idxPoolSt]
578580         let fcfg = getFactoryConfig()
579581         let gwxCntr = valueOrErrorMessage(addressFromString(fcfg[idxFactGwxRewCntr]), "Wr sl addr")
580582         if (if ((outAssetId != amId))
581583             then (outAssetId != prId)
582584             else false)
583585             then throw("Wr out as")
584586             else {
585587                 let resultAssetId = if ((outAssetId == amId))
586588                     then amId
587589                     else prId
588590                 let pmt = value(i.payments[0])
589591                 let userAddress = i.caller
590592                 let txId58 = toBase58String(i.transactionId)
591593                 let pmtAssetId = value(pmt.assetId)
592594                 let pmtAmt = pmt.amount
593595                 if (if (if (if ((0 > slippage))
594596                     then true
595597                     else (0 > amAssetSwap))
596598                     then true
597599                     else (0 > prAssetSwap))
598600                     then true
599601                     else (0 > outAmount))
600602                     then throw("Wrong params")
601603                     else if ((lpId != toBase58String(pmtAssetId)))
602604                         then throw("Invalid LP")
603605                         else {
604606                             let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
605607                             let estimAmAmt = r._1
606608                             let estimPrAmt = r._2
607609                             let amBalance = getAccBalance(amId)
608610                             let prBalance = getAccBalance(prId)
609-                            let $t02826828752 = if ((outAssetId == amId))
611+                            let $t02826628750 = if ((outAssetId == amId))
610612                                 then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), (outAmount - estimAmAmt), prAssetSwap, 0, 0, (estimAmAmt + amAssetSwap))
611613                                 else if ((outAssetId == prId))
612614                                     then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, (outAmount - estimPrAmt), amAssetSwap, (estimPrAmt + prAssetSwap))
613615                                     else throw("wrong outAssetId")
614-                            let amBalanceNow = $t02826828752._1
615-                            let prBalanceNow = $t02826828752._2
616-                            let virtSwapInAm = $t02826828752._3
617-                            let virtSwapOutPr = $t02826828752._4
618-                            let virtSwapInPr = $t02826828752._5
619-                            let virtSwapOutAm = $t02826828752._6
620-                            let totalGet = $t02826828752._7
616+                            let amBalanceNow = $t02826628750._1
617+                            let prBalanceNow = $t02826628750._2
618+                            let virtSwapInAm = $t02826628750._3
619+                            let virtSwapOutPr = $t02826628750._4
620+                            let virtSwapInPr = $t02826628750._5
621+                            let virtSwapOutAm = $t02826628750._6
622+                            let totalGet = $t02826628750._7
621623                             let invLeft = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
622624                             let invRight = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
623-                            if (true)
624-                                then throw(((("invLeft=" + asString(invLeft)) + " invRight=") + asString(invRight)))
625-                                else {
626-                                    let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))
627-                                    if ((D0vsD1 == D0vsD1))
625+                            let D0vsD1 = validateAbsDiff(parseBigIntValue(asString(invRight)), parseBigIntValue(asString(invLeft)), toBigInt(1000))
626+                            if ((D0vsD1 == D0vsD1))
627+                                then {
628+                                    let amount2Return = validateAbsDiff(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
629+                                    if ((amount2Return == amount2Return))
628630                                         then {
629-                                            let amount2Return = validateAbsDiff(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
630-                                            if ((amount2Return == amount2Return))
631+                                            let resultTuple = if ((outAssetId == amId))
632+                                                then $Tuple2(toInt(amount2Return._2), 0)
633+                                                else $Tuple2(0, toInt(amount2Return._2))
634+                                            let curPriceX18 = calcPriceBigInt(toX18(prBalance, prDcm), toX18(amBalance, amDcm))
635+                                            let curPrice = fromX18(curPriceX18, scale8)
636+                                            let state = [ScriptTransfer(userAddress, if ((resultAssetId == amId))
637+                                                then resultTuple._1
638+                                                else resultTuple._2, if ((resultAssetId == "WAVES"))
639+                                                then unit
640+                                                else fromBase58String(resultAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(resultTuple._1, resultTuple._2, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
641+                                            if ((state == state))
631642                                                 then {
632-                                                    let resultTuple = if ((outAssetId == amId))
633-                                                        then $Tuple2(toInt(amount2Return._2), 0)
634-                                                        else $Tuple2(0, toInt(amount2Return._2))
635-                                                    let curPriceX18 = calcPriceBigInt(toX18(prBalance, prDcm), toX18(amBalance, amDcm))
636-                                                    let curPrice = fromX18(curPriceX18, scale8)
637-                                                    let state = [ScriptTransfer(userAddress, if ((resultAssetId == amId))
638-                                                        then resultTuple._1
639-                                                        else resultTuple._2, if ((resultAssetId == "WAVES"))
640-                                                        then unit
641-                                                        else fromBase58String(resultAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(resultTuple._1, resultTuple._2, pmtAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
642-                                                    if ((state == state))
643-                                                        then {
644-                                                            let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
645-                                                            if ((burn == burn))
646-                                                                then state
647-                                                                else throw("Strict value is not equal to itself.")
648-                                                            }
643+                                                    let burn = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
644+                                                    if ((burn == burn))
645+                                                        then state
649646                                                         else throw("Strict value is not equal to itself.")
650647                                                     }
651648                                                 else throw("Strict value is not equal to itself.")
652649                                             }
653650                                         else throw("Strict value is not equal to itself.")
654651                                     }
652+                                else throw("Strict value is not equal to itself.")
655653                             }
656654                 }
657655         }
658656 
659657 
660658 
661659 @Callable(i)
662660 func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
663661     let res = commonGet(i)
664662     let outAmAmt = res._1
665663     let outPrAmt = res._2
666664     let pmtAmt = res._3
667665     let pmtAssetId = res._4
668666     let state = res._5
669667     if ((noLessThenAmtAsset > outAmAmt))
670668         then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
671669         else if ((noLessThenPriceAsset > outPrAmt))
672670             then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
673671             else {
674672                 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
675673                 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
676674                     then state
677675                     else throw("Strict value is not equal to itself.")
678676                 }
679677     }
680678 
681679 
682680 
683681 @Callable(i)
684682 func unstakeAndGet (amount) = {
685683     let checkPayments = if ((size(i.payments) != 0))
686684         then throw("No pmnts expected")
687685         else true
688686     if ((checkPayments == checkPayments))
689687         then {
690688             let cfg = getPoolConfig()
691689             let factoryCfg = getFactoryConfig()
692690             let lpAssetId = fromBase58String(cfg[idxLPAsId])
693691             let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
694692             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
695693             if ((unstakeInv == unstakeInv))
696694                 then {
697695                     let r = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
698696                     let poolStatus = parseIntValue(r._9)
699697                     let state = r._10
700698                     let checkPoolStatus = if (if (isGlobalShutdown())
701699                         then true
702700                         else (poolStatus == PoolShutdown))
703701                         then throw(("Admin blocked: " + toString(poolStatus)))
704702                         else true
705703                     if ((checkPoolStatus == checkPoolStatus))
706704                         then {
707705                             let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
708706                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
709707                                 then state
710708                                 else throw("Strict value is not equal to itself.")
711709                             }
712710                         else throw("Strict value is not equal to itself.")
713711                     }
714712                 else throw("Strict value is not equal to itself.")
715713             }
716714         else throw("Strict value is not equal to itself.")
717715     }
718716 
719717 
720718 
721719 @Callable(i)
722720 func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
723721     then throw("permissions denied")
724722     else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
725723 
726724 
727725 
728726 @Callable(i)
729727 func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
730728 
731729 
732730 
733731 @Callable(i)
734732 func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
735733 
736734 
737735 
738736 @Callable(i)
739737 func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
740738     let prices = calcPrices(amAmt, prAmt, lpAmt)
741739     $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
742740     }
743741 
744742 
745743 
746744 @Callable(i)
747745 func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
748746 
749747 
750748 
751749 @Callable(i)
752750 func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
753751 
754752 
755753 
756754 @Callable(i)
757755 func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
758756 
759757 
760758 
761759 @Callable(i)
762760 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, ""))
763761 
764762 
765763 
766764 @Callable(i)
767765 func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
768766     let res = estimateGetOperation(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
769767     $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
770768     }
771769 
772770 
773771 @Verifier(tx)
774772 func verify () = match tx {
775773     case order: Order => 
776774         let mtchPub = getMatcherPubOrFail()
777775         let orV = validateMatcherOrderAllowed(order)
778776         let sndrV = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
779777         let mtchV = sigVerify(order.bodyBytes, order.proofs[1], mtchPub)
780778         if (if (if (orV)
781779             then sndrV
782780             else false)
783781             then mtchV
784782             else false)
785783             then true
786784             else throwOrderError(orV, sndrV, mtchV)
787785     case _ => 
788786         let admin = valueOrElse(getString(this, keyManPubKey()), EMPTY)
789787         if ((admin == EMPTY))
790788             then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
791789             else sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(admin))
792790 }
793791 
github/deemru/w8io/169f3d6 
99.36 ms ◑