tx · G2XEGD7hsqhg4SxrRygzpzvubT5reSX2zeaUxqM6yYBG

3P5HjPowgipiVB3UvXphDiPvKs424WC9xQw:  -0.02900000 Waves

2022.08.30 21:07 [3273023] smart account 3P5HjPowgipiVB3UvXphDiPvKs424WC9xQw > SELF 0.00000000 Waves

{ "type": 13, "id": "G2XEGD7hsqhg4SxrRygzpzvubT5reSX2zeaUxqM6yYBG", "fee": 2900000, "feeAssetId": null, "timestamp": 1661882722230, "version": 1, "sender": "3P5HjPowgipiVB3UvXphDiPvKs424WC9xQw", "senderPublicKey": "6M6f44eNZfeyyKFVnuupXdHStN16Rz7uDrkJHWfnMqWY", "proofs": [ "uhk9q5RBQzBXTUuHjk7ecHHHzfg2ya9bEAqTcrsSe9LWzvKP3b6MDg3ea9fSHvV4VHqQc3dbRXSVyLyZHiQU2YJ" ], "script": "base64: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", "chainId": 87, "height": 3273023, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: E7FeKPSUrK5wJ4SPpWUDRJ6t48MTv3FGK8swighR2sBn Next: w4TJgNkAchSPv4rRHX8AyDRQgpMVPDCdgmxSoraks7T Diff:
OldNewDifferences
765765 }
766766
767767
768+
769+@Callable(i)
770+func testingTest () = $Tuple2(nil, "")
771+
772+
768773 @Verifier(tx)
769774 func verify () = {
770775 let targetPublicKey = match managerPublicKeyOrUnit() {
Full:
OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let lPdecimals = 8
55
66 let scale8 = 100000000
77
88 let scale8BigInt = toBigInt(100000000)
99
1010 let scale18 = toBigInt(1000000000000000000)
1111
1212 let zeroBigInt = toBigInt(0)
1313
1414 let SEP = "__"
1515
1616 let PoolActive = 1
1717
1818 let PoolPutDisabled = 2
1919
2020 let PoolMatcherDisabled = 3
2121
2222 let PoolShutdown = 4
2323
2424 let idxPoolAddress = 1
2525
2626 let idxPoolStatus = 2
2727
2828 let idxPoolLPAssetId = 3
2929
3030 let idxAmtAssetId = 4
3131
3232 let idxPriceAssetId = 5
3333
3434 let idxAmtAssetDcm = 6
3535
3636 let idxPriceAssetDcm = 7
3737
3838 let idxIAmtAssetId = 8
3939
4040 let idxIPriceAssetId = 9
4141
4242 let idxLPAssetDcm = 10
4343
4444 let idxPoolAmtAssetAmt = 1
4545
4646 let idxPoolPriceAssetAmt = 2
4747
4848 let idxPoolLPAssetAmt = 3
4949
5050 let idxFactoryStakingContract = 1
5151
5252 let idxFactorySlippageContract = 7
5353
5454 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
5555
5656
5757 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
5858
5959
6060 func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
6161
6262
6363 func abs (val) = if ((zeroBigInt > val))
6464 then -(val)
6565 else val
6666
6767
6868 func fc () = "%s__factoryContract"
6969
7070
7171 func mpk () = "%s__managerPublicKey"
7272
7373
7474 func pmpk () = "%s__pendingManagerPublicKey"
7575
7676
7777 func pl () = "%s%s__price__last"
7878
7979
8080 func ph (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
8181
8282
8383 func pau (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
8484
8585
8686 func gau (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
8787
8888
8989 func aa () = "%s__amountAsset"
9090
9191
9292 func pa () = "%s__priceAsset"
9393
9494
9595 func keyFactoryConfig () = "%s__factoryConfig"
9696
9797
9898 func keyMatcherPub () = "%s%s__matcher__publicKey"
9999
100100
101101 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
102102
103103
104104 func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
105105
106106
107107 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
108108
109109
110110 func keyAllPoolsShutdown () = "%s__shutdown"
111111
112112
113113 func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
114114
115115
116116 func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
117117
118118
119119 func throwOrderError (orderValid,senderValid,matcherValid) = throw(((((("order validation failed: orderValid=" + toString(orderValid)) + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
120120
121121
122122 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
123123
124124
125125 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
126126
127127
128128 let factoryContract = addressFromStringValue(getStringOrFail(this, fc()))
129129
130130 func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
131131
132132
133133 func getMatcherPubOrFail () = fromBase58String(getStringOrFail(factoryContract, keyMatcherPub()))
134134
135135
136136 func getPoolConfig () = {
137137 let amtAsset = getStringOrFail(this, aa())
138138 let priceAsset = getStringOrFail(this, pa())
139139 let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
140140 let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
141141 split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
142142 }
143143
144144
145145 func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
146146
147147
148148 func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
149149
150150
151151 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)
152152
153153
154154 func getAccBalance (assetId) = if ((assetId == "WAVES"))
155155 then wavesBalance(this).available
156156 else assetBalance(this, fromBase58String(assetId))
157157
158158
159159 func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
160160
161161
162162 func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
163163 let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
164164 let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
165165 calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
166166 }
167167
168168
169169 func calcPrices (amAmt,prAmt,lpAmt) = {
170170 let cfg = getPoolConfig()
171171 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
172172 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
173173 let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
174174 let amAmtX18 = toX18(amAmt, amtAssetDcm)
175175 let prAmtX18 = toX18(prAmt, priceAssetDcm)
176176 let lpAmtX18 = toX18(lpAmt, scale8)
177177 let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
178178 let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
179179 [priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
180180 }
181181
182182
183183 func calculatePrices (amAmt,prAmt,lpAmt) = {
184184 let prices = calcPrices(amAmt, prAmt, lpAmt)
185185 [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
186186 }
187187
188188
189189 func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
190190 let cfg = getPoolConfig()
191191 let lpAssetId = cfg[idxPoolLPAssetId]
192192 let amAssetId = cfg[idxAmtAssetId]
193193 let prAssetId = cfg[idxPriceAssetId]
194194 let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
195195 let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
196196 let poolStatus = cfg[idxPoolStatus]
197197 let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
198198 if ((lpAssetId != pmtAssetId))
199199 then throw("Invalid asset passed.")
200200 else {
201201 let amBalance = getAccBalance(amAssetId)
202202 let amBalanceX18 = toX18(amBalance, amAssetDcm)
203203 let prBalance = getAccBalance(prAssetId)
204204 let prBalanceX18 = toX18(prBalance, prAssetDcm)
205205 let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
206206 let curPrice = fromX18(curPriceX18, scale8)
207207 let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
208208 let lpEmissionX18 = toX18(lpEmission, scale8)
209209 let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
210210 let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
211211 let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
212212 let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
213213 let state = if ((txId58 == ""))
214214 then nil
215215 else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
216216 then unit
217217 else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
218218 then unit
219219 else fromBase58String(prAssetId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
220220 $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
221221 }
222222 }
223223
224224
225225 func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
226226 let cfg = getPoolConfig()
227227 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
228228 let amAssetIdStr = cfg[idxAmtAssetId]
229229 let prAssetIdStr = cfg[idxPriceAssetId]
230230 let iAmtAssetId = cfg[idxIAmtAssetId]
231231 let iPriceAssetId = cfg[idxIPriceAssetId]
232232 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
233233 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
234234 let poolStatus = cfg[idxPoolStatus]
235235 let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
236236 let inAmAssetIdStr = toBase58String(valueOrElse(inAmAssetId, fromBase58String("WAVES")))
237237 let inPrAssetIdStr = toBase58String(valueOrElse(inPrAssetId, fromBase58String("WAVES")))
238238 if (if ((amAssetIdStr != inAmAssetIdStr))
239239 then true
240240 else (prAssetIdStr != inPrAssetIdStr))
241241 then throw("Invalid amt or price asset passed.")
242242 else {
243243 let amBalance = if (isEvaluate)
244244 then getAccBalance(amAssetIdStr)
245245 else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
246246 let prBalance = if (isEvaluate)
247247 then getAccBalance(prAssetIdStr)
248248 else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
249249 let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
250250 let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
251251 let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
252252 let amBalanceX18 = toX18(amBalance, amtAssetDcm)
253253 let prBalanceX18 = toX18(prBalance, priceAssetDcm)
254254 let res = if ((lpEmission == 0))
255255 then {
256256 let curPriceX18 = zeroBigInt
257257 let slippageX18 = zeroBigInt
258258 let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
259259 $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
260260 }
261261 else {
262262 let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
263263 let slippageX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
264264 let slippageToleranceX18 = toX18(slippageTolerance, scale8)
265265 if (if ((curPriceX18 != zeroBigInt))
266266 then (slippageX18 > slippageToleranceX18)
267267 else false)
268268 then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
269269 else {
270270 let lpEmissionX18 = toX18(lpEmission, scale8)
271271 let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
272272 let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
273273 let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
274274 then $Tuple2(amViaPrX18, inPrAssetAmtX18)
275275 else $Tuple2(inAmAssetAmtX18, prViaAmX18)
276276 let expAmtAssetAmtX18 = expectedAmts._1
277277 let expPriceAssetAmtX18 = expectedAmts._2
278278 let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
279279 $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
280280 }
281281 }
282282 let calcLpAmt = res._1
283283 let calcAmAssetPmt = res._2
284284 let calcPrAssetPmt = res._3
285285 let curPrice = fromX18(res._4, scale8)
286286 let slippageCalc = fromX18(res._5, scale8)
287287 if ((0 >= calcLpAmt))
288288 then throw("Invalid calculations. LP calculated is less than zero.")
289289 else {
290290 let emitLpAmt = if (!(emitLp))
291291 then 0
292292 else calcLpAmt
293293 let amDiff = (inAmAssetAmt - calcAmAssetPmt)
294294 let prDiff = (inPrAssetAmt - calcPrAssetPmt)
295295 let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
296296 $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
297297 }
298298 }
299299 }
300300
301301
302302 func validateMatcherOrderAllowed (order) = {
303303 let cfg = getPoolConfig()
304304 let amtAssetId = cfg[idxAmtAssetId]
305305 let priceAssetId = cfg[idxPriceAssetId]
306306 let poolStatus = parseIntValue(cfg[idxPoolStatus])
307307 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
308308 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
309309 let accAmtAssetBalance = getAccBalance(amtAssetId)
310310 let accPriceAssetBalance = getAccBalance(priceAssetId)
311311 let curPriceX18 = if ((order.orderType == Buy))
312312 then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
313313 else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
314314 let curPrice = fromX18(curPriceX18, scale8)
315315 if (if (if (isGlobalShutdown())
316316 then true
317317 else (poolStatus == PoolMatcherDisabled))
318318 then true
319319 else (poolStatus == PoolShutdown))
320320 then throw("Exchange operations disabled")
321321 else {
322322 let orderAmtAsset = order.assetPair.amountAsset
323323 let orderAmtAssetStr = if ((orderAmtAsset == unit))
324324 then "WAVES"
325325 else toBase58String(value(orderAmtAsset))
326326 let orderPriceAsset = order.assetPair.priceAsset
327327 let orderPriceAssetStr = if ((orderPriceAsset == unit))
328328 then "WAVES"
329329 else toBase58String(value(orderPriceAsset))
330330 if (if ((orderAmtAssetStr != amtAssetId))
331331 then true
332332 else (orderPriceAssetStr != priceAssetId))
333333 then throw("Wrong order assets.")
334334 else {
335335 let orderPrice = order.price
336336 let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
337337 let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
338338 let isOrderPriceValid = if ((order.orderType == Buy))
339339 then (curPrice >= castedOrderPrice)
340340 else (castedOrderPrice >= curPrice)
341341 true
342342 }
343343 }
344344 }
345345
346346
347347 func commonGet (i) = if ((size(i.payments) != 1))
348348 then throw("exactly 1 payment is expected")
349349 else {
350350 let pmt = value(i.payments[0])
351351 let pmtAssetId = value(pmt.assetId)
352352 let pmtAmt = pmt.amount
353353 let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
354354 let outAmAmt = res._1
355355 let outPrAmt = res._2
356356 let poolStatus = parseIntValue(res._9)
357357 let state = res._10
358358 if (if (isGlobalShutdown())
359359 then true
360360 else (poolStatus == PoolShutdown))
361361 then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
362362 else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
363363 }
364364
365365
366366 func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
367367 then throw("exactly 2 payments are expected")
368368 else {
369369 let amAssetPmt = value(i.payments[0])
370370 let prAssetPmt = value(i.payments[1])
371371 let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp)
372372 let poolStatus = parseIntValue(estPut._8)
373373 if (if (if (isGlobalShutdown())
374374 then true
375375 else (poolStatus == PoolPutDisabled))
376376 then true
377377 else (poolStatus == PoolShutdown))
378378 then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
379379 else estPut
380380 }
381381
382382
383383 func managerPublicKeyOrUnit () = match getString(mpk()) {
384384 case s: String =>
385385 fromBase58String(s)
386386 case _: Unit =>
387387 unit
388388 case _ =>
389389 throw("Match error")
390390 }
391391
392392
393393 func pendingManagerPublicKeyOrUnit () = match getString(pmpk()) {
394394 case s: String =>
395395 fromBase58String(s)
396396 case _: Unit =>
397397 unit
398398 case _ =>
399399 throw("Match error")
400400 }
401401
402402
403403 func mustManager (i) = {
404404 let pd = throw("Permission denied")
405405 match managerPublicKeyOrUnit() {
406406 case pk: ByteVector =>
407407 if ((i.callerPublicKey == pk))
408408 then true
409409 else pd
410410 case _: Unit =>
411411 if ((i.caller == this))
412412 then true
413413 else pd
414414 case _ =>
415415 throw("Match error")
416416 }
417417 }
418418
419419
420420 @Callable(i)
421421 func constructor (factoryContract) = {
422422 let checkCaller = mustManager(i)
423423 if ((checkCaller == checkCaller))
424424 then [StringEntry(fc(), factoryContract)]
425425 else throw("Strict value is not equal to itself.")
426426 }
427427
428428
429429
430430 @Callable(i)
431431 func setManager (pendingManagerPublicKey) = {
432432 let checkCaller = mustManager(i)
433433 if ((checkCaller == checkCaller))
434434 then {
435435 let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
436436 if ((checkManagerPublicKey == checkManagerPublicKey))
437437 then [StringEntry(pmpk(), pendingManagerPublicKey)]
438438 else throw("Strict value is not equal to itself.")
439439 }
440440 else throw("Strict value is not equal to itself.")
441441 }
442442
443443
444444
445445 @Callable(i)
446446 func confirmManager () = {
447447 let pm = pendingManagerPublicKeyOrUnit()
448448 let hasPM = if (isDefined(pm))
449449 then true
450450 else throw("No pending manager")
451451 if ((hasPM == hasPM))
452452 then {
453453 let checkPM = if ((i.callerPublicKey == value(pm)))
454454 then true
455455 else throw("You are not pending manager")
456456 if ((checkPM == checkPM))
457457 then [StringEntry(mpk(), toBase58String(value(pm))), DeleteEntry(pmpk())]
458458 else throw("Strict value is not equal to itself.")
459459 }
460460 else throw("Strict value is not equal to itself.")
461461 }
462462
463463
464464
465465 @Callable(i)
466466 func put (slippageTolerance,shouldAutoStake) = {
467467 let factoryCfg = getFactoryConfig()
468468 let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
469469 let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
470470 if ((0 > slippageTolerance))
471471 then throw("Invalid slippageTolerance passed")
472472 else {
473473 let estPut = commonPut(i, slippageTolerance, true)
474474 let emitLpAmt = estPut._2
475475 let lpAssetId = estPut._7
476476 let state = estPut._9
477477 let amDiff = estPut._10
478478 let prDiff = estPut._11
479479 let amId = estPut._12
480480 let prId = estPut._13
481481 let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
482482 if ((emitInv == emitInv))
483483 then {
484484 let emitInvLegacy = match emitInv {
485485 case legacyFactoryContract: Address =>
486486 invoke(legacyFactoryContract, "emit", [emitLpAmt], nil)
487487 case _ =>
488488 unit
489489 }
490490 if ((emitInvLegacy == emitInvLegacy))
491491 then {
492492 let slippageAInv = if ((amDiff > 0))
493493 then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
494494 else nil
495495 if ((slippageAInv == slippageAInv))
496496 then {
497497 let slippagePInv = if ((prDiff > 0))
498498 then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
499499 else nil
500500 if ((slippagePInv == slippagePInv))
501501 then {
502502 let lpTransfer = if (shouldAutoStake)
503503 then {
504504 let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
505505 if ((slpStakeInv == slpStakeInv))
506506 then nil
507507 else throw("Strict value is not equal to itself.")
508508 }
509509 else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
510510 (state ++ lpTransfer)
511511 }
512512 else throw("Strict value is not equal to itself.")
513513 }
514514 else throw("Strict value is not equal to itself.")
515515 }
516516 else throw("Strict value is not equal to itself.")
517517 }
518518 else throw("Strict value is not equal to itself.")
519519 }
520520 }
521521
522522
523523
524524 @Callable(i)
525525 func putForFree (maxSlippage) = if ((0 > maxSlippage))
526526 then throw("Invalid value passed")
527527 else {
528528 let estPut = commonPut(i, maxSlippage, false)
529529 estPut._9
530530 }
531531
532532
533533
534534 @Callable(i)
535535 func get () = {
536536 let res = commonGet(i)
537537 let outAmtAmt = res._1
538538 let outPrAmt = res._2
539539 let pmtAmt = res._3
540540 let pmtAssetId = res._4
541541 let state = res._5
542542 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
543543 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
544544 then state
545545 else throw("Strict value is not equal to itself.")
546546 }
547547
548548
549549
550550 @Callable(i)
551551 func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
552552 let res = commonGet(i)
553553 let outAmAmt = res._1
554554 let outPrAmt = res._2
555555 let pmtAmt = res._3
556556 let pmtAssetId = res._4
557557 let state = res._5
558558 if ((noLessThenAmtAsset > outAmAmt))
559559 then throw(((("noLessThenAmtAsset failed: " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
560560 else if ((noLessThenPriceAsset > outPrAmt))
561561 then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
562562 else {
563563 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
564564 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
565565 then state
566566 else throw("Strict value is not equal to itself.")
567567 }
568568 }
569569
570570
571571
572572 @Callable(i)
573573 func unstakeAndGet (amount) = {
574574 let checkPayments = if ((size(i.payments) != 0))
575575 then throw("No payments are expected")
576576 else true
577577 if ((checkPayments == checkPayments))
578578 then {
579579 let cfg = getPoolConfig()
580580 let factoryCfg = getFactoryConfig()
581581 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
582582 let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
583583 let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(lpAssetId), amount], nil)
584584 if ((unstakeInv == unstakeInv))
585585 then {
586586 let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
587587 let poolStatus = parseIntValue(res._9)
588588 let state = res._10
589589 let checkPoolStatus = if (if (isGlobalShutdown())
590590 then true
591591 else (poolStatus == PoolShutdown))
592592 then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
593593 else true
594594 if ((checkPoolStatus == checkPoolStatus))
595595 then {
596596 let burnLPAssetOnFactory = invoke(factoryContract, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
597597 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
598598 then state
599599 else throw("Strict value is not equal to itself.")
600600 }
601601 else throw("Strict value is not equal to itself.")
602602 }
603603 else throw("Strict value is not equal to itself.")
604604 }
605605 else throw("Strict value is not equal to itself.")
606606 }
607607
608608
609609
610610 @Callable(i)
611611 func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
612612 then throw("permissions denied")
613613 else $Tuple2([StringEntry(aa(), amtAssetStr), StringEntry(pa(), priceAssetStr)], "success")
614614
615615
616616
617617 @Callable(i)
618618 func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
619619
620620
621621
622622 @Callable(i)
623623 func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
624624
625625
626626
627627 @Callable(i)
628628 func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
629629 let prices = calcPrices(amAmt, prAmt, lpAmt)
630630 $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
631631 }
632632
633633
634634
635635 @Callable(i)
636636 func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
637637
638638
639639
640640 @Callable(i)
641641 func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
642642
643643
644644
645645 @Callable(i)
646646 func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
647647
648648
649649
650650 @Callable(i)
651651 func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = $Tuple2(nil, estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp))
652652
653653
654654
655655 @Callable(i)
656656 func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
657657 let res = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
658658 $Tuple2(nil, $Tuple10(res._1, res._2, res._3, res._4, res._5, res._6, res._7, toString(res._8), res._9, res._10))
659659 }
660660
661661
662662
663663 @Callable(i)
664664 func statsREADONLY () = {
665665 let cfg = getPoolConfig()
666666 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
667667 let amtAssetId = cfg[idxAmtAssetId]
668668 let priceAssetId = cfg[idxPriceAssetId]
669669 let iAmtAssetId = cfg[idxIAmtAssetId]
670670 let iPriceAssetId = cfg[idxIPriceAssetId]
671671 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
672672 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
673673 let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
674674 let accAmtAssetBalance = getAccBalance(amtAssetId)
675675 let accPriceAssetBalance = getAccBalance(priceAssetId)
676676 let pricesList = if ((poolLPBalance == 0))
677677 then [zeroBigInt, zeroBigInt, zeroBigInt]
678678 else calcPrices(accAmtAssetBalance, accPriceAssetBalance, poolLPBalance)
679679 let curPrice = 0
680680 let lpAmtAssetShare = fromX18(pricesList[1], scale8)
681681 let lpPriceAssetShare = fromX18(pricesList[2], scale8)
682682 let poolWeight = value(getInteger(factoryContract, keyPoolWeight(toString(this))))
683683 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
684684 }
685685
686686
687687
688688 @Callable(i)
689689 func evaluatePutByAmountAssetREADONLY (inAmAssetAmt) = {
690690 let cfg = getPoolConfig()
691691 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
692692 let amAssetIdStr = cfg[idxAmtAssetId]
693693 let amAssetId = fromBase58String(amAssetIdStr)
694694 let prAssetIdStr = cfg[idxPriceAssetId]
695695 let prAssetId = fromBase58String(prAssetIdStr)
696696 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
697697 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
698698 let poolStatus = cfg[idxPoolStatus]
699699 let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
700700 let accAmtAssetBalance = getAccBalance(amAssetIdStr)
701701 let accPriceAssetBalance = getAccBalance(prAssetIdStr)
702702 let amtAssetAmtX18 = toX18(accAmtAssetBalance, amtAssetDcm)
703703 let priceAssetAmtX18 = toX18(accPriceAssetBalance, priceAssetDcm)
704704 let curPriceX18 = if ((poolLPBalance == 0))
705705 then zeroBigInt
706706 else calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
707707 let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
708708 let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
709709 let inPrAssetAmt = fromX18(inPrAssetAmtX18, priceAssetDcm)
710710 let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
711711 let calcLpAmt = estPut._1
712712 let curPriceCalc = estPut._3
713713 let amBalance = estPut._4
714714 let prBalance = estPut._5
715715 let lpEmission = estPut._6
716716 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
717717 }
718718
719719
720720
721721 @Callable(i)
722722 func evaluatePutByPriceAssetREADONLY (inPrAssetAmt) = {
723723 let cfg = getPoolConfig()
724724 let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
725725 let amAssetIdStr = cfg[idxAmtAssetId]
726726 let amAssetId = fromBase58String(amAssetIdStr)
727727 let prAssetIdStr = cfg[idxPriceAssetId]
728728 let prAssetId = fromBase58String(prAssetIdStr)
729729 let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
730730 let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
731731 let poolStatus = cfg[idxPoolStatus]
732732 let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
733733 let amBalanceRaw = getAccBalance(amAssetIdStr)
734734 let prBalanceRaw = getAccBalance(prAssetIdStr)
735735 let amBalanceRawX18 = toX18(amBalanceRaw, amtAssetDcm)
736736 let prBalanceRawX18 = toX18(prBalanceRaw, priceAssetDcm)
737737 let curPriceX18 = if ((poolLPBalance == 0))
738738 then zeroBigInt
739739 else calcPriceBigInt(prBalanceRawX18, amBalanceRawX18)
740740 let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
741741 let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
742742 let inAmAssetAmt = fromX18(inAmAssetAmtX18, amtAssetDcm)
743743 let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
744744 let calcLpAmt = estPut._1
745745 let curPriceCalc = estPut._3
746746 let amBalance = estPut._4
747747 let prBalance = estPut._5
748748 let lpEmission = estPut._6
749749 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
750750 }
751751
752752
753753
754754 @Callable(i)
755755 func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
756756 let res = estimateGetOperation("", paymentLpAssetId, paymentLpAmt, this)
757757 let outAmAmt = res._1
758758 let outPrAmt = res._2
759759 let amBalance = res._5
760760 let prBalance = res._6
761761 let lpEmission = res._7
762762 let curPrice = res._8
763763 let poolStatus = parseIntValue(res._9)
764764 $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), toString(curPrice), toString(poolStatus)], SEP))
765765 }
766766
767767
768+
769+@Callable(i)
770+func testingTest () = $Tuple2(nil, "")
771+
772+
768773 @Verifier(tx)
769774 func verify () = {
770775 let targetPublicKey = match managerPublicKeyOrUnit() {
771776 case pk: ByteVector =>
772777 pk
773778 case _: Unit =>
774779 tx.senderPublicKey
775780 case _ =>
776781 throw("Match error")
777782 }
778783 match tx {
779784 case order: Order =>
780785 let matcherPub = getMatcherPubOrFail()
781786 let orderValid = validateMatcherOrderAllowed(order)
782787 let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
783788 let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
784789 if (if (if (orderValid)
785790 then senderValid
786791 else false)
787792 then matcherValid
788793 else false)
789794 then true
790795 else throwOrderError(orderValid, senderValid, matcherValid)
791796 case s: SetScriptTransaction =>
792797 let newHash = blake2b256(value(s.script))
793798 let allowedHash = fromBase64String(value(getString(factoryContract, keyAllowedLpScriptHash())))
794799 let currentHash = scriptHash(this)
795800 if (if ((allowedHash == newHash))
796801 then (currentHash != newHash)
797802 else false)
798803 then true
799804 else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
800805 case _ =>
801806 sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
802807 }
803808 }
804809

github/deemru/w8io/fabc49c 
112.42 ms