tx · 42FtAQFCPt8H29PBoKFvardJBiKF5SoMyuCypKSYstXP

3P4gZomvnrbAw6sc3QrBEg6wENPa8ZDKV5p:  -0.02400000 Waves

2022.07.14 20:26 [3205263] smart account 3P4gZomvnrbAw6sc3QrBEg6wENPa8ZDKV5p > SELF 0.00000000 Waves

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

github/deemru/w8io/3ef1775 
38.69 ms