tx · 4XMfPGw8RYb1pWgAgLz5Hg5SX4EhE3daf6k38WHfuuCR

3PBEwUv36ZXRiDEaVmXR41sPvbGfm3nyC6k:  -0.02400000 Waves

2022.10.12 15:45 [3334573] smart account 3PBEwUv36ZXRiDEaVmXR41sPvbGfm3nyC6k > SELF 0.00000000 Waves

{ "type": 13, "id": "4XMfPGw8RYb1pWgAgLz5Hg5SX4EhE3daf6k38WHfuuCR", "fee": 2400000, "feeAssetId": null, "timestamp": 1665578651646, "version": 1, "sender": "3PBEwUv36ZXRiDEaVmXR41sPvbGfm3nyC6k", "senderPublicKey": "6sk7NmzsvB4xw4CGiiRwL1vFLCFQY8SVsViWLPC8eEso", "proofs": [ "2uMzD5SUZpb4wa3ojQ9cp4soE3RtwPhtuZDmXVKgWNuEKvAG4hD6SbkPyoyBgSefEeEP8tJG1JYJajJzs8ZxHt3s" ], "script": "base64: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", "chainId": 87, "height": 3334573, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: FS9YrzohkJUoMqFgTUj4esMq1rnixcDiQ99kfgKFeT7b Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func a (b) = getInteger(this, b)
5+
6+
7+func c (b) = getString(this, b)
8+
9+
10+func d (b) = valueOrErrorMessage(getString(this, b), ((("no string value for key " + b) + " at address ") + toString(this)))
11+
12+
13+func e (f,g) = if (f)
14+ then throw(g)
15+ else true
16+
17+
18+func h (b,i) = if ((0 > i))
19+ then throw(((("writing negative value " + toString(i)) + " for key ") + b))
20+ else IntegerEntry(b, i)
21+
22+
23+func j (i) = if ((0 > i))
24+ then throw("writing negative value")
25+ else i
26+
27+
28+func k (i) = {
29+ let l = i
30+ if ($isInstanceOf(l, "Int"))
31+ then {
32+ let m = l
33+ m
34+ }
35+ else throw("r:1")
36+ }
37+
38+
39+func n (b,i) = h(b, (valueOrElse(a(b), 0) + i))
40+
41+
42+func o (b,i) = StringEntry(b, i)
43+
44+
45+func p (i,q,r) = {
46+ let s = fraction(i, q, r)
47+ let t = 3037000499
48+ let u = ((((s % t) * (r % t)) % t) == (((i % t) * (q % t)) % t))
49+ if (u)
50+ then s
51+ else (s + 1)
52+ }
53+
54+
55+let v = 525600
56+
57+let w = 10000000000000000
58+
59+let x = 1000
60+
61+let y = "assetId"
62+
63+let z = valueOrErrorMessage(c(y), "no assetId")
64+
65+let A = {
66+ let B = split(z, "_")[0]
67+ if ((B == "WAVES"))
68+ then unit
69+ else fromBase58String(B)
70+ }
71+
72+let C = (z + "_ReserveFactor")
73+
74+let D = (z + "_CollateralFactor")
75+
76+let E = (z + "_LiquidationThreshold")
77+
78+let F = "account_health_overlap"
79+
80+let G = (z + "_LiquidationPenalty")
81+
82+let H = "configAddress"
83+
84+let I = "aTokenId"
85+
86+let J = "aTokenName"
87+
88+let K = "aTokenCirculation"
89+
90+let L = "aTokenDecimals"
91+
92+let M = "reserveGlobalData"
93+
94+let N = valueOrElse(getString(M), "||||")
95+
96+let O = split(N, "|")
97+
98+let P = valueOrErrorMessage(valueOrElse(parseInt(O[0]), a("lastUpdateHeight")), "no lastUpdateHeight")
99+
100+let Q = valueOrElse(parseInt(O[1]), valueOrElse(a("totalDeposit"), 0))
101+
102+let R = valueOrElse(parseInt(O[2]), valueOrElse(a("totalBorrow"), 0))
103+
104+let S = valueOrElse(parseInt(O[3]), valueOrElse(a("totalReserve"), 0))
105+
106+let T = valueOrElse(parseInt(O[4]), valueOrElse(a("storedIndex"), w))
107+
108+func U (V) = (V + "_aTokenBalance")
109+
110+
111+func W (V) = (V + "_debt")
112+
113+
114+func X (V) = (V + "_index")
115+
116+
117+func Y (V) = (V + "_useAsCollateral")
118+
119+
120+let Z = valueOrErrorMessage(a(L), "no assetDecimals")
121+
122+let aa = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, H), "reserve: no configAddress")), "invalid config address")
123+
124+func ab (ac) = {
125+ let l = invoke(aa, "opAllowed", [z, ac], nil)
126+ if ($isInstanceOf(l, "Boolean"))
127+ then {
128+ let ad = l
129+ if (ad)
130+ then true
131+ else throw("not allowed")
132+ }
133+ else throw("opAllowed: unexpected result type")
134+ }
135+
136+
137+let ae = valueOrErrorMessage(addressFromString(split(valueOrErrorMessage(getString(aa, "main"), "no main in config"), "|")[0]), "invalid main address")
138+
139+func af (B) = if (contains(getStringValue(aa, "main"), toString(B.caller)))
140+ then true
141+ else throw("only main can do")
142+
143+
144+func ag (B) = {
145+ let ah = valueOrErrorMessage(getString(aa, "divAdmins"), "no div admins")
146+ if (!(contains(ah, toString(B.caller))))
147+ then throw("only div admin can do")
148+ else true
149+ }
150+
151+
152+let ai = e(isDefined(c(y)), "already initialized")
153+
154+let aj = {
155+ let l = getString(aa, "oracle_address")
156+ if ($isInstanceOf(l, "String"))
157+ then {
158+ let ak = l
159+ addressFromString(ak)
160+ }
161+ else unit
162+ }
163+
164+let al = {
165+ let l = invoke(valueOrErrorMessage(aj, "no oracle"), "price", [z], nil)
166+ if ($isInstanceOf(l, "Int"))
167+ then {
168+ let B = l
169+ B
170+ }
171+ else throw("bad oracle data")
172+ }
173+
174+let am = height
175+
176+let an = fromBase58String(valueOrErrorMessage(c(I), "no aTokenId"))
177+
178+let ao = valueOrElse(a(K), 0)
179+
180+let ap = valueOrErrorMessage(getInteger(aa, C), "no reserveFactor")
181+
182+let aq = valueOrErrorMessage(getInteger(aa, D), "no collateralFactor")
183+
184+let ar = valueOrErrorMessage(getInteger(aa, E), "no liquidationThreshold")
185+
186+let as = valueOrErrorMessage(getInteger(aa, F), "no overlapCharge")
187+
188+let at = valueOrErrorMessage(getInteger(aa, G), "no liquidationPenalty")
189+
190+let au = if ((Q > 0))
191+ then min([x, fraction(R, x, Q)])
192+ else 0
193+
194+let av = {
195+ let aw = getIntegerValue(aa, (z + "_APoint"))
196+ let ad = getIntegerValue(aa, (z + "_BPoint"))
197+ let ax = getIntegerValue(aa, (z + "_CPoint"))
198+ let ay = getIntegerValue(aa, (z + "_DPoint"))
199+ let az = (fraction((aw - ax), au, -(ad)) + aw)
200+ let aA = (fraction((ax - ay), (au - ad), (ad - x)) + ax)
201+ if ((au == 0))
202+ then aw
203+ else if ((au == ad))
204+ then ax
205+ else if (if ((ad > au))
206+ then true
207+ else (ad == x))
208+ then az
209+ else aA
210+ }
211+
212+let aB = if ((Q == 0))
213+ then 0
214+ else fraction(fraction(R, av, Q), (x - ap), x)
215+
216+let aC = if ((am == P))
217+ then T
218+ else {
219+ let aD = p(av, w, (v * x))
220+ p(T, (w + (aD * (am - P))), w)
221+ }
222+
223+let aE = valueOrElse(getBoolean(aa, ("staking_enabled_" + z)), false)
224+
225+let aF = {
226+ let l = A
227+ if ($isInstanceOf(l, "ByteVector"))
228+ then {
229+ let aG = l
230+ assetBalance(this, aG)
231+ }
232+ else wavesBalance(this).available
233+ }
234+
235+func aH (aI,aJ,aK) = if ((aI > aJ))
236+ then throw(("not enough liquidity: " + aK))
237+ else true
238+
239+
240+func aL (V) = valueOrElse(a(W(V)), 0)
241+
242+
243+func aM (V) = {
244+ let aN = aL(V)
245+ if ((aN == 0))
246+ then 0
247+ else {
248+ let aO = valueOrErrorMessage(a(X(V)), "has debt but does not have index")
249+ fraction(aN, aC, aO)
250+ }
251+ }
252+
253+
254+let aP = fraction(R, aC, T)
255+
256+let aQ = (aP - R)
257+
258+let aR = fraction(aQ, (x - ap), x)
259+
260+let aS = (Q + aR)
261+
262+let aT = ((S + aQ) - aR)
263+
264+let aU = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(aa, ("staking_config_" + z)), ("no staking address for " + z))), ("bad staking address for " + z))
265+
266+let aV = min([aT, if (aE)
267+ then k(invoke(aU, "info", nil, nil))
268+ else aF])
269+
270+func aW (B,A) = {
271+ let aX = B.payments[0].amount
272+ if ((0 >= aX))
273+ then throw(("Payment is less than min allowed amount: " + toString(aX)))
274+ else if ((B.payments[0].assetId != A))
275+ then throw((" bad asset attached: required " + z))
276+ else aX
277+ }
278+
279+
280+func aY (aZ,ba,bb,bc) = {
281+ let bd = if ((aF == bc))
282+ then unit
283+ else if (!(aE))
284+ then unit
285+ else if ((aF > bc))
286+ then invoke(aU, "put", nil, [AttachedPayment(A, (aF - bc))])
287+ else invoke(aU, "get", [(bc - aF)], nil)
288+ if ((bd == bd))
289+ then {
290+ let be = j((aS + aZ))
291+ let bf = j((aP + ba))
292+ let bg = j((aT + bb))
293+[o(M, ((((((((toString(am) + "|") + toString(be)) + "|") + toString(bf)) + "|") + toString(bg)) + "|") + toString(aC)))]
294+ }
295+ else throw("Strict value is not equal to itself.")
296+ }
297+
298+
299+func bh (bi) = if ((bi == 6))
300+ then 1000000
301+ else if ((bi == 8))
302+ then 100000000
303+ else throw(("bad decimals: " + toString(bi)))
304+
305+
306+func bj (aI) = fraction(aI, al, bh(Z))
307+
308+
309+func bk (aI) = fraction(aI, bh(Z), al)
310+
311+
312+func bl (bm) = if ((bm == 0))
313+ then 0
314+ else if ((ao > 0))
315+ then fraction(bm, aS, ao)
316+ else bm
317+
318+
319+func bn (bo) = if ((bo == 0))
320+ then 0
321+ else if ((ao > 0))
322+ then fraction(bo, ao, aS)
323+ else bo
324+
325+
326+func bp (bo) = if ((bo == 0))
327+ then 0
328+ else if ((ao > 0))
329+ then p(bo, ao, aS)
330+ else bo
331+
332+
333+func bq (br) = valueOrElse(a(U(br)), 0)
334+
335+
336+func bs (bt) = BooleanEntry(Y(bt), true)
337+
338+
339+func bu (bt) = if ((aM(bt) > 0))
340+ then [bs(bt)]
341+ else nil
342+
343+
344+func bv (br,aI) = {
345+ let bf = aM(br)
346+ let be = bl(bq(br))
347+ let bw = min([bf, be])
348+ let bx = if ((-1 > aI))
349+ then throw("invalid collapse amount")
350+ else if (if ((bw == 0))
351+ then true
352+ else (aI == 0))
353+ then throw("nothing to collapse")
354+ else if (if ((aI == -1))
355+ then true
356+ else (aI > bw))
357+ then bw
358+ else aI
359+ let by = bp(bx)
360+ $Tuple2((aY(-(bx), -(bx), 0, 0) ++ [n(U(br), -(by)), n(K, -(by)), h(W(br), (bf - bx)), h(X(br), aC)]), bx)
361+ }
362+
363+
364+func bz (V,aI) = {
365+ let bA = ab("repay")
366+ if ((bA == bA))
367+ then {
368+ let bB = aM(V)
369+ if ((bB == bB))
370+ then {
371+ let bC = if ((aI > bB))
372+ then $Tuple4(0, -(bB), (aI - bB), [ScriptTransfer(addressFromStringValue(V), (aI - bB), A)])
373+ else $Tuple4((bB - aI), -(aI), 0, nil)
374+ let bD = bC._1
375+ let bE = bC._2
376+ let bF = bC._3
377+ let bG = bC._4
378+ let bH = (aI - bF)
379+ $Tuple2(((aY(0, bE, 0, bF) ++ bG) ++ [h(W(V), bD), h(X(V), aC)]), bH)
380+ }
381+ else throw("Strict value is not equal to itself.")
382+ }
383+ else throw("Strict value is not equal to itself.")
384+ }
385+
386+
387+func bI () = {
388+ let aw = getIntegerValue(aa, (z + "_APoint"))
389+ let ad = getIntegerValue(aa, (z + "_BPoint"))
390+ let ax = getIntegerValue(aa, (z + "_CPoint"))
391+ let ay = getIntegerValue(aa, (z + "_DPoint"))
392+ ((((((((((((((("ABCD: " + toString(aw)) + ";") + toString(ad)) + ";") + toString(ax)) + ";") + toString(ay)) + ", reserveFactor: ") + toString(ap)) + ", collateralFactor: ") + toString(aq)) + ", liquidationThreshold: ") + toString(ar)) + ", liquidationPenalty: ") + toString(at))
393+ }
394+
395+
396+func bJ () = ((((((((((((((((((((((((((("currentTotalDeposit: " + toString(aS)) + ", storedTotalDeposit: ") + toString(Q)) + ", currentTotalDebt: ") + toString(aP)) + ", storedTotalDebt: ") + toString(R)) + ", currentTotalReserve: ") + toString(aT)) + ", storedTotalReserve: ") + toString(S)) + ", currentIndex:") + toString(aC)) + ", storedIndex: ") + toString(T)) + ", lastUpdateHeight: ") + toString(P)) + ", utilization: ") + toString(au)) + ", aTokenCirculation: ") + toString(ao)) + ", aTokenPrice: ") + toString(bl(pow(10, 0, Z, 0, 0, FLOOR)))) + ", APR: ") + toString(av)) + ", APY: ") + toString(aB))
397+
398+
399+func bK (bt) = {
400+ func bL (bM,A) = {
401+ let l = A
402+ if ($isInstanceOf(l, "ByteVector"))
403+ then {
404+ let bN = l
405+ assetBalance(bM, bN)
406+ }
407+ else if ($isInstanceOf(l, "Unit"))
408+ then {
409+ let bO = l
410+ wavesBalance(bM).available
411+ }
412+ else throw("Match error")
413+ }
414+
415+ let bP = bq(bt)
416+ let bQ = bL(addressFromStringValue(bt), an)
417+ ((((((((((((((((("currentDebt: " + toString(aM(bt))) + ", storedDebt: ") + toString(valueOrElse(a(W(bt)), 0))) + ", currentDeposit: ") + toString(bl(bP))) + ", aTokenContractBalance: ") + toString(bP)) + ", aTokenWalletBalance: ") + toString(bQ)) + ", walletStake: ") + toString(bl(bQ))) + ", assetWalletBalance: ") + toString(bL(addressFromStringValue(bt), A))) + ", useAsCollateral: ") + toString(valueOrElse(getBoolean(this, Y(bt)), true))) + ", storedIndex: ") + toString(valueOrElse(a(X(bt)), 0)))
418+ }
419+
420+
421+func bR () = ((((((((((((((((((((((("storedTotalDeposit: " + toString(Q)) + ", storedTotalDebt: ") + toString(R)) + ", storedTotalReserve: ") + toString(S)) + ", storedIndex: ") + toString(T)) + ", lastUpdateHeight: ") + toString(P)) + ", currentTotalDeposit: ") + toString(aS)) + ", currentTotalDebt: ") + toString(aP)) + ", currentTotalReserve: ") + toString(aT)) + ", currentIndex: ") + toString(aC)) + ", currentHeight: ") + toString(am)) + ", aTokenCirculation: ") + toString(ao)) + ", aTokenPrice: ") + toString(bl(pow(10, 0, Z, 0, 0, FLOOR))))
422+
423+
424+func bS (bt) = {
425+ let bT = bq(bt)
426+ let bU = bl(bT)
427+ let bf = aM(bt)
428+ if ((am == P))
429+ then $Tuple4(Q, R, bU, bf)
430+ else $Tuple4(aS, aP, bU, bf)
431+ }
432+
433+
434+func bV (B,bt,aI,bW) = {
435+ let bX = ((Q + S) - R)
436+ let bA = if (if (if (af(B))
437+ then aH(aI, bX, ("funds in use: max=" + toString(bX)))
438+ else false)
439+ then e((-1 > aI), "invalid amount")
440+ else false)
441+ then ab("withdraw")
442+ else false
443+ if ((bA == bA))
444+ then {
445+ let bY = if ((aI == -1))
446+ then {
447+ let bT = bq(bt)
448+ $Tuple2(bT, bl(bT))
449+ }
450+ else $Tuple2(bp(aI), aI)
451+ let by = bY._1
452+ let bZ = bY._2
453+ $Tuple2((aY(-(bZ), 0, 0, bZ) ++ [ScriptTransfer(if (bW)
454+ then ae
455+ else addressFromStringValue(bt), bZ, A), n(U(bt), -(by)), n(K, -(by))]), bZ)
456+ }
457+ else throw("Strict value is not equal to itself.")
458+ }
459+
460+
461+func ca (ac,bt,B) = {
462+ let bA = if (af(B))
463+ then ab(ac)
464+ else false
465+ if ((bA == bA))
466+ then {
467+ let bm = aW(B, an)
468+ $Tuple2(((aY(0, 0, 0, 0) ++ [n(U(bt), bm), Burn(an, bm)]) ++ bu(bt)), bl(bm))
469+ }
470+ else throw("Strict value is not equal to itself.")
471+ }
472+
473+
474+func cb (B,br,cc,cd,ce) = {
475+ let cf = bq(br)
476+ let aI = if ((cc == -1))
477+ then cf
478+ else cc
479+ let bA = if (if (if (af(B))
480+ then ab(ce)
481+ else false)
482+ then e((-1 > cc), "invalid amountToMint")
483+ else false)
484+ then e((aI > cf), ("Trying to mint more than available, max: " + toString(cf)))
485+ else false
486+ if ((bA == bA))
487+ then $Tuple2((aY(0, 0, 0, 0) ++ [n(U(br), -(aI)), Reissue(an, aI, true), ScriptTransfer(addressFromStringValue(cd), aI, an)]), bl(aI))
488+ else throw("Strict value is not equal to itself.")
489+ }
490+
491+
492+@Callable(B)
493+func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(aV, z, (aT - aV)))
494+
495+
496+
497+@Callable(B)
498+func storedDepositBorrow () = $Tuple2(nil, $Tuple2(Q, R))
499+
500+
501+
502+@Callable(B)
503+func getCurrentTotals (bt) = $Tuple2(nil, bS(bt))
504+
505+
506+
507+@Callable(B)
508+func getCurrentTotals2 (cg,ch) = {
509+ let ci = bS(cg)
510+ let cj = ci._1
511+ let ck = ci._2
512+ let cl = ci._3
513+ let cm = ci._4
514+ let cn = bS(ch)
515+ let co = cn._1
516+ let cp = cn._2
517+ let cq = cn._3
518+ let cr = cn._4
519+ $Tuple2(nil, $Tuple6(cj, ck, cl, cm, cq, cr))
520+ }
521+
522+
523+
524+@Callable(B)
525+func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + bI()) + ", ") + bJ()))
526+
527+
528+
529+@Callable(B)
530+func adviseUser (bt) = {
531+ let cs = bj(aP)
532+ let ct = bj(aS)
533+ let cu = valueOrElse(getBoolean(this, Y(bt)), true)
534+ let cv = if (cu)
535+ then ct
536+ else 0
537+ let cw = min([cs, cv])
538+ let cx = p(cw, as, x)
539+ let cy = if ((cs > cv))
540+ then 0
541+ else fraction((cv - cs), aq, x)
542+ let cz = if ((cs > cv))
543+ then (fraction((cs - cv), x, ar) + cx)
544+ else cx
545+ let cA = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(cs)) + ", currentDepositUsd: ") + toString(ct)) + ", bp: ") + toString(cy)) + ", bpu: ") + toString(cz))
546+ $Tuple2(nil, ((cA + ", ") + bK(bt)))
547+ }
548+
549+
550+
551+@Callable(B)
552+func addInterest () = if ((B.payments[0].assetId != A))
553+ then throw("can't add interest with unrelated token")
554+ else aY(B.payments[0].amount, 0, 0, 0)
555+
556+
557+
558+@Callable(B)
559+func addToReserve () = if ((B.payments[0].assetId != A))
560+ then throw("can't add interest with unrelated token")
561+ else aY(0, 0, B.payments[0].amount, 0)
562+
563+
564+
565+@Callable(B)
566+func withdrawFromReserve (bx) = {
567+ let bA = ag(B)
568+ if ((bA == bA))
569+ then {
570+ let cB = if ((bx == -1))
571+ then aV
572+ else bx
573+ $Tuple2((aY(0, 0, -(cB), cB) ++ [ScriptTransfer(B.caller, cB, A)]), cB)
574+ }
575+ else throw("Strict value is not equal to itself.")
576+ }
577+
578+
579+
580+@Callable(B)
581+func forceUpdate () = {
582+ let cC = valueOrErrorMessage(getString(aa, "admin"), "reserve:no admin in config")
583+ if ((toString(B.caller) != cC))
584+ then throw("only admin can do")
585+ else aY(0, 0, 0, 0)
586+ }
587+
588+
589+
590+@Callable(B)
591+func initialize (cD,cE,cF,cG,cH) = {
592+ let bA = ai
593+ if ((bA == bA))
594+ then {
595+ let cI = Issue(cF, cG, 0, cH, true)
596+[cI, h(L, cH), o(J, cF), o(y, cE), o(H, cD), o(I, toBase58String(calculateAssetId(cI)))]
597+ }
598+ else throw("Strict value is not equal to itself.")
599+ }
600+
601+
602+
603+@Callable(B)
604+func initialize2 () = if ((B.caller != this))
605+ then throw("only self can continue")
606+ else [StringEntry(M, (toString(am) + "||||"))]
607+
608+
609+
610+@Callable(B)
611+func userDepositUSD (br) = $Tuple2(nil, bj(bl(bq(br))))
612+
613+
614+
615+@Callable(B)
616+func userDebtUSD (br) = $Tuple2(nil, bj(aM(br)))
617+
618+
619+
620+@Callable(B)
621+func userBalance (br) = {
622+ let bT = bq(br)
623+ let bU = bl(bT)
624+ let bf = aM(br)
625+ $Tuple2(nil, $Tuple6(bT, bU, bj(bU), bf, bj(bf), valueOrElse(getBoolean(this, Y(br)), true)))
626+ }
627+
628+
629+
630+@Callable(B)
631+func userDebt (br) = {
632+ let bf = aM(br)
633+ let cJ = bj(bf)
634+ $Tuple2(nil, $Tuple2(bf, cJ))
635+ }
636+
637+
638+
639+@Callable(B)
640+func assetUsdValue (bo) = $Tuple2(nil, bj(bo))
641+
642+
643+
644+@Callable(B)
645+func repayFor (V) = {
646+ let bA = af(B)
647+ if ((bA == bA))
648+ then bz(V, aW(B, A))
649+ else throw("Strict value is not equal to itself.")
650+ }
651+
652+
653+
654+@Callable(B)
655+func depositFor (cK,cL) = {
656+ let bA = if (af(B))
657+ then ab("deposit")
658+ else false
659+ if ((bA == bA))
660+ then if (if ((aM(cK) > 0))
661+ then !(cL)
662+ else false)
663+ then throw("can't disable use as collateral for asset with open debt")
664+ else {
665+ let aI = aW(B, A)
666+ let bm = bn(aI)
667+ (aY(aI, 0, 0, 0) ++ [n(K, bm), n(U(cK), bm), BooleanEntry(Y(cK), cL)])
668+ }
669+ else throw("Strict value is not equal to itself.")
670+ }
671+
672+
673+
674+@Callable(B)
675+func withdrawFor (br,aI) = bV(B, br, aI, false)
676+
677+
678+
679+@Callable(B)
680+func withdrawToMain (bt,aI) = if ((aI != -1))
681+ then throw("reserve: withdrawToMain amount -1 only")
682+ else bV(B, bt, aI, true)
683+
684+
685+
686+@Callable(B)
687+func replenishWithAtokenFor (bt) = ca("replenish_atokens", bt, B)
688+
689+
690+
691+@Callable(B)
692+func replenisForUnlockWithAtokenFor (bt) = ca("replenish_atokens_unlock", bt, B)
693+
694+
695+
696+@Callable(B)
697+func replenishForRepayWithAtokenFor (bt) = ca("repay_atokens", bt, B)
698+
699+
700+
701+@Callable(B)
702+func borrowFor (br,cM) = {
703+ let bA = if (if (af(B))
704+ then aH(cM, (Q - R), "too much borrow requested")
705+ else false)
706+ then ab("borrow")
707+ else false
708+ if ((bA == bA))
709+ then {
710+ let bB = aM(br)
711+ let bD = (bB + cM)
712+ (aY(0, cM, 0, cM) ++ [h(W(br), bD), bs(br), h(X(br), aC), ScriptTransfer(addressFromStringValue(br), cM, A)])
713+ }
714+ else throw("Strict value is not equal to itself.")
715+ }
716+
717+
718+
719+@Callable(B)
720+func mintAtokenFor (br,cc) = cb(B, br, cc, br, "mint_atokens")
721+
722+
723+
724+@Callable(B)
725+func mintAtokenForTo (cN,cc,cd) = cb(B, cN, cc, cd, "lock_mint_atokens")
726+
727+
728+
729+@Callable(B)
730+func redeemAtokensFor (bt) = {
731+ let bA = if (af(B))
732+ then ab("redeem_atokens")
733+ else false
734+ if ((bA == bA))
735+ then {
736+ let bm = aW(B, an)
737+ let cO = bl(bm)
738+ $Tuple2((aY(-(cO), 0, 0, cO) ++ [ScriptTransfer(addressFromStringValue(bt), cO, A), n(K, -(bm)), Burn(an, bm)]), cO)
739+ }
740+ else throw("Strict value is not equal to itself.")
741+ }
742+
743+
744+
745+@Callable(B)
746+func transferATokensFor (cN,cd,cP) = {
747+ let bA = if (af(B))
748+ then ab("transfer_debt")
749+ else false
750+ if ((bA == bA))
751+ then {
752+ let cQ = bk(cP)
753+ let bT = bn(cQ)
754+ let cR = bq(cN)
755+ if ((bT > cR))
756+ then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(cP)) + " transfer.assets: ") + toString(cQ)) + " transfer.atokens: ") + toString(bT)) + " from.atokens: ") + toString(cR)) + " at ") + toString(this)))
757+ else $Tuple2(((aY(0, 0, 0, 0) ++ [n(U(cN), -(bT)), n(U(cd), bT)]) ++ bu(cd)), bl(bT))
758+ }
759+ else throw("Strict value is not equal to itself.")
760+ }
761+
762+
763+
764+@Callable(B)
765+func transferDebtFor (cN,cd,aI) = {
766+ let bA = if (af(B))
767+ then ab("transfer_debt")
768+ else false
769+ if ((bA == bA))
770+ then $Tuple2((aY(0, 0, 0, 0) ++ [h(W(cN), (aM(cN) - aI)), h(W(cd), (aM(cd) + aI)), h(X(cN), aC), h(X(cd), aC), bs(cd)]), aI)
771+ else throw("Strict value is not equal to itself.")
772+ }
773+
774+
775+
776+@Callable(B)
777+func disableUseAsCollateralFor (br) = {
778+ let bA = if (af(B))
779+ then ab("use_as_col")
780+ else false
781+ if ((bA == bA))
782+ then if ((aM(br) > 0))
783+ then throw("can't disable collateral for asset with open debt")
784+ else (aY(0, 0, 0, 0) ++ [BooleanEntry(Y(br), false)])
785+ else throw("Strict value is not equal to itself.")
786+ }
787+
788+
789+
790+@Callable(B)
791+func enableUseAsCollateral () = {
792+ let bA = ab("use_as_col")
793+ if ((bA == bA))
794+ then (aY(0, 0, 0, 0) ++ [bs(toString(B.caller))])
795+ else throw("Strict value is not equal to itself.")
796+ }
797+
798+
799+
800+@Callable(B)
801+func collapseFor (bt) = {
802+ let bA = if (af(B))
803+ then ab("force_collapse")
804+ else false
805+ if ((bA == bA))
806+ then bv(bt, -1)
807+ else throw("Strict value is not equal to itself.")
808+ }
809+
810+
811+
812+@Callable(B)
813+func collapseForAmount (bt,aI) = {
814+ let bA = if (af(B))
815+ then ab("collapse")
816+ else false
817+ if ((bA == bA))
818+ then bv(bt, aI)
819+ else throw("Strict value is not equal to itself.")
820+ }
821+
822+
823+
824+@Callable(B)
825+func lpValue (bm) = $Tuple2(nil, bl(bm))
826+
827+

github/deemru/w8io/3ef1775 
39.27 ms