tx · vS3hxKT3r5Besttpz4Ayv3UebLpyiWyApJHt6jJ7CVX

3MrLv9SyejKpyQmQtxofNjJRbP7ofVzusrT:  -0.01000000 Waves

2022.03.15 11:49 [1964833] smart account 3MrLv9SyejKpyQmQtxofNjJRbP7ofVzusrT > SELF 0.00000000 Waves

{ "type": 13, "id": "vS3hxKT3r5Besttpz4Ayv3UebLpyiWyApJHt6jJ7CVX", "fee": 1000000, "feeAssetId": null, "timestamp": 1647334170881, "version": 2, "chainId": 84, "sender": "3MrLv9SyejKpyQmQtxofNjJRbP7ofVzusrT", "senderPublicKey": "AksmzbhS8VH8fPkDs7eyh735mMBBgSqDpkumTQua7jqS", "proofs": [ "4LhdWNid5ByLbRFFuS8H4ta9HgujD2JhZzcQL75HWnGENAeGzkn3SqUcKmyyXJPuoymxd9WyThPYy1wmzGx9AoCA" ], "script": "base64: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", "height": 1964833, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: none Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let scale8 = 100000000
5+
6+let scale8BigInt = toBigInt(100000000)
7+
8+let scale18 = toBigInt(1000000000000000000)
9+
10+let zeroBigInt = toBigInt(0)
11+
12+let oneBigInt = toBigInt(1)
13+
14+let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
15+
16+let Amult = "100"
17+
18+let Dconv = "1"
19+
20+let SEP = "__"
21+
22+let EMPTY = ""
23+
24+let PoolActive = 1
25+
26+let PoolPutDis = 2
27+
28+let PoolMatcherDis = 3
29+
30+let PoolShutdown = 4
31+
32+let idxPoolAddress = 1
33+
34+let idxPoolSt = 2
35+
36+let idxLPAsId = 3
37+
38+let idxAmAsId = 4
39+
40+let idxPrAsId = 5
41+
42+let idxAmtAsDcm = 6
43+
44+let idxPriceAsDcm = 7
45+
46+let idxIAmtAsId = 8
47+
48+let idxIPriceAsId = 9
49+
50+let idxFactStakCntr = 1
51+
52+let idxFactSlippCntr = 7
53+
54+let idxFactGwxRewCntr = 10
55+
56+func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
57+
58+
59+func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
60+
61+
62+func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
63+
64+
65+func abs (val) = if ((zeroBigInt > val))
66+ then -(val)
67+ else val
68+
69+
70+func fc () = "%s__factoryContract"
71+
72+
73+func mpk () = "%s__managerPublicKey"
74+
75+
76+func pmpk () = "%s__pendingManagerPublicKey"
77+
78+
79+func pl () = "%s%s__price__last"
80+
81+
82+func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
83+
84+
85+func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
86+
87+
88+func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
89+
90+
91+func aa () = "%s__amountAsset"
92+
93+
94+func pa () = "%s__priceAsset"
95+
96+
97+func amp () = "%s__amp"
98+
99+
100+func ada () = "%s__addonAddr"
101+
102+
103+func fcfg () = "%s__factoryConfig"
104+
105+
106+func mtpk () = "%s%s__matcher__publicKey"
107+
108+
109+func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
110+
111+
112+func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
113+
114+
115+func aps () = "%s__shutdown"
116+
117+
118+func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
119+
120+
121+func str (val) = match val {
122+ case valStr: String =>
123+ valStr
124+ case _ =>
125+ throw("fail cast to String")
126+}
127+
128+
129+func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
130+
131+
132+func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
133+
134+
135+let fca = addressFromStringValue(strf(this, fc()))
136+
137+let A = strf(this, amp())
138+
139+func igs () = valueOrElse(getBoolean(fca, aps()), false)
140+
141+
142+func mp () = fromBase58String(strf(fca, mtpk()))
143+
144+
145+func gpc () = {
146+ let amtAs = strf(this, aa())
147+ let priceAs = strf(this, pa())
148+ let iPriceAs = intf(fca, mba(priceAs))
149+ let iAmtAs = intf(fca, mba(amtAs))
150+ split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
151+ }
152+
153+
154+func gfc () = split(strf(fca, fcfg()), SEP)
155+
156+
157+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)
158+
159+
160+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)
161+
162+
163+func getAccBalance (assetId) = if ((assetId == "WAVES"))
164+ then wavesBalance(this).available
165+ else assetBalance(this, fromBase58String(assetId))
166+
167+
168+func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
169+
170+
171+func vad (A1,A2,slippage) = {
172+ let diff = fraction((A1 - A2), scale8BigInt, A2)
173+ let pass = ((slippage - abs(diff)) > zeroBigInt)
174+ if (!(pass))
175+ then throw(("Big slpg: " + toString(diff)))
176+ else $Tuple2(pass, min([A1, A2]))
177+ }
178+
179+
180+func vd (D1,D0,slpg) = {
181+ let diff = fraction(D0, scale8BigInt, D1)
182+ let fail = (slpg > diff)
183+ if (if (fail)
184+ then true
185+ else (D0 > D1))
186+ then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
187+ else fail
188+ }
189+
190+
191+func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
192+ let amtAsAmtX18 = t1(amAmt, amAssetDcm)
193+ let prAsAmtX18 = t1(prAmt, prAssetDcm)
194+ cpbi(prAsAmtX18, amtAsAmtX18)
195+ }
196+
197+
198+func calcPrices (amAmt,prAmt,lpAmt) = {
199+ let cfg = gpc()
200+ let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
201+ let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
202+ let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
203+ let amAmtX18 = t1(amAmt, amtAsDcm)
204+ let prAmtX18 = t1(prAmt, prAsDcm)
205+ let lpAmtX18 = t1(lpAmt, scale8)
206+ let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
207+ let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
208+[priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
209+ }
210+
211+
212+func calculatePrices (amAmt,prAmt,lpAmt) = {
213+ let p = calcPrices(amAmt, prAmt, lpAmt)
214+[f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
215+ }
216+
217+
218+func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
219+ let cfg = gpc()
220+ let lpId = cfg[idxLPAsId]
221+ let amId = cfg[idxAmAsId]
222+ let prId = cfg[idxPrAsId]
223+ let amDcm = parseIntValue(cfg[idxAmtAsDcm])
224+ let prDcm = parseIntValue(cfg[idxPriceAsDcm])
225+ let sts = cfg[idxPoolSt]
226+ let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
227+ if ((lpId != pmtAssetId))
228+ then throw("Wrong pmt asset")
229+ else {
230+ let amBalance = getAccBalance(amId)
231+ let amBalanceX18 = t1(amBalance, amDcm)
232+ let prBalance = getAccBalance(prId)
233+ let prBalanceX18 = t1(prBalance, prDcm)
234+ let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
235+ let curPrice = f1(curPriceX18, scale8)
236+ let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
237+ let lpEmissX18 = t1(lpEmiss, scale8)
238+ let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
239+ let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
240+ let outAmAmt = f1(outAmAmtX18, amDcm)
241+ let outPrAmt = f1(outPrAmtX18, prDcm)
242+ let state = if ((txId58 == ""))
243+ then nil
244+ else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
245+ then unit
246+ else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
247+ then unit
248+ else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
249+ $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
250+ }
251+ }
252+
253+
254+func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,pmtAmt,pmtId) = {
255+ let cfg = gpc()
256+ let lpId = fromBase58String(cfg[idxLPAsId])
257+ let amIdStr = cfg[idxAmAsId]
258+ let prIdStr = cfg[idxPrAsId]
259+ let inAmIdStr = cfg[idxIAmtAsId]
260+ let inPrIdStr = cfg[idxIPriceAsId]
261+ let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
262+ let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
263+ let sts = cfg[idxPoolSt]
264+ let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
265+ let amBalance = if (isEval)
266+ then getAccBalance(amIdStr)
267+ else if (if (isOneAsset)
268+ then (pmtId == amIdStr)
269+ else false)
270+ then (getAccBalance(amIdStr) - pmtAmt)
271+ else if (isOneAsset)
272+ then getAccBalance(amIdStr)
273+ else (getAccBalance(amIdStr) - inAmAmt)
274+ let prBalance = if (isEval)
275+ then getAccBalance(prIdStr)
276+ else if (if (isOneAsset)
277+ then (pmtId == prIdStr)
278+ else false)
279+ then (getAccBalance(prIdStr) - pmtAmt)
280+ else if (isOneAsset)
281+ then getAccBalance(prIdStr)
282+ else (getAccBalance(prIdStr) - inPrAmt)
283+ let inAmAssetAmtX18 = t1(inAmAmt, amtDcm)
284+ let inPrAssetAmtX18 = t1(inPrAmt, priceDcm)
285+ let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
286+ let amBalanceX18 = t1(amBalance, amtDcm)
287+ let prBalanceX18 = t1(prBalance, priceDcm)
288+ let r = if ((lpEm == 0))
289+ then {
290+ let curPriceX18 = zeroBigInt
291+ let slippageX18 = zeroBigInt
292+ let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
293+ $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
294+ }
295+ else {
296+ let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
297+ let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
298+ let slippageX18 = t1(slippage, scale8)
299+ if (if ((curPriceX18 != zeroBigInt))
300+ then (slippageRealX18 > slippageX18)
301+ else false)
302+ then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
303+ else {
304+ let lpEmissionX18 = t1(lpEm, scale8)
305+ let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
306+ let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
307+ let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
308+ then $Tuple2(amViaPrX18, inPrAssetAmtX18)
309+ else $Tuple2(inAmAssetAmtX18, prViaAmX18)
310+ let expAmtAssetAmtX18 = expectedAmts._1
311+ let expPriceAssetAmtX18 = expectedAmts._2
312+ let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
313+ $Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
314+ }
315+ }
316+ let calcLpAmt = r._1
317+ let calcAmAssetPmt = r._2
318+ let calcPrAssetPmt = r._3
319+ let curPrice = f1(r._4, scale8)
320+ let slippageCalc = f1(r._5, scale8)
321+ if ((0 >= calcLpAmt))
322+ then throw("LP <= 0")
323+ else {
324+ let emitLpAmt = if (!(emitLp))
325+ then 0
326+ else calcLpAmt
327+ let amDiff = (inAmAmt - calcAmAssetPmt)
328+ let prDiff = (inPrAmt - calcPrAssetPmt)
329+ let $t01529615641 = if (if (isOneAsset)
330+ then (pmtId == amIdStr)
331+ else false)
332+ then $Tuple2(pmtAmt, 0)
333+ else if (if (isOneAsset)
334+ then (pmtId == prIdStr)
335+ else false)
336+ then $Tuple2(0, pmtAmt)
337+ else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
338+ let writeAmAmt = $t01529615641._1
339+ let writePrAmt = $t01529615641._2
340+ let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
341+ $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
342+ }
343+ }
344+
345+
346+func moa (order) = {
347+ let cfg = gpc()
348+ let amtAsId = cfg[idxAmAsId]
349+ let prAsId = cfg[idxPrAsId]
350+ let sts = parseIntValue(cfg[idxPoolSt])
351+ let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
352+ let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
353+ let accAmtAsBalance = getAccBalance(amtAsId)
354+ let accPrAsBalance = getAccBalance(prAsId)
355+ let curPriceX18 = if ((order.orderType == Buy))
356+ then pcp(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
357+ else pcp(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
358+ let curPrice = f1(curPriceX18, scale8)
359+ if (if (if (igs())
360+ then true
361+ else (sts == PoolMatcherDis))
362+ then true
363+ else (sts == PoolShutdown))
364+ then throw("Admin blocked")
365+ else {
366+ let orAmtAsset = order.assetPair.amountAsset
367+ let orAmtAsStr = if ((orAmtAsset == unit))
368+ then "WAVES"
369+ else toBase58String(value(orAmtAsset))
370+ let orPrAsset = order.assetPair.priceAsset
371+ let orPrAsStr = if ((orPrAsset == unit))
372+ then "WAVES"
373+ else toBase58String(value(orPrAsset))
374+ if (if ((orAmtAsStr != amtAsId))
375+ then true
376+ else (orPrAsStr != prAsId))
377+ then throw("Wr assets")
378+ else {
379+ let orderPrice = order.price
380+ let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
381+ let castOrderPrice = ts(orderPrice, scale8, priceDcm)
382+ let isOrderPriceValid = if ((order.orderType == Buy))
383+ then (curPrice >= castOrderPrice)
384+ else (castOrderPrice >= curPrice)
385+ true
386+ }
387+ }
388+ }
389+
390+
391+func cg (i) = if ((size(i.payments) != 1))
392+ then throw("1 pmnt exp")
393+ else {
394+ let pmt = value(i.payments[0])
395+ let pmtAssetId = value(pmt.assetId)
396+ let pmtAmt = pmt.amount
397+ let r = ego(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
398+ let outAmAmt = r._1
399+ let outPrAmt = r._2
400+ let sts = parseIntValue(r._9)
401+ let state = r._10
402+ if (if (igs())
403+ then true
404+ else (sts == PoolShutdown))
405+ then throw(("Admin blocked: " + toString(sts)))
406+ else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
407+ }
408+
409+
410+func cp (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,pmtAmt,pmtId) = {
411+ let r = epo(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, false, emitLp, isOneAsset, pmtAmt, pmtId)
412+ let sts = parseIntValue(r._8)
413+ if (if (if (igs())
414+ then true
415+ else (sts == PoolPutDis))
416+ then true
417+ else (sts == PoolShutdown))
418+ then throw(("Blocked:" + toString(sts)))
419+ else r
420+ }
421+
422+
423+func m () = match getString(mpk()) {
424+ case s: String =>
425+ fromBase58String(s)
426+ case _: Unit =>
427+ unit
428+ case _ =>
429+ throw("Match error")
430+}
431+
432+
433+func pm () = match getString(pmpk()) {
434+ case s: String =>
435+ fromBase58String(s)
436+ case _: Unit =>
437+ unit
438+ case _ =>
439+ throw("Match error")
440+}
441+
442+
443+func mm (i) = {
444+ let pd = throw("Permission denied")
445+ match m() {
446+ case pk: ByteVector =>
447+ if ((i.callerPublicKey == pk))
448+ then true
449+ else pd
450+ case _: Unit =>
451+ if ((i.caller == this))
452+ then true
453+ else pd
454+ case _ =>
455+ throw("Match error")
456+ }
457+ }
458+
459+
460+@Callable(i)
461+func constructor (fc) = {
462+ let c = mm(i)
463+ if ((c == c))
464+ then [StringEntry(fc(), fc)]
465+ else throw("Strict value is not equal to itself.")
466+ }
467+
468+
469+
470+@Callable(i)
471+func setManager (pendingManagerPublicKey) = {
472+ let c = mm(i)
473+ if ((c == c))
474+ then {
475+ let cm = fromBase58String(pendingManagerPublicKey)
476+ if ((cm == cm))
477+ then [StringEntry(pmpk(), pendingManagerPublicKey)]
478+ else throw("Strict value is not equal to itself.")
479+ }
480+ else throw("Strict value is not equal to itself.")
481+ }
482+
483+
484+
485+@Callable(i)
486+func confirmManager () = {
487+ let p = pm()
488+ let hpm = if (isDefined(p))
489+ then true
490+ else throw("No pending manager")
491+ if ((hpm == hpm))
492+ then {
493+ let cpm = if ((i.callerPublicKey == value(p)))
494+ then true
495+ else throw("You are not pending manager")
496+ if ((cpm == cpm))
497+ then [StringEntry(mpk(), toBase58String(value(p))), DeleteEntry(pmpk())]
498+ else throw("Strict value is not equal to itself.")
499+ }
500+ else throw("Strict value is not equal to itself.")
501+ }
502+
503+
504+
505+@Callable(i)
506+func put (slip,autoStake) = {
507+ let factCfg = gfc()
508+ let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
509+ let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
510+ if ((0 > slip))
511+ then throw("Wrong slippage")
512+ else if ((size(i.payments) != 2))
513+ then throw("2 pmnts expd")
514+ else {
515+ let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, 0, "")
516+ let emitLpAmt = e._2
517+ let lpAssetId = e._7
518+ let state = e._9
519+ let amDiff = e._10
520+ let prDiff = e._11
521+ let amId = e._12
522+ let prId = e._13
523+ let r = invoke(fca, "emit", [emitLpAmt], nil)
524+ if ((r == r))
525+ then {
526+ let el = match r {
527+ case legacy: Address =>
528+ invoke(legacy, "emit", [emitLpAmt], nil)
529+ case _ =>
530+ unit
531+ }
532+ if ((el == el))
533+ then {
534+ let sa = if ((amDiff > 0))
535+ then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
536+ else nil
537+ if ((sa == sa))
538+ then {
539+ let sp = if ((prDiff > 0))
540+ then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
541+ else nil
542+ if ((sp == sp))
543+ then {
544+ let lpTrnsfr = if (autoStake)
545+ then {
546+ let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
547+ if ((ss == ss))
548+ then nil
549+ else throw("Strict value is not equal to itself.")
550+ }
551+ else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
552+ (state ++ lpTrnsfr)
553+ }
554+ else throw("Strict value is not equal to itself.")
555+ }
556+ else throw("Strict value is not equal to itself.")
557+ }
558+ else throw("Strict value is not equal to itself.")
559+ }
560+ else throw("Strict value is not equal to itself.")
561+ }
562+ }
563+
564+
565+
566+@Callable(i)
567+func putOneTkn (amAssetPart,prAssetPart,outLp,slippage,autoStake) = {
568+ let cfg = gfc()
569+ let stakingCntr = valueOrErrorMessage(addressFromString(cfg[idxFactStakCntr]), "Wr st addr")
570+ let slipCntr = valueOrErrorMessage(addressFromString(cfg[idxFactSlippCntr]), "Wr sl addr")
571+ let gwxCntr = valueOrErrorMessage(addressFromString(cfg[idxFactGwxRewCntr]), "Wr gwx addr")
572+ let poolCfg = gpc()
573+ let amId = poolCfg[idxAmAsId]
574+ let prId = poolCfg[idxPrAsId]
575+ let amDcm = parseIntValue(poolCfg[idxAmtAsDcm])
576+ let prDcm = parseIntValue(poolCfg[idxPriceAsDcm])
577+ if (if (if (if ((0 >= slippage))
578+ then true
579+ else (0 >= amAssetPart))
580+ then true
581+ else (0 >= prAssetPart))
582+ then true
583+ else (0 >= outLp))
584+ then throw("Wrong params")
585+ else if ((size(i.payments) != 1))
586+ then throw("1 pmnt expd")
587+ else {
588+ let pmt = value(i.payments[0])
589+ let pmtAssetId = toBase58String(value(pmt.assetId))
590+ let pmtAmt = pmt.amount
591+ if (if (if ((amAssetPart > pmtAmt))
592+ then true
593+ else (prAssetPart > pmtAmt))
594+ then true
595+ else (10000000 > pmtAmt))
596+ then throw("Wrong pmt amt")
597+ else {
598+ let amBalance = getAccBalance(amId)
599+ let prBalance = getAccBalance(prId)
600+ let $t02418924569 = if ((pmtAssetId == amId))
601+ then $Tuple6((amBalance - pmtAmt), prBalance, (pmtAmt - amAssetPart), prAssetPart, 0, 0)
602+ else if ((pmtAssetId == prId))
603+ then $Tuple6(amBalance, (prBalance - pmtAmt), 0, 0, (pmtAmt - prAssetPart), amAssetPart)
604+ else throw("wrong pmtAssetId")
605+ let amBalanceNow = $t02418924569._1
606+ let prBalanceNow = $t02418924569._2
607+ let virtSwapInAm = $t02418924569._3
608+ let virtSwapOutPr = $t02418924569._4
609+ let virtSwapInPr = $t02418924569._5
610+ let virtSwapOutAm = $t02418924569._6
611+ let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
612+ let D1 = invoke(gwxCntr, "calcD", [toString(toBigInt(((amBalanceNow + virtSwapInAm) - virtSwapOutAm))), toString(toBigInt(((prBalanceNow + virtSwapInPr) - virtSwapOutPr))), A, Amult, Dconv], nil)
613+ let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
614+ if ((D0vsD1 == D0vsD1))
615+ then {
616+ let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(fromBase58String(amId), amAssetPart), AttachedPayment(fromBase58String(prId), prAssetPart), slippage, true, true, pmtAmt, pmtAssetId)
617+ let estimLP = estPut._2
618+ let lpAssetId = estPut._7
619+ let state = estPut._9
620+ let amDiff = estPut._10
621+ let prDiff = estPut._11
622+ let lpCalcRes = vad(toBigInt(estimLP), toBigInt(outLp), toBigInt(slippage))
623+ let emitLpAmt = toInt(lpCalcRes._2)
624+ let e = invoke(fca, "emit", [emitLpAmt], nil)
625+ if ((e == e))
626+ then {
627+ let el = match e {
628+ case legacy: Address =>
629+ invoke(legacy, "emit", [emitLpAmt], nil)
630+ case _ =>
631+ unit
632+ }
633+ if ((el == el))
634+ then {
635+ let sa = if ((amDiff > 0))
636+ then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(amId), amDiff)])
637+ else nil
638+ if ((sa == sa))
639+ then {
640+ let sp = if ((prDiff > 0))
641+ then invoke(slipCntr, "put", nil, [AttachedPayment(fromBase58String(prId), prDiff)])
642+ else nil
643+ if ((sp == sp))
644+ then {
645+ let lpTrnsfr = if (autoStake)
646+ then {
647+ let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
648+ if ((ss == ss))
649+ then nil
650+ else throw("Strict value is not equal to itself.")
651+ }
652+ else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
653+ (state ++ lpTrnsfr)
654+ }
655+ else throw("Strict value is not equal to itself.")
656+ }
657+ else throw("Strict value is not equal to itself.")
658+ }
659+ else throw("Strict value is not equal to itself.")
660+ }
661+ else throw("Strict value is not equal to itself.")
662+ }
663+ else throw("Strict value is not equal to itself.")
664+ }
665+ }
666+ }
667+
668+
669+
670+@Callable(i)
671+func putForFree (maxSlpg) = if ((0 > maxSlpg))
672+ then throw("Wrong slpg")
673+ else if ((size(i.payments) != 2))
674+ then throw("2 pmnts expd")
675+ else {
676+ let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, 0, "")
677+ estPut._9
678+ }
679+
680+
681+
682+@Callable(i)
683+func get () = {
684+ let r = cg(i)
685+ let outAmtAmt = r._1
686+ let outPrAmt = r._2
687+ let pmtAmt = r._3
688+ let pmtAssetId = r._4
689+ let state = r._5
690+ let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
691+ if ((b == b))
692+ then state
693+ else throw("Strict value is not equal to itself.")
694+ }
695+
696+
697+
698+@Callable(i)
699+func getOneTkn (exchResult,notUsed,outAmount,outAssetId,slippage) = if ((size(i.payments) != 1))
700+ then throw("1 pmnt expd")
701+ else {
702+ let cfg = gpc()
703+ let lpId = cfg[idxLPAsId]
704+ let amId = cfg[idxAmAsId]
705+ let prId = cfg[idxPrAsId]
706+ let amDcm = parseIntValue(cfg[idxAmtAsDcm])
707+ let prDcm = parseIntValue(cfg[idxPriceAsDcm])
708+ let sts = cfg[idxPoolSt]
709+ let factCfg = gfc()
710+ let gwxCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactGwxRewCntr]), "Wr sl addr")
711+ let pmt = value(i.payments[0])
712+ let addon = valueOrElse(getString(this, ada()), "")
713+ let userAddress = if ((addon == toString(i.caller)))
714+ then i.originCaller
715+ else i.caller
716+ let txId58 = toBase58String(i.transactionId)
717+ let pmtAssetId = value(pmt.assetId)
718+ let pmtAmt = pmt.amount
719+ if ((1000000000 > pmtAmt))
720+ then throw("Min pmt 10 LP")
721+ else if (if (if ((0 > slippage))
722+ then true
723+ else (0 > exchResult))
724+ then true
725+ else (0 > outAmount))
726+ then throw("Wrong params")
727+ else if ((lpId != toBase58String(pmtAssetId)))
728+ then throw("Wrong LP")
729+ else {
730+ let r = ego(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
731+ let estimAmAmt = r._1
732+ let estimPrAmt = r._2
733+ let amBalance = getAccBalance(amId)
734+ let prBalance = getAccBalance(prId)
735+ let $t02934829805 = if ((outAssetId == amId))
736+ then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), exchResult, estimPrAmt, 0, 0, (estimAmAmt + exchResult))
737+ else if ((outAssetId == prId))
738+ then $Tuple7((amBalance - estimAmAmt), (prBalance - estimPrAmt), 0, 0, exchResult, estimAmAmt, (estimPrAmt + exchResult))
739+ else throw("wrong outAssetId")
740+ let amBalanceNow = $t02934829805._1
741+ let prBalanceNow = $t02934829805._2
742+ let virtSwapInAm = $t02934829805._3
743+ let virtSwapOutPr = $t02934829805._4
744+ let virtSwapInPr = $t02934829805._5
745+ let virtSwapOutAm = $t02934829805._6
746+ let totalGet = $t02934829805._7
747+ if (if ((0 > virtSwapInAm))
748+ then true
749+ else (0 > virtSwapInPr))
750+ then throw("Wrong calc")
751+ else {
752+ let D0 = invoke(gwxCntr, "calcD", [toString(amBalanceNow), toString(prBalanceNow), A, Amult, Dconv], nil)
753+ let D1 = invoke(gwxCntr, "calcD", [toString(((amBalanceNow - virtSwapInAm) + virtSwapOutAm)), toString(((prBalanceNow + virtSwapOutPr) - virtSwapInPr)), A, Amult, Dconv], nil)
754+ let D0vsD1 = vd(parseBigIntValue(str(D1)), parseBigIntValue(str(D0)), slippage4D)
755+ if ((D0vsD1 == D0vsD1))
756+ then {
757+ let finalRes = vad(toBigInt(totalGet), toBigInt(outAmount), toBigInt(slippage))
758+ if ((finalRes == finalRes))
759+ then {
760+ let $t03051030614 = if ((outAssetId == amId))
761+ then $Tuple2(toInt(finalRes._2), 0)
762+ else $Tuple2(0, toInt(finalRes._2))
763+ let outAm = $t03051030614._1
764+ let outPr = $t03051030614._2
765+ let curPrX18 = cpbi(t1(prBalance, prDcm), t1(amBalance, amDcm))
766+ let curPr = f1(curPrX18, scale8)
767+ let state = [ScriptTransfer(userAddress, (outAm + outPr), if ((outAssetId == "WAVES"))
768+ then unit
769+ else fromBase58String(outAssetId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)]
770+ if ((state == state))
771+ then {
772+ let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
773+ if ((burn == burn))
774+ then state
775+ else throw("Strict value is not equal to itself.")
776+ }
777+ else throw("Strict value is not equal to itself.")
778+ }
779+ else throw("Strict value is not equal to itself.")
780+ }
781+ else throw("Strict value is not equal to itself.")
782+ }
783+ }
784+ }
785+
786+
787+
788+@Callable(i)
789+func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
790+ let r = cg(i)
791+ let outAmAmt = r._1
792+ let outPrAmt = r._2
793+ let pmtAmt = r._3
794+ let pmtAssetId = r._4
795+ let state = r._5
796+ if ((noLessThenAmtAsset > outAmAmt))
797+ then throw(((("Failed: " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
798+ else if ((noLessThenPriceAsset > outPrAmt))
799+ then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
800+ else {
801+ let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
802+ if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
803+ then state
804+ else throw("Strict value is not equal to itself.")
805+ }
806+ }
807+
808+
809+
810+@Callable(i)
811+func unstakeAndGet (amount) = {
812+ let checkPayments = if ((size(i.payments) != 0))
813+ then throw("No pmnts expd")
814+ else true
815+ if ((checkPayments == checkPayments))
816+ then {
817+ let cfg = gpc()
818+ let factoryCfg = gfc()
819+ let lpAssetId = fromBase58String(cfg[idxLPAsId])
820+ let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
821+ let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
822+ if ((unstakeInv == unstakeInv))
823+ then {
824+ let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
825+ let sts = parseIntValue(r._9)
826+ let state = r._10
827+ let v = if (if (igs())
828+ then true
829+ else (sts == PoolShutdown))
830+ then throw(("Blocked: " + toString(sts)))
831+ else true
832+ if ((v == v))
833+ then {
834+ let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
835+ if ((burnA == burnA))
836+ then state
837+ else throw("Strict value is not equal to itself.")
838+ }
839+ else throw("Strict value is not equal to itself.")
840+ }
841+ else throw("Strict value is not equal to itself.")
842+ }
843+ else throw("Strict value is not equal to itself.")
844+ }
845+
846+
847+
848+@Callable(i)
849+func activate (amtAsStr,prAsStr) = if ((toString(i.caller) != toString(fca)))
850+ then throw("denied")
851+ else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr)], "success")
852+
853+
854+
855+@Callable(i)
856+func getPoolConfigWrapperREADONLY () = $Tuple2(nil, gpc())
857+
858+
859+
860+@Callable(i)
861+func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
862+
863+
864+
865+@Callable(i)
866+func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
867+ let pr = calcPrices(amAmt, prAmt, lpAmt)
868+ $Tuple2(nil, [toString(pr[0]), toString(pr[1]), toString(pr[2])])
869+ }
870+
871+
872+
873+@Callable(i)
874+func fromX18WrapperREADONLY (val,resScaleMult) = $Tuple2(nil, f1(parseBigIntValue(val), resScaleMult))
875+
876+
877+
878+@Callable(i)
879+func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(t1(origVal, origScaleMult)))
880+
881+
882+
883+@Callable(i)
884+func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(cpbi(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
885+
886+
887+
888+@Callable(i)
889+func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,usrAddr,isEval,emitLp) = $Tuple2(nil, epo(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, usrAddr, isEval, emitLp, false, 0, ""))
890+
891+
892+
893+@Callable(i)
894+func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
895+ let r = ego(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
896+ $Tuple2(nil, $Tuple10(r._1, r._2, r._3, r._4, r._5, r._6, r._7, toString(r._8), r._9, r._10))
897+ }
898+
899+
900+@Verifier(tx)
901+func verify () = match tx {
902+ case order: Order =>
903+ let mtchPub = mp()
904+ let orV = moa(order)
905+ let sndrV = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
906+ let mtchV = sigVerify(order.bodyBytes, order.proofs[1], mtchPub)
907+ if (if (if (orV)
908+ then sndrV
909+ else false)
910+ then mtchV
911+ else false)
912+ then true
913+ else toe(orV, sndrV, mtchV)
914+ case _ =>
915+ let targetPublicKey = match m() {
916+ case pk: ByteVector =>
917+ pk
918+ case _: Unit =>
919+ tx.senderPublicKey
920+ case _ =>
921+ throw("Match error")
922+ }
923+ sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
924+}
925+

github/deemru/w8io/026f985 
43.49 ms