2022.04.27 09:59 [3091971] smart account 3PCwFXSq8vj8iKitA5zrrLRbuqehfmimpce > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "bf1sT7CdN98dsfRNmzPUh2AN7hohrHx8C1wrohLq8bR",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1651042716266,
    "version": 1,
    "sender": "3PCwFXSq8vj8iKitA5zrrLRbuqehfmimpce",
    "senderPublicKey": "9iqTo4hVx8TfXiitFf4xY1DGQbccrLGt37iRETBSeBXx",
    "proofs": [
        "4GyHzy4eT93EEU1xxf6i5rLKhperJ3JWmoUyvKMTgGa4LhngS6wxvju32NHWK5j7swbNUsMgT3ekQEg1X6VVLvAK"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3091971,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2nR7BBnuWTynb28i6t6bPujt5R1a9DPuGCaTU8hkyW2D
Next: 5QeWKmypjgk88mJBKw5YgezXvdobvRLDG9xPTiWYYNKn

Diff: 

OldNewDifferences
181181 let storedIndex = valueOrElse(getI(indexStore), RBase)
182182 
183183 let utilization = if ((storedTotalDeposit > 0))
184-    then fraction(storedTotalDebt, factorsBase, storedTotalDeposit)
184+    then min([factorsBase, fraction(storedTotalDebt, factorsBase, storedTotalDeposit)])
185185     else 0
186186 
187187 let apr = {
354354             let currentDebt = currentUserDebt(userAddress)
355355             if ((currentDebt == currentDebt))
356356                 then {
357-                    let $t01111011413 = if ((amount > currentDebt))
357+                    let $t01113011433 = if ((amount > currentDebt))
358358                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
359359                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
360-                    let newDebt = $t01111011413._1
361-                    let totalDebtUpdate = $t01111011413._2
362-                    let payout = $t01111011413._3
363-                    let actions = $t01111011413._4
360+                    let newDebt = $t01113011433._1
361+                    let totalDebtUpdate = $t01113011433._2
362+                    let payout = $t01113011433._3
363+                    let actions = $t01113011433._4
364364                     let repaid = (amount - payout)
365365                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
366366                     }
405405 func withdrawInternal (i,user,amount,toMain) = {
406406     let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
407407     let checks = if (if (if (mainOnly(i))
408-        then liquidityCheck(amount, maxWithdraw, "funds in use")
408+        then liquidityCheck(amount, maxWithdraw, ("funds in use: max=" + toString(maxWithdraw)))
409409         else false)
410410         then throwIf((-1 > amount), "invalid amount")
411411         else false)
413413         else false
414414     if ((checks == checks))
415415         then {
416-            let $t01526415455 = if ((amount == -1))
416+            let $t01531515506 = if ((amount == -1))
417417                 then {
418418                     let atokens = aTokenBalance(user)
419419                     $Tuple2(atokens, aTokenToAsset(atokens))
420420                     }
421421                 else $Tuple2(assetToATokenCeil(amount), amount)
422-            let removedAtokens = $t01526415455._1
423-            let withdrawAmount = $t01526415455._2
422+            let removedAtokens = $t01531515506._1
423+            let withdrawAmount = $t01531515506._2
424424             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(if (toMain)
425425                 then mainContract
426426                 else addressFromStringValue(user), withdrawAmount, assetId), changeBy(aTokenBalanceStore(user), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
429429     }
430430 
431431 
432+func replenishInternal (op,user,i) = {
433+    let checks = if (mainOnly(i))
434+        then opAllowed(op)
435+        else false
436+    if ((checks == checks))
437+        then {
438+            let aTokenAmount = paymentAmount(i, aTokenId)
439+            $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
440+            }
441+        else throw("Strict value is not equal to itself.")
442+    }
443+
444+
432445 @Callable(i)
433-func getReserveDivsInfo () = $Tuple2(nil, $Tuple2(claimableDividends, assetIdStr))
446+func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(claimableDividends, assetIdStr, (currentTotalReserve - claimableDividends)))
434447 
435448 
436449 
441454 
442455 @Callable(i)
443456 func getCurrentTotals2 (user1,user2) = {
444-    let $t01600316040 = userTotals(user1)
445-    let d1 = $t01600316040._1
446-    let d2 = $t01600316040._2
447-    let d3 = $t01600316040._3
448-    let d4 = $t01600316040._4
449-    let $t01604516082 = userTotals(user2)
450-    let e1 = $t01604516082._1
451-    let e2 = $t01604516082._2
452-    let e3 = $t01604516082._3
453-    let e4 = $t01604516082._4
457+    let $t01643516472 = userTotals(user1)
458+    let d1 = $t01643516472._1
459+    let d2 = $t01643516472._2
460+    let d3 = $t01643516472._3
461+    let d4 = $t01643516472._4
462+    let $t01647716514 = userTotals(user2)
463+    let e1 = $t01647716514._1
464+    let e2 = $t01647716514._2
465+    let e3 = $t01647716514._3
466+    let e4 = $t01647716514._4
454467     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
455468     }
456469 
621634 
622635 
623636 @Callable(i)
624-func replenishWithAtokenFor (user) = {
625-    let checks = if (mainOnly(i))
626-        then opAllowed("atokens")
627-        else false
628-    if ((checks == checks))
629-        then {
630-            let aTokenAmount = paymentAmount(i, aTokenId)
631-            $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
632-            }
633-        else throw("Strict value is not equal to itself.")
634-    }
637+func replenishWithAtokenFor (user) = replenishInternal("replenish_atokens", user, i)
638+
639+
640+
641+@Callable(i)
642+func replenishForRepayWithAtokenFor (user) = replenishInternal("repay_atokens", user, i)
635643 
636644 
637645 
660668         then userATokenBalance
661669         else amountToMint
662670     let checks = if (if (if (mainOnly(i))
663-        then opAllowed("atokens")
671+        then opAllowed("mint_atokens")
664672         else false)
665673         then throwIf((-1 > amountToMint), "invalid amountToMint")
666674         else false)
676684 @Callable(i)
677685 func redeemAtokensFor (user) = {
678686     let checks = if (mainOnly(i))
679-        then opAllowed("atokens")
687+        then opAllowed("redeem_atokens")
680688         else false
681689     if ((checks == checks))
682690         then {

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 func getI (key) = getInteger(this, key)
55 
66 
77 func getS (key) = getString(this, key)
88 
99 
1010 func getSV (key) = valueOrErrorMessage(getString(this, key), ((("no string value for key " + key) + " at address ") + toString(this)))
1111 
1212 
1313 func throwIf (condition,error) = if (condition)
1414     then throw(error)
1515     else true
1616 
1717 
1818 func writeInt (key,value) = if ((0 > value))
1919     then throw(((("writing negative value " + toString(value)) + " for key ") + key))
2020     else IntegerEntry(key, value)
2121 
2222 
2323 func changeBy (key,value) = writeInt(key, (valueOrElse(getI(key), 0) + value))
2424 
2525 
2626 func writeString (key,value) = StringEntry(key, value)
2727 
2828 
2929 func fractionCeil (value,numerator,denominator) = {
3030     let cand = fraction(value, numerator, denominator)
3131     let D = 3037000499
3232     let exact = ((((cand % D) * (denominator % D)) % D) == (((value % D) * (numerator % D)) % D))
3333     if (exact)
3434         then cand
3535         else (cand + 1)
3636     }
3737 
3838 
3939 let BlocksPerYear = 525600
4040 
4141 let RBase = 10000000000000000
4242 
4343 let factorsBase = 1000
4444 
4545 let assetIdStore = "assetId"
4646 
4747 let assetIdStr = valueOrErrorMessage(getS(assetIdStore), "no assetId")
4848 
4949 let assetId = if ((assetIdStr == "WAVES"))
5050     then unit
5151     else fromBase58String(assetIdStr)
5252 
5353 let reserveFactorStore = (assetIdStr + "_ReserveFactor")
5454 
5555 let collateralFactorStore = (assetIdStr + "_CollateralFactor")
5656 
5757 let liquidationThresholdStore = (assetIdStr + "_LiquidationThreshold")
5858 
5959 let overlapChargeStore = "account_health_overlap"
6060 
6161 let liquidationPenaltyStore = (assetIdStr + "_LiquidationPenalty")
6262 
6363 let configAddressStore = "configAddress"
6464 
6565 let aTokenIdStore = "aTokenId"
6666 
6767 let aTokenNameStore = "aTokenName"
6868 
6969 let aTokenCirculationStore = "aTokenCirculation"
7070 
7171 let lastUpdateHeightStore = "lastUpdateHeight"
7272 
7373 let totalDebtStore = "totalBorrow"
7474 
7575 let totalDepositStore = "totalDeposit"
7676 
7777 let totalReserveStore = "totalReserve"
7878 
7979 let indexStore = "storedIndex"
8080 
8181 let aTokenDecimalsStore = "aTokenDecimals"
8282 
8383 func aTokenBalanceStore (userAddress) = (userAddress + "_aTokenBalance")
8484 
8585 
8686 func debtStore (userAddress) = (userAddress + "_debt")
8787 
8888 
8989 func debtIndexStore (userAddress) = (userAddress + "_index")
9090 
9191 
9292 func useAsCollateralStore (userAddress) = (userAddress + "_useAsCollateral")
9393 
9494 
9595 func getBalance (addressOrAlias,assetId) = match assetId {
9696     case bv: ByteVector => 
9797         assetBalance(addressOrAlias, bv)
9898     case u: Unit => 
9999         wavesBalance(addressOrAlias).available
100100     case _ => 
101101         throw("Match error")
102102 }
103103 
104104 
105105 let assetDecimals = valueOrErrorMessage(getI(aTokenDecimalsStore), "no assetDecimals")
106106 
107107 let configAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, configAddressStore), "reserve: no configAddress")), "invalid config address")
108108 
109109 func opAllowed (op) = match invoke(configAddress, "opAllowed", [assetIdStr, op], nil) {
110110     case b: Boolean => 
111111         if (b)
112112             then true
113113             else throw("not allowed")
114114     case _ => 
115115         throw("opAllowed: unexpected result type")
116116 }
117117 
118118 
119119 let mainContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, "main"), "no main in config")), "invalid main address")
120120 
121121 func mainOnly (i) = if ((i.caller != mainContract))
122122     then throw("only main can do")
123123     else true
124124 
125125 
126126 func divAdminOnly (i) = {
127127     let divAdmins = valueOrErrorMessage(getString(configAddress, "divAdmins"), "no div admins")
128128     if (!(contains(divAdmins, toString(i.caller))))
129129         then throw("only div admin can do")
130130         else true
131131     }
132132 
133133 
134134 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
135135     then (fromBase58String(value) == fromBase58String(""))
136136     else false)
137137     then throw("invalid assetId")
138138     else true
139139 
140140 
141141 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
142142 
143143 let maybeOracleAddress = match getString(configAddress, "oracle_address") {
144144     case s: String => 
145145         addressFromString(s)
146146     case _ => 
147147         unit
148148 }
149149 
150150 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [assetIdStr], nil) {
151151     case i: Int => 
152152         i
153153     case _ => 
154154         throw("bad oracle data")
155155 }
156156 
157157 let HEIGHT = height
158158 
159159 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
160160 
161161 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
162162 
163163 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
164164 
165165 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
166166 
167167 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
168168 
169169 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
170170 
171171 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
172172 
173173 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
174174 
175175 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
176176 
177177 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
178178 
179179 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
180180 
181181 let storedIndex = valueOrElse(getI(indexStore), RBase)
182182 
183183 let utilization = if ((storedTotalDeposit > 0))
184-    then fraction(storedTotalDebt, factorsBase, storedTotalDeposit)
184+    then min([factorsBase, fraction(storedTotalDebt, factorsBase, storedTotalDeposit)])
185185     else 0
186186 
187187 let apr = {
188188     let a = getIntegerValue(configAddress, (assetIdStr + "_APoint"))
189189     let b = getIntegerValue(configAddress, (assetIdStr + "_BPoint"))
190190     let c = getIntegerValue(configAddress, (assetIdStr + "_CPoint"))
191191     let d = getIntegerValue(configAddress, (assetIdStr + "_DPoint"))
192192     let lineAC = (fraction((a - c), utilization, -(b)) + a)
193193     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
194194     if ((utilization == 0))
195195         then a
196196         else if ((utilization == b))
197197             then c
198198             else if (if ((b > utilization))
199199                 then true
200200                 else (b == factorsBase))
201201                 then lineAC
202202                 else lineCD
203203     }
204204 
205205 let apy = if ((storedTotalDeposit == 0))
206206     then 0
207207     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
208208 
209209 let currentIndex = if ((HEIGHT == lastUpdateHeight))
210210     then storedIndex
211211     else {
212212         let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
213213         fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
214214         }
215215 
216216 let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
217217 
218218 let actualBalance = match assetId {
219219     case aid: ByteVector => 
220220         assetBalance(this, aid)
221221     case _ => 
222222         wavesBalance(this).available
223223 }
224224 
225225 func liquidityCheck (amount,max,err) = if ((amount > max))
226226     then throw(("not enough liquidity: " + err))
227227     else true
228228 
229229 
230230 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
231231 
232232 
233233 func currentUserDebt (userAddress) = {
234234     let v = storedUserDebt(userAddress)
235235     if ((v == 0))
236236         then 0
237237         else {
238238             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
239239             fraction(v, currentIndex, storedUserIndex)
240240             }
241241     }
242242 
243243 
244244 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
245245 
246246 let addedDebt = (currentTotalDebt - storedTotalDebt)
247247 
248248 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
249249 
250250 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
251251 
252252 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
253253 
254254 let claimableDividends = if (stakingEnabled)
255255     then currentTotalReserve
256256     else min([actualBalance, currentTotalReserve])
257257 
258258 func paymentAmount (i,assetId) = {
259259     let p = i.payments[0].amount
260260     if ((0 >= p))
261261         then throw(("Payment is less than min allowed amount: " + toString(p)))
262262         else if ((i.payments[0].assetId != assetId))
263263             then throw((" bad asset attached: required " + assetIdStr))
264264             else p
265265     }
266266 
267267 
268268 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
269269     let stakingAction = if ((actualBalance == keepAtBalance))
270270         then unit
271271         else if (!(stakingEnabled))
272272             then unit
273273             else {
274274                 let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
275275                 if ((actualBalance > keepAtBalance))
276276                     then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
277277                     else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
278278                 }
279279     if ((stakingAction == stakingAction))
280280         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
281281         else throw("Strict value is not equal to itself.")
282282     }
283283 
284284 
285285 func pow10 (n) = if ((n == 6))
286286     then 1000000
287287     else if ((n == 8))
288288         then 100000000
289289         else throw(("bad decimals: " + toString(n)))
290290 
291291 
292292 func assetToUsd (amount) = fraction(amount, oraclePrice, pow10(assetDecimals))
293293 
294294 
295295 func usdToAsset (amount) = fraction(amount, pow10(assetDecimals), oraclePrice)
296296 
297297 
298298 func aTokenToAsset (aTokenAmount) = if ((aTokenAmount == 0))
299299     then 0
300300     else if ((aTokenCirculation > 0))
301301         then fraction(aTokenAmount, currentTotalDeposit, aTokenCirculation)
302302         else aTokenAmount
303303 
304304 
305305 func assetToAToken (assetAmount) = if ((assetAmount == 0))
306306     then 0
307307     else if ((aTokenCirculation > 0))
308308         then fraction(assetAmount, aTokenCirculation, currentTotalDeposit)
309309         else assetAmount
310310 
311311 
312312 func assetToATokenCeil (assetAmount) = if ((assetAmount == 0))
313313     then 0
314314     else if ((aTokenCirculation > 0))
315315         then fractionCeil(assetAmount, aTokenCirculation, currentTotalDeposit)
316316         else assetAmount
317317 
318318 
319319 func aTokenBalance (address) = valueOrElse(getI(aTokenBalanceStore(address)), 0)
320320 
321321 
322322 func enableCol (user) = BooleanEntry(useAsCollateralStore(user), true)
323323 
324324 
325325 func enableColIfNeeded (user) = if ((currentUserDebt(user) > 0))
326326     then [enableCol(user)]
327327     else nil
328328 
329329 
330330 func collapseUser (address,amount) = {
331331     let debt = currentUserDebt(address)
332332     let deposit = aTokenToAsset(aTokenBalance(address))
333333     let maxPossible = min([debt, deposit])
334334     let amt = if ((-1 > amount))
335335         then throw("invalid collapse amount")
336336         else if (if ((maxPossible == 0))
337337             then true
338338             else (amount == 0))
339339             then throw("nothing to collapse")
340340             else if (if ((amount == -1))
341341                 then true
342342                 else (amount > maxPossible))
343343                 then maxPossible
344344                 else amount
345345     let removedAtokens = assetToATokenCeil(amt)
346346     $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
347347     }
348348 
349349 
350350 func repayUser (userAddress,amount) = {
351351     let checks = opAllowed("repay")
352352     if ((checks == checks))
353353         then {
354354             let currentDebt = currentUserDebt(userAddress)
355355             if ((currentDebt == currentDebt))
356356                 then {
357-                    let $t01111011413 = if ((amount > currentDebt))
357+                    let $t01113011433 = if ((amount > currentDebt))
358358                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
359359                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
360-                    let newDebt = $t01111011413._1
361-                    let totalDebtUpdate = $t01111011413._2
362-                    let payout = $t01111011413._3
363-                    let actions = $t01111011413._4
360+                    let newDebt = $t01113011433._1
361+                    let totalDebtUpdate = $t01113011433._2
362+                    let payout = $t01113011433._3
363+                    let actions = $t01113011433._4
364364                     let repaid = (amount - payout)
365365                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
366366                     }
367367                 else throw("Strict value is not equal to itself.")
368368             }
369369         else throw("Strict value is not equal to itself.")
370370     }
371371 
372372 
373373 func getConfig () = {
374374     let a = getIntegerValue(configAddress, (assetIdStr + "_APoint"))
375375     let b = getIntegerValue(configAddress, (assetIdStr + "_BPoint"))
376376     let c = getIntegerValue(configAddress, (assetIdStr + "_CPoint"))
377377     let d = getIntegerValue(configAddress, (assetIdStr + "_DPoint"))
378378     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
379379     }
380380 
381381 
382382 func getState () = ((((((((((((((((((((((((((("currentTotalDeposit: " + toString(currentTotalDeposit)) + ", storedTotalDeposit: ") + toString(storedTotalDeposit)) + ", currentTotalDebt: ") + toString(currentTotalDebt)) + ", storedTotalDebt: ") + toString(storedTotalDebt)) + ", currentTotalReserve: ") + toString(currentTotalReserve)) + ", storedTotalReserve: ") + toString(storedTotalReserve)) + ", currentIndex:") + toString(currentIndex)) + ", storedIndex: ") + toString(storedIndex)) + ", lastUpdateHeight: ") + toString(lastUpdateHeight)) + ", utilization: ") + toString(utilization)) + ", aTokenCirculation: ") + toString(aTokenCirculation)) + ", aTokenPrice: ") + toString(aTokenToAsset(pow(10, 0, assetDecimals, 0, 0, FLOOR)))) + ", APR: ") + toString(apr)) + ", APY: ") + toString(apy))
383383 
384384 
385385 func getUserState (user) = {
386386     let aBalance = aTokenBalance(user)
387387     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
388388     ((((((((((((((((("currentDebt: " + toString(currentUserDebt(user))) + ", storedDebt: ") + toString(valueOrElse(getI(debtStore(user)), 0))) + ", currentDeposit: ") + toString(aTokenToAsset(aBalance))) + ", aTokenContractBalance: ") + toString(aBalance)) + ", aTokenWalletBalance: ") + toString(aBalanceWallet)) + ", walletStake: ") + toString(aTokenToAsset(aBalanceWallet))) + ", assetWalletBalance: ") + toString(getBalance(addressFromStringValue(user), assetId))) + ", useAsCollateral: ") + toString(valueOrElse(getBoolean(this, useAsCollateralStore(user)), true))) + ", storedIndex: ") + toString(valueOrElse(getI(debtIndexStore(user)), 0)))
389389     }
390390 
391391 
392392 func debugTotals () = ((((((((((((((((((((((("storedTotalDeposit: " + toString(storedTotalDeposit)) + ", storedTotalDebt: ") + toString(storedTotalDebt)) + ", storedTotalReserve: ") + toString(storedTotalReserve)) + ", storedIndex: ") + toString(storedIndex)) + ", lastUpdateHeight: ") + toString(lastUpdateHeight)) + ", currentTotalDeposit: ") + toString(currentTotalDeposit)) + ", currentTotalDebt: ") + toString(currentTotalDebt)) + ", currentTotalReserve: ") + toString(currentTotalReserve)) + ", currentIndex: ") + toString(currentIndex)) + ", currentHeight: ") + toString(HEIGHT)) + ", aTokenCirculation: ") + toString(aTokenCirculation)) + ", aTokenPrice: ") + toString(aTokenToAsset(pow(10, 0, assetDecimals, 0, 0, FLOOR))))
393393 
394394 
395395 func userTotals (user) = {
396396     let atokens = aTokenBalance(user)
397397     let asset = aTokenToAsset(atokens)
398398     let debt = currentUserDebt(user)
399399     if ((HEIGHT == lastUpdateHeight))
400400         then $Tuple4(storedTotalDeposit, storedTotalDebt, asset, debt)
401401         else $Tuple4(currentTotalDeposit, currentTotalDebt, asset, debt)
402402     }
403403 
404404 
405405 func withdrawInternal (i,user,amount,toMain) = {
406406     let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
407407     let checks = if (if (if (mainOnly(i))
408-        then liquidityCheck(amount, maxWithdraw, "funds in use")
408+        then liquidityCheck(amount, maxWithdraw, ("funds in use: max=" + toString(maxWithdraw)))
409409         else false)
410410         then throwIf((-1 > amount), "invalid amount")
411411         else false)
412412         then opAllowed("withdraw")
413413         else false
414414     if ((checks == checks))
415415         then {
416-            let $t01526415455 = if ((amount == -1))
416+            let $t01531515506 = if ((amount == -1))
417417                 then {
418418                     let atokens = aTokenBalance(user)
419419                     $Tuple2(atokens, aTokenToAsset(atokens))
420420                     }
421421                 else $Tuple2(assetToATokenCeil(amount), amount)
422-            let removedAtokens = $t01526415455._1
423-            let withdrawAmount = $t01526415455._2
422+            let removedAtokens = $t01531515506._1
423+            let withdrawAmount = $t01531515506._2
424424             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(if (toMain)
425425                 then mainContract
426426                 else addressFromStringValue(user), withdrawAmount, assetId), changeBy(aTokenBalanceStore(user), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
427427             }
428428         else throw("Strict value is not equal to itself.")
429429     }
430430 
431431 
432+func replenishInternal (op,user,i) = {
433+    let checks = if (mainOnly(i))
434+        then opAllowed(op)
435+        else false
436+    if ((checks == checks))
437+        then {
438+            let aTokenAmount = paymentAmount(i, aTokenId)
439+            $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
440+            }
441+        else throw("Strict value is not equal to itself.")
442+    }
443+
444+
432445 @Callable(i)
433-func getReserveDivsInfo () = $Tuple2(nil, $Tuple2(claimableDividends, assetIdStr))
446+func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(claimableDividends, assetIdStr, (currentTotalReserve - claimableDividends)))
434447 
435448 
436449 
437450 @Callable(i)
438451 func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
439452 
440453 
441454 
442455 @Callable(i)
443456 func getCurrentTotals2 (user1,user2) = {
444-    let $t01600316040 = userTotals(user1)
445-    let d1 = $t01600316040._1
446-    let d2 = $t01600316040._2
447-    let d3 = $t01600316040._3
448-    let d4 = $t01600316040._4
449-    let $t01604516082 = userTotals(user2)
450-    let e1 = $t01604516082._1
451-    let e2 = $t01604516082._2
452-    let e3 = $t01604516082._3
453-    let e4 = $t01604516082._4
457+    let $t01643516472 = userTotals(user1)
458+    let d1 = $t01643516472._1
459+    let d2 = $t01643516472._2
460+    let d3 = $t01643516472._3
461+    let d4 = $t01643516472._4
462+    let $t01647716514 = userTotals(user2)
463+    let e1 = $t01647716514._1
464+    let e2 = $t01647716514._2
465+    let e3 = $t01647716514._3
466+    let e4 = $t01647716514._4
454467     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
455468     }
456469 
457470 
458471 
459472 @Callable(i)
460473 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
461474 
462475 
463476 
464477 @Callable(i)
465478 func adviseUser (user) = {
466479     let currentDebtUsd = assetToUsd(currentTotalDebt)
467480     let currentDepositUsd = assetToUsd(currentTotalDeposit)
468481     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
469482     let effectiveDepositUsd = if (asCollateral)
470483         then currentDepositUsd
471484         else 0
472485     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
473486     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
474487     let bp = if ((currentDebtUsd > effectiveDepositUsd))
475488         then 0
476489         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
477490     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
478491         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
479492         else overlapCharge
480493     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
481494     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
482495     }
483496 
484497 
485498 
486499 @Callable(i)
487500 func addInterest () = if ((i.payments[0].assetId != assetId))
488501     then throw("can't add interest with unrelated token")
489502     else syncTotals(i.payments[0].amount, 0, 0, 0)
490503 
491504 
492505 
493506 @Callable(i)
494507 func addToReserve () = if ((i.payments[0].assetId != assetId))
495508     then throw("can't add interest with unrelated token")
496509     else syncTotals(0, 0, i.payments[0].amount, 0)
497510 
498511 
499512 
500513 @Callable(i)
501514 func withdrawFromReserve (amt) = {
502515     let checks = divAdminOnly(i)
503516     if ((checks == checks))
504517         then {
505518             let diff = if ((amt == -1))
506519                 then claimableDividends
507520                 else amt
508521             $Tuple2((syncTotals(0, 0, -(diff), diff) ++ [ScriptTransfer(i.caller, diff, assetId)]), diff)
509522             }
510523         else throw("Strict value is not equal to itself.")
511524     }
512525 
513526 
514527 
515528 @Callable(i)
516529 func forceUpdate () = {
517530     let admin = valueOrErrorMessage(getString(configAddress, "admin"), "reserve:no admin in config")
518531     if ((toString(i.caller) != admin))
519532         then throw("only admin can do")
520533         else syncTotals(0, 0, 0, 0)
521534     }
522535 
523536 
524537 
525538 @Callable(i)
526539 func initialize (cfgAddress,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
527540     let checks = if (notInitialized)
528541         then isAssetIdOrWaves(assetIdOrWaves)
529542         else false
530543     if ((checks == checks))
531544         then {
532545             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
533546 [aToken, writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken)))]
534547             }
535548         else throw("Strict value is not equal to itself.")
536549     }
537550 
538551 
539552 
540553 @Callable(i)
541554 func initialize2 () = if ((i.caller != this))
542555     then throw("only self can continue")
543556     else [writeInt(lastUpdateHeightStore, HEIGHT)]
544557 
545558 
546559 
547560 @Callable(i)
548561 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
549562 
550563 
551564 
552565 @Callable(i)
553566 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
554567 
555568 
556569 
557570 @Callable(i)
558571 func userBalance (address) = {
559572     let atokens = aTokenBalance(address)
560573     let asset = aTokenToAsset(atokens)
561574     let debt = currentUserDebt(address)
562575     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
563576     }
564577 
565578 
566579 
567580 @Callable(i)
568581 func userDebt (address) = {
569582     let debt = currentUserDebt(address)
570583     let debtUsd = assetToUsd(debt)
571584     $Tuple2(nil, $Tuple2(debt, debtUsd))
572585     }
573586 
574587 
575588 
576589 @Callable(i)
577590 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
578591 
579592 
580593 
581594 @Callable(i)
582595 func repayFor (userAddress) = {
583596     let checks = mainOnly(i)
584597     if ((checks == checks))
585598         then repayUser(userAddress, paymentAmount(i, assetId))
586599         else throw("Strict value is not equal to itself.")
587600     }
588601 
589602 
590603 
591604 @Callable(i)
592605 func depositFor (depositor,useAsCollateral) = {
593606     let checks = if (mainOnly(i))
594607         then opAllowed("deposit")
595608         else false
596609     if ((checks == checks))
597610         then if (if ((currentUserDebt(depositor) > 0))
598611             then !(useAsCollateral)
599612             else false)
600613             then throw("can't disable use as collateral for asset with open debt")
601614             else {
602615                 let amount = paymentAmount(i, assetId)
603616                 let aTokenAmount = assetToAToken(amount)
604617                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
605618                 }
606619         else throw("Strict value is not equal to itself.")
607620     }
608621 
609622 
610623 
611624 @Callable(i)
612625 func withdrawFor (address,amount) = withdrawInternal(i, address, amount, false)
613626 
614627 
615628 
616629 @Callable(i)
617630 func withdrawToMain (user,amount) = if ((amount != -1))
618631     then throw("reserve: withdrawToMain amount -1 only")
619632     else withdrawInternal(i, user, amount, true)
620633 
621634 
622635 
623636 @Callable(i)
624-func replenishWithAtokenFor (user) = {
625-    let checks = if (mainOnly(i))
626-        then opAllowed("atokens")
627-        else false
628-    if ((checks == checks))
629-        then {
630-            let aTokenAmount = paymentAmount(i, aTokenId)
631-            $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
632-            }
633-        else throw("Strict value is not equal to itself.")
634-    }
637+func replenishWithAtokenFor (user) = replenishInternal("replenish_atokens", user, i)
638+
639+
640+
641+@Callable(i)
642+func replenishForRepayWithAtokenFor (user) = replenishInternal("repay_atokens", user, i)
635643 
636644 
637645 
638646 @Callable(i)
639647 func borrowFor (address,amountToBorrow) = {
640648     let checks = if (if (mainOnly(i))
641649         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
642650         else false)
643651         then opAllowed("borrow")
644652         else false
645653     if ((checks == checks))
646654         then {
647655             let currentDebt = currentUserDebt(address)
648656             let newDebt = (currentDebt + amountToBorrow)
649657             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
650658             }
651659         else throw("Strict value is not equal to itself.")
652660     }
653661 
654662 
655663 
656664 @Callable(i)
657665 func mintAtokenFor (address,amountToMint) = {
658666     let userATokenBalance = aTokenBalance(address)
659667     let amount = if ((amountToMint == -1))
660668         then userATokenBalance
661669         else amountToMint
662670     let checks = if (if (if (mainOnly(i))
663-        then opAllowed("atokens")
671+        then opAllowed("mint_atokens")
664672         else false)
665673         then throwIf((-1 > amountToMint), "invalid amountToMint")
666674         else false)
667675         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
668676         else false
669677     if ((checks == checks))
670678         then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
671679         else throw("Strict value is not equal to itself.")
672680     }
673681 
674682 
675683 
676684 @Callable(i)
677685 func redeemAtokensFor (user) = {
678686     let checks = if (mainOnly(i))
679-        then opAllowed("atokens")
687+        then opAllowed("redeem_atokens")
680688         else false
681689     if ((checks == checks))
682690         then {
683691             let aTokenAmount = paymentAmount(i, aTokenId)
684692             let outAmount = aTokenToAsset(aTokenAmount)
685693             $Tuple2((syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(addressFromStringValue(user), outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)]), outAmount)
686694             }
687695         else throw("Strict value is not equal to itself.")
688696     }
689697 
690698 
691699 
692700 @Callable(i)
693701 func transferATokensFor (from,to,valueUsd) = {
694702     let checks = if (mainOnly(i))
695703         then opAllowed("transfer_debt")
696704         else false
697705     if ((checks == checks))
698706         then {
699707             let assets = usdToAsset(valueUsd)
700708             let atokens = assetToAToken(assets)
701709             let aTokensFrom = aTokenBalance(from)
702710             if ((atokens > aTokensFrom))
703711                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
704712                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
705713             }
706714         else throw("Strict value is not equal to itself.")
707715     }
708716 
709717 
710718 
711719 @Callable(i)
712720 func transferDebtFor (from,to,amount) = {
713721     let checks = if (mainOnly(i))
714722         then opAllowed("transfer_debt")
715723         else false
716724     if ((checks == checks))
717725         then $Tuple2((syncTotals(0, 0, 0, 0) ++ [writeInt(debtStore(from), (currentUserDebt(from) - amount)), writeInt(debtStore(to), (currentUserDebt(to) + amount)), writeInt(debtIndexStore(from), currentIndex), writeInt(debtIndexStore(to), currentIndex), enableCol(to)]), amount)
718726         else throw("Strict value is not equal to itself.")
719727     }
720728 
721729 
722730 
723731 @Callable(i)
724732 func disableUseAsCollateralFor (address) = {
725733     let checks = if (mainOnly(i))
726734         then opAllowed("use_as_col")
727735         else false
728736     if ((checks == checks))
729737         then if ((currentUserDebt(address) > 0))
730738             then throw("can't disable collateral for asset with open debt")
731739             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
732740         else throw("Strict value is not equal to itself.")
733741     }
734742 
735743 
736744 
737745 @Callable(i)
738746 func enableUseAsCollateral () = {
739747     let checks = opAllowed("use_as_col")
740748     if ((checks == checks))
741749         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
742750         else throw("Strict value is not equal to itself.")
743751     }
744752 
745753 
746754 
747755 @Callable(i)
748756 func collapseFor (user) = {
749757     let checks = if (mainOnly(i))
750758         then opAllowed("force_collapse")
751759         else false
752760     if ((checks == checks))
753761         then collapseUser(user, -1)
754762         else throw("Strict value is not equal to itself.")
755763     }
756764 
757765 
758766 
759767 @Callable(i)
760768 func collapseForAmount (user,amount) = {
761769     let checks = if (mainOnly(i))
762770         then opAllowed("collapse")
763771         else false
764772     if ((checks == checks))
765773         then collapseUser(user, amount)
766774         else throw("Strict value is not equal to itself.")
767775     }
768776 
769777 
github/deemru/w8io/786bc32 
93.72 ms ◑