tx · 7BMaooyVRunkNNJbq3YbCAbDVRuxh93npAkYJsrr2s8H

3MpnX4JEWyNQEbJCSxMtvTnSFK48ZxF5Gzp:  -0.05000000 Waves

2023.04.25 17:22 [2550184] smart account 3MpnX4JEWyNQEbJCSxMtvTnSFK48ZxF5Gzp > SELF 0.00000000 Waves

{ "type": 13, "id": "7BMaooyVRunkNNJbq3YbCAbDVRuxh93npAkYJsrr2s8H", "fee": 5000000, "feeAssetId": null, "timestamp": 1682432613727, "version": 2, "chainId": 84, "sender": "3MpnX4JEWyNQEbJCSxMtvTnSFK48ZxF5Gzp", "senderPublicKey": "EUBww65whQw6TozhvTZ6f3yCUVHXsSeWH8iAtKAtyYf", "proofs": [ "4CpQ8e2bXrw8i3aCAgtgqaLZuY7VjoyK2WTctf2MbWBYpASp94uhq2KYLEUjFVNUHcXL3uyR3EoxEhQ2tAtBm7YF" ], "script": "base64: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", "height": 2550184, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: none Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "__"
5+
6+let b = ""
7+
8+let c = 1000000000000
9+
10+let d = 100000000
11+
12+let e = ((c / 20) * 19)
13+
14+let f = ((60 * 60) * 24)
15+
16+let g = (f * 365)
17+
18+let h = 1000000
19+
20+let i = 9223372036854775807
21+
22+let j = 1000
23+
24+let k = 5
25+
26+let l = ((c / 100) * 5)
27+
28+let m = ((c / 100) * 2)
29+
30+let n = ((c / 100) * 50)
31+
32+let o = (c / 100)
33+
34+let p = "ENABLED"
35+
36+let q = "DISABLED"
37+
38+let r = 1
39+
40+let s = 2
41+
42+let t = 3
43+
44+let u = 1
45+
46+let v = 2
47+
48+let w = 3
49+
50+let x = 4
51+
52+let y = 5
53+
54+let z = "Invocation error"
55+
56+func A (B,C) = fraction(B, d, C, HALFEVEN)
57+
58+
59+func D (B,C) = fraction(B, C, d, HALFEVEN)
60+
61+
62+func E (B,C) = fraction(B, c, C, HALFEVEN)
63+
64+
65+func F (B,C) = fraction(B, C, c, HALFEVEN)
66+
67+
68+func G (H) = makeString(H, a)
69+
70+
71+func I () = G(["%s", "initialized"])
72+
73+
74+func J () = G(["%s", "coordinatorAddress"])
75+
76+
77+func K () = G(["%s", "verifierAddress"])
78+
79+
80+func L () = G(["%s", "serviceAddress"])
81+
82+
83+func M () = G(["%s", "frontendAddress"])
84+
85+
86+func N () = G(["%s", "minterAddress"])
87+
88+
89+func O () = G(["%s", "treasuryAddress"])
90+
91+
92+func P () = G(["%s", "backendAddress"])
93+
94+
95+func Q () = G(["%s", "eastStakingAddress"])
96+
97+
98+func R () = G(["%s", "oracleAddress"])
99+
100+
101+func S () = G(["%s", "exchangeAddress"])
102+
103+
104+func T () = G(["%s", "eastAsset"])
105+
106+
107+func U () = G(["%s", "stEastAsset"])
108+
109+
110+func V () = "A_asset_balance"
111+
112+
113+func W () = "B_asset_balance"
114+
115+
116+func X (Y,Z) = G(["%s%s%s", "vault", Y, Z])
117+
118+
119+func aa (Y) = G(["%s%s", "vault", Y])
120+
121+
122+func ab () = G(["%s", "precision"])
123+
124+
125+func ac () = G(["%s", "backingRatio"])
126+
127+
128+func ad () = G(["%s", "liquidationRatio"])
129+
130+
131+func ae () = G(["%s", "liquidationBonus"])
132+
133+
134+func af () = G(["%s", "liquidationProtocolFee"])
135+
136+
137+func ag () = G(["%s", "stabilityFee"])
138+
139+
140+func ah () = G(["%s", "minAmountDelta"])
141+
142+
143+func ai () = G(["%s", "ticker"])
144+
145+
146+func aj () = G(["%s", "maxRateHeightDelta"])
147+
148+
149+func ak () = G(["%s", "contractAssetId"])
150+
151+
152+func al (am) = G(["%s%s", "price", am])
153+
154+
155+func an (am) = G(["%s%s", "lastHeight", am])
156+
157+
158+func ao (ap,aq) = G(["%s%s%s", "signed", ap, aq])
159+
160+
161+func ar () = G(["%s", "protocolActive"])
162+
163+
164+func as () = valueOrElse(getBoolean(this, I()), false)
165+
166+
167+func at () = if (!(as()))
168+ then throw("Not initialized")
169+ else unit
170+
171+
172+func au () = if (as())
173+ then throw("Already initialized")
174+ else unit
175+
176+
177+func av (aw) = if ((aw.caller != this))
178+ then throw("Only self invocation allowed.")
179+ else unit
180+
181+
182+func ax () = addressFromStringValue(valueOrErrorMessage(getString(J()), "Coordinator is not set"))
183+
184+
185+func ay () = {
186+ let az = getString(J())
187+ if ($isInstanceOf(az, "String"))
188+ then {
189+ let aA = az
190+ getString(addressFromStringValue(aA), K())
191+ }
192+ else if ($isInstanceOf(az, "Unit"))
193+ then unit
194+ else throw("Match error")
195+ }
196+
197+
198+func aB (aC,aD) = addressFromStringValue(valueOrErrorMessage(getString(ax(), aC), aD))
199+
200+
201+func aE () = aB(N(), "Minter is not set")
202+
203+
204+func aF () = aB(M(), "Frontend is not set")
205+
206+
207+func aG () = aB(O(), "Treasury is not set")
208+
209+
210+func aH () = aB(P(), "Backend is not set")
211+
212+
213+func aI () = aB(R(), "Oracle is not set")
214+
215+
216+func aJ () = aB(Q(), "East staking is not set")
217+
218+
219+func aK (aw) = (aw.caller != aG())
220+
221+
222+func aL () = valueOrElse(getInteger(ax(), ah()), j)
223+
224+
225+func aM () = valueOrElse(getInteger(ax(), aj()), k)
226+
227+
228+func aN () = valueOrElse(getInteger(ax(), ae()), l)
229+
230+
231+func aO () = valueOrElse(getInteger(ax(), af()), m)
232+
233+
234+func aP () = valueOrElse(getInteger(ax(), ag()), o)
235+
236+
237+func aQ () = getStringValue(ak())
238+
239+
240+func aR () = valueOrErrorMessage(getString(ax(), T()), "East asset is not set")
241+
242+
243+func aS () = fromBase58String(aR())
244+
245+
246+func aT () = valueOrElse(getBoolean(ax(), ar()), false)
247+
248+
249+func aU () = if (if (!(aT()))
250+ then true
251+ else !(as()))
252+ then throw("Protocol is disabled. Please contact support.")
253+ else unit
254+
255+
256+func aV (aw) = if ((aw.caller != aF()))
257+ then throw("Not allowed")
258+ else unit
259+
260+
261+func aW (aw) = if ((aw.caller != aH()))
262+ then throw("Not allowed")
263+ else unit
264+
265+
266+func aX (aw,Y) = if ((toBase58String(aw.caller.bytes) == Y))
267+ then throw("Self invocation not allowed.")
268+ else unit
269+
270+
271+func aY (aw) = if ((size(aw.payments) != 1))
272+ then throw("Only one payment allowed.")
273+ else unit
274+
275+
276+func aZ (aw) = if ((size(aw.payments) != 0))
277+ then throw("No payment allowed.")
278+ else unit
279+
280+
281+func ba (aw) = (size(aw.payments) == 1)
282+
283+
284+func bb (bc) = if ((0 >= bc))
285+ then throw("Attribute should be positive or zero.")
286+ else unit
287+
288+
289+func bd (bc) = if ((0 > bc))
290+ then throw("Attribute should be positive.")
291+ else unit
292+
293+
294+func be (Y,Z) = getString(X(Y, Z))
295+
296+
297+func bf (Y,Z) = valueOrErrorMessage(be(Y, Z), "Vault not exists")
298+
299+
300+func bg (bh) = {
301+ let az = bh.assetId
302+ if ($isInstanceOf(az, "ByteVector"))
303+ then {
304+ let bi = az
305+ toBase58String(bi)
306+ }
307+ else if ($isInstanceOf(az, "Unit"))
308+ then "WAVES"
309+ else throw("Match error")
310+ }
311+
312+
313+func bj (bi) = if ((bi == "WAVES"))
314+ then unit
315+ else fromBase58String(bi)
316+
317+
318+func bk (bh,bl) = {
319+ let bi = {
320+ let az = bl
321+ if ($isInstanceOf(az, "ByteVector"))
322+ then {
323+ let bm = az
324+ bm
325+ }
326+ else if ($isInstanceOf(az, "String"))
327+ then {
328+ let aA = az
329+ bj(aA)
330+ }
331+ else if ($isInstanceOf(az, "Unit"))
332+ then unit
333+ else throw("Match error")
334+ }
335+ let az = bi
336+ if ($isInstanceOf(az, "ByteVector"))
337+ then {
338+ let bm = az
339+ let bn = {
340+ let bo = assetInfo(bm)
341+ if ($isInstanceOf(bo, "Asset"))
342+ then {
343+ let Z = bo
344+ Z.name
345+ }
346+ else if ($isInstanceOf(bo, "Unit"))
347+ then throw(("Can't find asset " + toBase58String(bm)))
348+ else throw("Match error")
349+ }
350+ let aD = throw(("Attached payment asset is not " + bn))
351+ let bo = bh.assetId
352+ if ($isInstanceOf(bo, "ByteVector"))
353+ then {
354+ let bp = bo
355+ if ((bp != bi))
356+ then aD
357+ else unit
358+ }
359+ else if ($isInstanceOf(bo, "Unit"))
360+ then aD
361+ else throw("Match error")
362+ }
363+ else if ($isInstanceOf(az, "Unit"))
364+ then if ((bh.assetId != unit))
365+ then throw("Attached payment asset is not WAVES")
366+ else unit
367+ else throw("Match error")
368+ }
369+
370+
371+func bq () = valueOrErrorMessage(getInteger(ac()), "Backing ratio is not set")
372+
373+
374+func br () = valueOrErrorMessage(getInteger(ad()), "Liquidation ratio is not set")
375+
376+
377+func bs (ap) = {
378+ let az = addressFromString(ap)
379+ if ($isInstanceOf(az, "Address"))
380+ then {
381+ let Y = az
382+ true
383+ }
384+ else if ($isInstanceOf(az, "Unit"))
385+ then throw("Invalid address")
386+ else throw("Match error")
387+ }
388+
389+
390+func bt (bu) = (size(fromBase58String(bu)) == 32)
391+
392+
393+func bv () = (lastBlock.timestamp / 1000)
394+
395+
396+func bw (aw) = {
397+ let bx = aY(aw)
398+ if ((bx == bx))
399+ then {
400+ let by = aw.payments[0].assetId
401+ let az = by
402+ if ($isInstanceOf(az, "Unit"))
403+ then {
404+ let bz = az
405+ unit
406+ }
407+ else throw("Only WAVES accepted")
408+ }
409+ else throw("Strict value is not equal to itself.")
410+ }
411+
412+
413+func bA (bi) = {
414+ let az = bi
415+ if ($isInstanceOf(az, "ByteVector"))
416+ then {
417+ let bB = az
418+ let bC = toBase58String(bB)
419+ let bD = valueOrErrorMessage(assetInfo(bB), (("Asset " + bC) + " doesn't exist"))
420+ $Tuple3(bC, bD.name, bD.decimals)
421+ }
422+ else if ($isInstanceOf(az, "Unit"))
423+ then {
424+ let bE = az
425+ $Tuple3("WAVES", "WAVES", 8)
426+ }
427+ else throw("Match error")
428+ }
429+
430+
431+func bF (bG) = {
432+ let bH = aM()
433+ let bI = (lastBlock.height - bG)
434+ if ((bH >= bI))
435+ then unit
436+ else throw("Large price delta.")
437+ }
438+
439+
440+func bJ () = {
441+ let am = getStringValue(this, ai())
442+ let bK = aI()
443+ let bG = getIntegerValue(bK, an(am))
444+ let bL = bF(bG)
445+ if ((bL == bL))
446+ then {
447+ let bM = getIntegerValue(bK, al(am))
448+ fraction(bM, c, h)
449+ }
450+ else throw("Strict value is not equal to itself.")
451+ }
452+
453+
454+func bN () = G(["%d", "totalAssetAccepted"])
455+
456+
457+func bO () = G(["%s", "stakerAddress"])
458+
459+
460+func bP () = valueOrElse(getInteger(bN()), 0)
461+
462+
463+func bQ () = valueOrElse(getString(bO()), b)
464+
465+
466+func bR () = addressFromStringValue(bQ())
467+
468+
469+func bS () = (bQ() != b)
470+
471+
472+func bT (bU,bV) = if (if ((0 > bV))
473+ then true
474+ else (0 > bU))
475+ then throw("Backing ratio must be positive")
476+ else if (((1000 + F(l, 1000)) > bV))
477+ then throw("Liquidation ratio must be higher than 105%")
478+ else if ((bV >= bU))
479+ then throw("Backing ratio must be higher than liquidation ratio")
480+ else unit
481+
482+
483+func bW (ap) = {
484+ let Z = aQ()
485+ let bX = aF()
486+ let bY = getString(bX, X(ap, Z))
487+ let az = bY
488+ if ($isInstanceOf(az, "Unit"))
489+ then ["%d%d%d", "0", "0", "0"]
490+ else if ($isInstanceOf(az, "String"))
491+ then {
492+ let aA = az
493+ split(aA, a)
494+ }
495+ else throw("Match error")
496+ }
497+
498+
499+func bZ (ap,ca) = {
500+ let cb = bW(ap)
501+ let cc = (parseIntValue(cb[r]) + 1)
502+ let cd = (parseIntValue(cb[s]) + ca)
503+ if ((0 > cd))
504+ then throw("Something went wrong. Contact support.")
505+ else {
506+ let ce = bJ()
507+ makeString(["%d%d%d", toString(cc), toString(cd), toString(ce)], a)
508+ }
509+ }
510+
511+
512+func cf (ca) = {
513+ let cg = bq()
514+ let ce = bJ()
515+ let ch = F(ca, ce)
516+ let ci = E(ch, cg)
517+ $Tuple2(ci, ch)
518+ }
519+
520+
521+@Callable(aw)
522+func initialize (cj,ck,cl,cm,cn) = {
523+ let co = [au(), bs(cj), bT(ck, cl)]
524+ if ((co == co))
525+ then {
526+ let cg = E(ck, 1000)
527+ let cp = E(cl, 1000)
528+[IntegerEntry(ac(), cg), IntegerEntry(ad(), cp), StringEntry(J(), cj), StringEntry(ai(), cn), StringEntry(ak(), cm), BooleanEntry(I(), true)]
529+ }
530+ else throw("Strict value is not equal to itself.")
531+ }
532+
533+
534+
535+@Callable(aw)
536+func setRatios (ck,cl) = {
537+ let co = [at(), av(aw), bT(ck, cl)]
538+ if ((co == co))
539+ then {
540+ let cg = E(ck, 1000)
541+ let cp = E(cl, 1000)
542+[IntegerEntry(ac(), cg), IntegerEntry(ad(), cp)]
543+ }
544+ else throw("Strict value is not equal to itself.")
545+ }
546+
547+
548+
549+@Callable(aw)
550+func setStaker (ap) = {
551+ let co = [at(), av(aw), bs(ap)]
552+ if ((co == co))
553+ then if (bS())
554+ then throw("Unable to proceed. Staker is already set.")
555+ else [StringEntry(bO(), ap)]
556+ else throw("Strict value is not equal to itself.")
557+ }
558+
559+
560+
561+@Callable(aw)
562+func mint (ap) = {
563+ let cq = aw.payments[0]
564+ let cr = aQ()
565+ let bx = [aU(), aV(aw), aY(aw), bk(cq, cr)]
566+ if ((bx == bx))
567+ then {
568+ let cs = cf(cq.amount)
569+ let ct = cs._1
570+ let cu = cs._2
571+ let bY = bZ(ap, cq.amount)
572+ let cv = (bP() + cq.amount)
573+ let cw = if (bS())
574+ then invoke(bR(), "stake", nil, [cq])
575+ else unit
576+ if ((cw == cw))
577+ then $Tuple2([IntegerEntry(bN(), cv)], $Tuple2(bY, ct))
578+ else throw("Strict value is not equal to itself.")
579+ }
580+ else throw("Strict value is not equal to itself.")
581+ }
582+
583+
584+
585+@Callable(aw)
586+func supply (ap) = {
587+ let cq = aw.payments[0]
588+ let cr = aQ()
589+ let bx = [aU(), aV(aw), aY(aw), bk(cq, cr)]
590+ if ((bx == bx))
591+ then {
592+ let bY = bZ(ap, cq.amount)
593+ let cv = (bP() + cq.amount)
594+ let cw = if (bS())
595+ then invoke(bR(), "stake", nil, [cq])
596+ else unit
597+ if ((cw == cw))
598+ then $Tuple2([IntegerEntry(bN(), cv)], bY)
599+ else throw("Strict value is not equal to itself.")
600+ }
601+ else throw("Strict value is not equal to itself.")
602+ }
603+
604+
605+
606+@Callable(aw)
607+func close (ap,ca) = {
608+ let bx = [aU(), aV(aw), bs(ap), bb(ca)]
609+ if ((bx == bx))
610+ then {
611+ let cx = bW(ap)
612+ let cy = parseIntValue(cx[s])
613+ if ((ca > cy))
614+ then throw("Unable to proceed. Not enough asset in vault.")
615+ else if ((ca > bP()))
616+ then throw("Unable to proceed. Not enough asset.")
617+ else {
618+ let cz = bZ(ap, -(ca))
619+ let cA = cf(ca)
620+ let ct = cA._1
621+ let cu = cA._2
622+ let cw = if (bS())
623+ then invoke(bR(), "unstake", [ca], nil)
624+ else unit
625+ if ((cw == cw))
626+ then {
627+ let bi = bj(aQ())
628+ let Y = addressFromStringValue(ap)
629+ let cv = (bP() - ca)
630+ $Tuple2([IntegerEntry(bN(), cv), ScriptTransfer(Y, ca, bi)], $Tuple3(cz, ct, cu))
631+ }
632+ else throw("Strict value is not equal to itself.")
633+ }
634+ }
635+ else throw("Strict value is not equal to itself.")
636+ }
637+
638+
639+
640+@Callable(aw)
641+func liquidate (cB,ap,cC) = {
642+ let bx = [aU(), aV(aw)]
643+ if ((bx == bx))
644+ then {
645+ let cx = bW(ap)
646+ let cy = parseIntValue(cx[s])
647+ let cD = F(cy, cC)
648+ if ((cD > cy))
649+ then throw("Unable to proceed. Not enough asset in vault.")
650+ else if ((cD > bP()))
651+ then throw("Unable to proceed. Not enough asset.")
652+ else {
653+ let cz = bZ(ap, -(cD))
654+ let cE = cf(cD)
655+ let ct = cE._1
656+ let cu = cE._2
657+ let cw = if (bS())
658+ then invoke(bR(), "unstake", [cD], nil)
659+ else unit
660+ if ((cw == cw))
661+ then {
662+ let cF = F(cD, aO())
663+ let cG = (cD - cF)
664+ let cv = (bP() - cD)
665+ let cH = aG()
666+ let cI = addressFromStringValue(cB)
667+ let bi = bj(aQ())
668+ $Tuple2([IntegerEntry(bN(), cv), ScriptTransfer(cI, cG, bi), ScriptTransfer(cH, cF, bi)], $Tuple2(cz, ct))
669+ }
670+ else throw("Strict value is not equal to itself.")
671+ }
672+ }
673+ else throw("Strict value is not equal to itself.")
674+ }
675+
676+
677+
678+@Callable(aw)
679+func getCurrentUsdPrice () = $Tuple2(nil, bJ())
680+
681+
682+
683+@Callable(aw)
684+func getSubvaultInfo (ap) = {
685+ let cJ = bW(ap)
686+ let cy = parseIntValue(cJ[s])
687+ let cK = bJ()
688+ let cL = F(cy, cK)
689+ let cg = bq()
690+ let cp = br()
691+ let ct = E(cL, cg)
692+ let cM = F(cL, cp)
693+ $Tuple2(nil, $Tuple3(cL, ct, cM))
694+ }
695+
696+
697+@Verifier(cN)
698+func cO () = {
699+ let az = ay()
700+ if ($isInstanceOf(az, "String"))
701+ then {
702+ let Y = az
703+ valueOrElse(getBoolean(addressFromStringValue(Y), ao(toString(this), toBase58String(cN.id))), false)
704+ }
705+ else sigVerify(cN.bodyBytes, cN.proofs[0], cN.senderPublicKey)
706+ }
707+

github/deemru/w8io/169f3d6 
29.57 ms