tx · C7KYQNHWq7mLoHBEpDKNYMyXSi4jeEAVqwJKhphjp5Cp

3MuD6pzEojTFQp6eLgU99Vja9KrjLdqE7zi:  -0.05000000 Waves

2023.04.24 13:03 [2548480] smart account 3MuD6pzEojTFQp6eLgU99Vja9KrjLdqE7zi > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "C7KYQNHWq7mLoHBEpDKNYMyXSi4jeEAVqwJKhphjp5Cp",
    "fee": 5000000,
    "feeAssetId": null,
    "timestamp": 1682330626580,
    "version": 2,
    "chainId": 84,
    "sender": "3MuD6pzEojTFQp6eLgU99Vja9KrjLdqE7zi",
    "senderPublicKey": "5eECifxhmAzj6sMcBznnRWEFPEaT1LAa9QeTbgFmMxJF",
    "proofs": [
        "2ddEk12f4csaHuZzSdRtfH3wnLV36VgpU2R67mGnYB2LbNXwsahYfm5tkPmzDXhEF6KrEJuYyEhoTDLA232GnWkZ"
    ],
    "script": "base64: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",
    "height": 2548480,
    "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+let bN = 1
455+
456+let bO = 2
457+
458+func bP (bQ) = G(["%s%s", "asset", bQ])
459+
460+
461+func bR (ap) = G(["%s%s", "vaultAssets", ap])
462+
463+
464+func bS () = G(["%s", "cumulativeFeeFraction"])
465+
466+
467+func bT () = G(["%s", "fractionLastUpdated"])
468+
469+
470+func bU (bV) = valueOrErrorMessage(getString(bP(bV)), "Unknown asset")
471+
472+
473+func bW (bV) = {
474+    let bX = bU(bV)
475+    let bY = split(bX, a)
476+    let bZ = bY[bO]
477+    addressFromStringValue(bZ)
478+    }
479+
480+
481+func ca (ap) = {
482+    let az = getString(bR(ap))
483+    if ($isInstanceOf(az, "String"))
484+        then {
485+            let aA = az
486+            split(aA, a)
487+            }
488+        else if ($isInstanceOf(az, "Unit"))
489+            then nil
490+            else throw("Match error")
491+    }
492+
493+
494+func cb (ap) = {
495+    let az = getString(aa(ap))
496+    if ($isInstanceOf(az, "String"))
497+        then {
498+            let aA = az
499+            split(aA, a)
500+            }
501+        else if ($isInstanceOf(az, "Unit"))
502+            then ["%d%d%d%d%d", "0", "0", toString(bv()), "0", "0"]
503+            else throw("Match error")
504+    }
505+
506+
507+func cc (bQ) = {
508+    let az = getString(bP(bQ))
509+    if ($isInstanceOf(az, "String"))
510+        then {
511+            let aA = az
512+            true
513+            }
514+        else if ($isInstanceOf(az, "Unit"))
515+            then false
516+            else throw("Match error")
517+    }
518+
519+
520+func cd () = valueOrElse(getInteger(bS()), 0)
521+
522+
523+func ce () = valueOrElse(getInteger(bT()), bv())
524+
525+
526+func cf (bQ) = {
527+    let cg = getStringValue(bP(bQ))
528+    let ch = split(cg, a)
529+    if ((ch[bN] != p))
530+        then throw((("Asset " + bQ) + " is not enabled"))
531+        else unit
532+    }
533+
534+
535+func ci (ap) = if ((size(ca(ap)) == 0))
536+    then throw("Vault is not exist")
537+    else unit
538+
539+
540+func cj (ck,cl,cm) = (cl + F(ck, (cd() - cm)))
541+
542+
543+func cn (co,ap) = makeString(["%s%s", co, ap], a)
544+
545+
546+func cp (ap,ck,cq) = {
547+    let cr = cb(ap)
548+    let cs = parseIntValue(cr[v])
549+    let ct = parseIntValue(cr[u])
550+    let cu = parseIntValue(cr[w])
551+    let cv = parseIntValue(cr[x])
552+    let cw = parseIntValue(cr[y])
553+    let cx = (cs + ck)
554+    let cy = (ct + 1)
555+    if ((0 > cx))
556+        then throw("Something went wrong. Contact support")
557+        else {
558+            let cz = (cj(cs, cv, cw) - cq)
559+            makeString(["%d%d%d%d%d", toString(cy), toString(cx), toString(bv()), toString(cz), toString(cd())], a)
560+            }
561+    }
562+
563+
564+func cA (ap,bQ) = {
565+    let cB = ca(ap)
566+    if (containsElement(cB, bQ))
567+        then throw("Asset already exists")
568+        else makeString((cB :+ bQ), a)
569+    }
570+
571+
572+func cC (ap,bQ) = {
573+    let cB = ca(ap)
574+    if (!(containsElement(cB, bQ)))
575+        then throw("Unknown asset")
576+        else {
577+            let cD = {
578+                let cE = indexOf(cB, bQ)
579+                if ($isInstanceOf(cE, "Int"))
580+                    then cE
581+                    else throw(($getType(cE) + " couldn't be cast to Int"))
582+                }
583+            makeString(removeByIndex(cB, cD), a)
584+            }
585+    }
586+
587+
588+@Callable(aw)
589+func initialize (cF) = {
590+    let cG = [au(), bs(cF)]
591+    if ((cG == cG))
592+        then [StringEntry(J(), cF), BooleanEntry(I(), true)]
593+        else throw("Strict value is not equal to itself.")
594+    }
595+
596+
597+
598+@Callable(aw)
599+func addAsset (bQ,cH) = {
600+    let cG = [at(), av(aw)]
601+    if ((cG == cG))
602+        then if (!(bs(cH)))
603+            then throw("Address is not valid")
604+            else if (cc(bQ))
605+                then throw("Asset is already set")
606+                else [StringEntry(bP(bQ), cn(p, cH))]
607+        else throw("Strict value is not equal to itself.")
608+    }
609+
610+
611+
612+@Callable(aw)
613+func disableAsset (bQ) = {
614+    let cG = [at(), av(aw)]
615+    if ((cG == cG))
616+        then {
617+            let ch = split(valueOrErrorMessage(getString(bP(bQ)), "Unknown asset"), a)
618+[StringEntry(bP(bQ), cn(q, ch[bO]))]
619+            }
620+        else throw("Strict value is not equal to itself.")
621+    }
622+
623+
624+
625+@Callable(aw)
626+func enableAsset (bQ) = {
627+    let cG = [at(), av(aw)]
628+    if ((cG == cG))
629+        then {
630+            let ch = split(valueOrErrorMessage(getString(bP(bQ)), "Unknown asset"), a)
631+[StringEntry(bP(bQ), cn(p, ch[bO]))]
632+            }
633+        else throw("Strict value is not equal to itself.")
634+    }
635+
636+
637+
638+@Callable(aw)
639+func updateFraction () = {
640+    let cI = (bv() - ce())
641+    let cJ = F(E(cI, g), aP())
642+    let cK = (cd() + cJ)
643+[IntegerEntry(bS(), cK), IntegerEntry(bT(), bv())]
644+    }
645+
646+
647+
648+@Callable(aw)
649+func mint () = {
650+    let cL = aw.payments[0]
651+    let cM = bg(cL)
652+    let Y = toBase58String(aw.caller.bytes)
653+    let cG = [aU(), aY(aw), cf(cM)]
654+    if ((cG == cG))
655+        then {
656+            let cN = invoke(this, "updateFraction", nil, nil)
657+            if ((cN == cN))
658+                then {
659+                    let cO = throw("Unable to proceed. Too few assets to mint")
660+                    if ((aL() > cL.amount))
661+                        then cO
662+                        else {
663+                            let cP = bW(cM)
664+                            let cQ = {
665+                                let cE = invoke(cP, "mint", [Y], aw.payments)
666+                                if ($isInstanceOf(cE, "(String, Int)"))
667+                                    then cE
668+                                    else throw(($getType(cE) + " couldn't be cast to (String, Int)"))
669+                                }
670+                            if ((cQ == cQ))
671+                                then {
672+                                    let cs = cQ._2
673+                                    let cR = cQ._1
674+                                    let cS = aS()
675+                                    let cT = cp(Y, cs, 0)
676+                                    let cU = aE()
677+                                    let cV = invoke(cU, "issue", [cs], nil)
678+                                    if ((cV == cV))
679+                                        then {
680+                                            let cB = ca(Y)
681+                                            let cW = if (!(containsElement(cB, cM)))
682+                                                then [StringEntry(bR(Y), cA(Y, cM))]
683+                                                else nil
684+                                            ([StringEntry(aa(Y), cT), StringEntry(X(Y, cM), cR), ScriptTransfer(aw.caller, cs, cS)] ++ cW)
685+                                            }
686+                                        else throw("Strict value is not equal to itself.")
687+                                    }
688+                                else throw("Strict value is not equal to itself.")
689+                            }
690+                    }
691+                else throw("Strict value is not equal to itself.")
692+            }
693+        else throw("Strict value is not equal to itself.")
694+    }
695+
696+
697+
698+@Callable(aw)
699+func supply () = {
700+    let cL = aw.payments[0]
701+    let Y = toBase58String(aw.caller.bytes)
702+    let Z = bg(aw.payments[0])
703+    let cG = [aU(), aY(aw), bf(Y, Z), cf(Z)]
704+    if ((cG == cG))
705+        then {
706+            let cN = invoke(this, "updateFraction", nil, nil)
707+            if ((cN == cN))
708+                then {
709+                    let cO = throw("Unable to proceed. Too few assets to supply")
710+                    if ((aL() > cL.amount))
711+                        then cO
712+                        else {
713+                            let cP = bW(Z)
714+                            let cX = {
715+                                let cE = invoke(cP, "supply", [Y], aw.payments)
716+                                if ($isInstanceOf(cE, "String"))
717+                                    then cE
718+                                    else throw(($getType(cE) + " couldn't be cast to String"))
719+                                }
720+                            if ((cX == cX))
721+                                then [StringEntry(X(Y, Z), cX)]
722+                                else throw("Strict value is not equal to itself.")
723+                            }
724+                    }
725+                else throw("Strict value is not equal to itself.")
726+            }
727+        else throw("Strict value is not equal to itself.")
728+    }
729+
730+
731+
732+@Callable(aw)
733+func reissue (cY) = {
734+    let Y = toBase58String(aw.caller.bytes)
735+    let cG = [aU(), aZ(aw), ci(Y)]
736+    if ((cG == cG))
737+        then {
738+            let cN = invoke(this, "updateFraction", nil, nil)
739+            if ((cN == cN))
740+                then {
741+                    let cO = throw("Unable to proceed. Too few east to reissue")
742+                    if ((aL() > cY))
743+                        then cO
744+                        else {
745+                            let cZ = cb(Y)
746+                            let cs = parseIntValue(cZ[v])
747+                            let da = {
748+                                let cE = invoke(this, "getVaultInfo", [Y], nil)
749+                                if ($isInstanceOf(cE, "(Int, Int, Int, Int, Int)"))
750+                                    then cE
751+                                    else throw(($getType(cE) + " couldn't be cast to (Int, Int, Int, Int, Int)"))
752+                                }
753+                            if ((da == da))
754+                                then {
755+                                    let db = da._5
756+                                    let dc = da._4
757+                                    let dd = da._3
758+                                    let de = da._2
759+                                    let df = da._1
760+                                    let dg = (de - cs)
761+                                    let dh = throw((("Unable to reissue. Only " + toString(dg)) + " EAST available."))
762+                                    if ((cY > dg))
763+                                        then dh
764+                                        else {
765+                                            let cT = cp(Y, cY, 0)
766+                                            let cU = aE()
767+                                            let cV = invoke(cU, "issue", [cY], nil)
768+                                            if ((cV == cV))
769+                                                then {
770+                                                    let cS = aS()
771+[StringEntry(aa(Y), cT), ScriptTransfer(aw.caller, cY, cS)]
772+                                                    }
773+                                                else throw("Strict value is not equal to itself.")
774+                                            }
775+                                    }
776+                                else throw("Strict value is not equal to itself.")
777+                            }
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+@Callable(aw)
787+func close (bV,cY,di) = {
788+    let Y = toBase58String(aw.caller.bytes)
789+    let cS = aS()
790+    let cG = [aU(), bd(cY), ci(Y), if (ba(aw))
791+        then bk(aw.payments[0], cS)
792+        else aZ(aw), if ((cY > 0))
793+        then [bf(Y, bV)]
794+        else unit]
795+    if ((cG == cG))
796+        then {
797+            let cN = invoke(this, "updateFraction", nil, nil)
798+            if ((cN == cN))
799+                then {
800+                    let cZ = cb(Y)
801+                    let cs = parseIntValue(cZ[v])
802+                    let dj = {
803+                        let cE = invoke(this, "getVaultInfo", [Y], nil)
804+                        if ($isInstanceOf(cE, "(Int, Int, Int, Int, Int)"))
805+                            then cE
806+                            else throw(($getType(cE) + " couldn't be cast to (Int, Int, Int, Int, Int)"))
807+                        }
808+                    if ((dj == dj))
809+                        then {
810+                            let db = dj._5
811+                            let dc = dj._4
812+                            let dd = dj._3
813+                            let de = dj._2
814+                            let df = dj._1
815+                            let dk = (de > cs)
816+                            let dl = if (ba(aw))
817+                                then {
818+                                    let cL = aw.payments[0]
819+                                    let dm = (cs + db)
820+                                    let dn = (cL.amount - di)
821+                                    let do = F(db, E(di, dm))
822+                                    let cO = throw(((("Unable to proceed. Not enough east to pay stability fee." + toString(dn)) + " ") + toString(do)))
823+                                    if ((do > dn))
824+                                        then cO
825+                                        else if ((cL.amount > (di + dn)))
826+                                            then cO
827+                                            else {
828+                                                let dh = throw("Unable to proceed. Payment is bigger than owed amount of east.")
829+                                                if ((cL.amount > dm))
830+                                                    then dh
831+                                                    else {
832+                                                        let dp = throw("Unable to proceed. Too few east to burn")
833+                                                        if ((aL() > di))
834+                                                            then dp
835+                                                            else {
836+                                                                let dq = throw("Unable to proceed. Too much east to burn.")
837+                                                                if ((di > cs))
838+                                                                    then dq
839+                                                                    else {
840+                                                                        let cT = cp(Y, -(di), dn)
841+                                                                        let dr = aG()
842+[ScriptTransfer(dr, dn, cS), StringEntry(aa(Y), cT), Burn(cS, di)]
843+                                                                        }
844+                                                                }
845+                                                        }
846+                                                }
847+                                    }
848+                                else nil
849+                            let ds = if ((cY > 0))
850+                                then {
851+                                    let cP = bW(bV)
852+                                    let dt = {
853+                                        let cE = invoke(cP, "close", [Y, cY], nil)
854+                                        if ($isInstanceOf(cE, "(String, Int, Int)"))
855+                                            then cE
856+                                            else throw(($getType(cE) + " couldn't be cast to (String, Int, Int)"))
857+                                        }
858+                                    if ((dt == dt))
859+                                        then {
860+                                            let du = dt._3
861+                                            let dv = dt._2
862+                                            let cX = dt._1
863+                                            let cO = throw("Unable to proceed. Too few assets to close")
864+                                            if ((aL() > cY))
865+                                                then cO
866+                                                else {
867+                                                    let dh = throw("Unable to proceed. Too much assets to close for that amount of east.")
868+                                                    if (if (dk)
869+                                                        then ((cs - di) > (de - dv))
870+                                                        else false)
871+                                                        then dh
872+                                                        else {
873+                                                            let dw = (df - du)
874+                                                            let cx = (cs - di)
875+                                                            let dp = throw("Unable to proceed. BR after close must be more than before.")
876+                                                            let dx = (toBigInt(df) * toBigInt(cx))
877+                                                            let dy = (toBigInt(dw) * toBigInt(cs))
878+                                                            if (if (!(dk))
879+                                                                then (dx > dy)
880+                                                                else false)
881+                                                                then dp
882+                                                                else [StringEntry(X(Y, bV), cX)]
883+                                                            }
884+                                                    }
885+                                            }
886+                                        else throw("Strict value is not equal to itself.")
887+                                    }
888+                                else nil
889+                            (dl ++ ds)
890+                            }
891+                        else throw("Strict value is not equal to itself.")
892+                    }
893+                else throw("Strict value is not equal to itself.")
894+            }
895+        else throw("Strict value is not equal to itself.")
896+    }
897+
898+
899+
900+@Callable(aw)
901+func liquidate (ap) = {
902+    let cL = aw.payments[0]
903+    let cS = aS()
904+    let cG = [aU(), aY(aw), aX(aw, ap), bk(cL, cS), ci(ap)]
905+    if ((cG == cG))
906+        then {
907+            let cN = invoke(this, "updateFraction", nil, nil)
908+            if ((cN == cN))
909+                then {
910+                    let cZ = cb(ap)
911+                    let cs = parseIntValue(cZ[v])
912+                    let dz = F(cs, n)
913+                    let cO = throw("Unable to proceed. Payment amount is bigger than 50% of the vault.")
914+                    if ((cL.amount > dz))
915+                        then cO
916+                        else {
917+                            let dA = {
918+                                let cE = invoke(this, "getVaultInfo", [ap], nil)
919+                                if ($isInstanceOf(cE, "(Int, Int, Int, Int, Int)"))
920+                                    then cE
921+                                    else throw(($getType(cE) + " couldn't be cast to (Int, Int, Int, Int, Int)"))
922+                                }
923+                            if ((dA == dA))
924+                                then {
925+                                    let db = dA._5
926+                                    let dB = dA._4
927+                                    let dC = dA._3
928+                                    let de = dA._2
929+                                    let df = dA._1
930+                                    let dh = throw("Unable to proceed. Vault health is normal.")
931+                                    if ((dC > dB))
932+                                        then dh
933+                                        else {
934+                                            let dD = F(cL.amount, aN())
935+                                            let dE = (cL.amount + dD)
936+                                            let dF = E(dE, df)
937+                                            let dr = aG()
938+                                            let dG = toBase58String(aw.caller.bytes)
939+                                            func dH (dI,dJ) =                                             {
940+                                                let az = dJ
941+                                                if ($isInstanceOf(az, "String"))
942+                                                    then {
943+                                                        let Z = az
944+                                                        let bx = cf(Z)
945+                                                        if ((bx == bx))
946+                                                            then {
947+                                                                let cr = be(ap, Z)
948+                                                                let bo = cr
949+                                                                if ($isInstanceOf(bo, "String"))
950+                                                                    then {
951+                                                                        let dK = bo
952+                                                                        let cP = bW(Z)
953+                                                                        let dL = {
954+                                                                            let cE = invoke(cP, "liquidate", [dG, ap, dF], nil)
955+                                                                            if ($isInstanceOf(cE, "(String, Int)"))
956+                                                                                then cE
957+                                                                                else throw(($getType(cE) + " couldn't be cast to (String, Int)"))
958+                                                                            }
959+                                                                        if ((dL == dL))
960+                                                                            then {
961+                                                                                let dM = dL._2
962+                                                                                let cX = dL._1
963+                                                                                let bi = bj(Z)
964+                                                                                let dN = [StringEntry(X(ap, Z), cX)]
965+                                                                                $Tuple2((dI._1 ++ dN), (dI._2 + dM))
966+                                                                                }
967+                                                                            else throw("Strict value is not equal to itself.")
968+                                                                        }
969+                                                                    else if ($isInstanceOf(bo, "Unit"))
970+                                                                        then dI
971+                                                                        else throw("Match error")
972+                                                                }
973+                                                            else throw("Strict value is not equal to itself.")
974+                                                        }
975+                                                    else if ($isInstanceOf(az, "Unit"))
976+                                                        then dI
977+                                                        else throw("Match error")
978+                                                }
979+
980+                                            let cB = ca(ap)
981+                                            let dO = {
982+                                                let dP = cB
983+                                                let dQ = size(dP)
984+                                                let dR = $Tuple2(nil, 0)
985+                                                func dS (dT,dU) =                                                 if ((dU >= dQ))
986+                                                    then dT
987+                                                    else dH(dT, dP[dU])
988+
989+                                                func dV (dT,dU) =                                                 if ((dU >= dQ))
990+                                                    then dT
991+                                                    else throw("List size exceeds 10")
992+
993+                                                dV(dS(dS(dS(dS(dS(dS(dS(dS(dS(dS(dR, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
994+                                                }
995+                                            let dW = dO._1
996+                                            let dX = dO._2
997+                                            let cT = cp(ap, -(cL.amount), 0)
998+                                            let dY = if (aK(aw))
999+                                                then {
1000+                                                    let dw = (df - dE)
1001+                                                    let dZ = (de - dX)
1002+                                                    let cx = (cs - cL.amount)
1003+                                                    let dp = throw("Unable to proceed. BR after liquidation must be more than before.")
1004+                                                    let dx = (toBigInt(df) * toBigInt(cx))
1005+                                                    let dy = (toBigInt(dw) * toBigInt(cs))
1006+                                                    if ((dx > dy))
1007+                                                        then dp
1008+                                                        else {
1009+                                                            let dq = throw("Unable to proceed. Vault health is above 100% after liquidation.")
1010+                                                            if ((dZ > cx))
1011+                                                                then dq
1012+                                                                else unit
1013+                                                            }
1014+                                                    }
1015+                                                else unit
1016+                                            if ((dY == dY))
1017+                                                then {
1018+                                                    let ea = [Burn(cS, cL.amount), StringEntry(aa(ap), cT)]
1019+                                                    (ea ++ dW)
1020+                                                    }
1021+                                                else throw("Strict value is not equal to itself.")
1022+                                            }
1023+                                    }
1024+                                else throw("Strict value is not equal to itself.")
1025+                            }
1026+                    }
1027+                else throw("Strict value is not equal to itself.")
1028+            }
1029+        else throw("Strict value is not equal to itself.")
1030+    }
1031+
1032+
1033+
1034+@Callable(aw)
1035+func getVaultInfo (ap) = {
1036+    let eb = ci(ap)
1037+    if ((eb == eb))
1038+        then {
1039+            let cN = invoke(this, "updateFraction", nil, nil)
1040+            if ((cN == cN))
1041+                then {
1042+                    let cB = ca(ap)
1043+                    func ct (dI,dJ) =                     {
1044+                        let az = dJ
1045+                        if ($isInstanceOf(az, "String"))
1046+                            then {
1047+                                let Z = az
1048+                                let cP = bW(Z)
1049+                                let ec = {
1050+                                    let cE = invoke(cP, "getSubvaultInfo", [ap], nil)
1051+                                    if ($isInstanceOf(cE, "(Int, Int, Int)"))
1052+                                        then cE
1053+                                        else throw(($getType(cE) + " couldn't be cast to (Int, Int, Int)"))
1054+                                    }
1055+                                if ((ec == ec))
1056+                                    then {
1057+                                        let ed = ec._3
1058+                                        let de = ec._2
1059+                                        let df = ec._1
1060+                                        $Tuple3((dI._1 + df), (dI._2 + de), (dI._3 + ed))
1061+                                        }
1062+                                    else throw("Strict value is not equal to itself.")
1063+                                }
1064+                            else if ($isInstanceOf(az, "Unit"))
1065+                                then dI
1066+                                else throw("Match error")
1067+                        }
1068+
1069+                    let cZ = cb(ap)
1070+                    let cs = parseIntValue(cZ[v])
1071+                    let cv = parseIntValue(cZ[x])
1072+                    let cw = parseIntValue(cZ[y])
1073+                    let ee = {
1074+                        let dP = cB
1075+                        let dQ = size(dP)
1076+                        let dR = $Tuple3(0, 0, 0)
1077+                        func dS (dT,dU) =                         if ((dU >= dQ))
1078+                            then dT
1079+                            else ct(dT, dP[dU])
1080+
1081+                        func dV (dT,dU) =                         if ((dU >= dQ))
1082+                            then dT
1083+                            else throw("List size exceeds 10")
1084+
1085+                        dV(dS(dS(dS(dS(dS(dS(dS(dS(dS(dS(dR, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1086+                        }
1087+                    let df = ee._1
1088+                    let de = ee._2
1089+                    let ed = ee._3
1090+                    let dB = E(ed, df)
1091+                    let dC = if ((cs > 0))
1092+                        then E(df, cs)
1093+                        else i
1094+                    let ef = cj(cs, cv, cw)
1095+                    $Tuple2(nil, $Tuple5(df, de, dC, dB, ef))
1096+                    }
1097+                else throw("Strict value is not equal to itself.")
1098+            }
1099+        else throw("Strict value is not equal to itself.")
1100+    }
1101+
1102+
1103+@Verifier(eg)
1104+func eh () = {
1105+    let az = ay()
1106+    if ($isInstanceOf(az, "String"))
1107+        then {
1108+            let Y = az
1109+            valueOrElse(getBoolean(addressFromStringValue(Y), ao(toString(this), toBase58String(eg.id))), false)
1110+            }
1111+        else sigVerify(eg.bodyBytes, eg.proofs[0], eg.senderPublicKey)
1112+    }
1113+
github/deemru/w8io/169f3d6 
84.26 ms ◑