2022.05.07 12:05 [3106553] smart account 3PBjqiMwwag72VWUtHNnVrxTBrNK8D7bVcN > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9pDQzVBFoZPSXMMJdZNfUE3hWoLrYsrVzxN6Edb8gqmP",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1651914289613,
    "version": 1,
    "sender": "3PBjqiMwwag72VWUtHNnVrxTBrNK8D7bVcN",
    "senderPublicKey": "5M9sKnq7evAcztZEeWBNJoGsW3Xeygnv1DjCqzBLtPQZ",
    "proofs": [
        "4Ne88cxoVpDusHCV3b6ADQrWLJSaAUMNB3LYDmVbsRopi7hQC46neqnT8LQeaV1yV3P4qbzgbRFtV91k2FbLDopX"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3106553,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Kokfc3pQTk7W4oWGEzXoZVqD923WVRhG7ScZsWuZb42
Next: 6UuBq7sz3c8Yjh5DNqmT3wDS5DRzKA44Jj56bXkE3B4o

Diff: 

OldNewDifferences
1818 func writeInt (key,value) = if ((0 > value))
1919     then throw(((("writing negative value " + toString(value)) + " for key ") + key))
2020     else IntegerEntry(key, value)
21+
22+
23+func asInt (value) = match value {
24+    case int: Int => 
25+        int
26+    case _ => 
27+        throw("1")
28+}
2129 
2230 
2331 func changeBy (key,value) = writeInt(key, (valueOrElse(getI(key), 0) + value))
251259 
252260 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
253261 
254-let claimableDividends = if (stakingEnabled)
255-    then currentTotalReserve
256-    else min([actualBalance, currentTotalReserve])
262+let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
263+
264+let claimableDividends = min([currentTotalReserve, if (stakingEnabled)
265+    then asInt(invoke(stakingAddress, "info", nil, nil))
266+    else actualBalance])
257267 
258268 func paymentAmount (i,assetId) = {
259269     let p = i.payments[0].amount
270280         then unit
271281         else if (!(stakingEnabled))
272282             then unit
273-            else {
274-                let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
275-                if ((actualBalance > keepAtBalance))
276-                    then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
277-                    else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
278-                }
283+            else if ((actualBalance > keepAtBalance))
284+                then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
285+                else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
279286     if ((stakingAction == stakingAction))
280287         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
281288         else throw("Strict value is not equal to itself.")
354361             let currentDebt = currentUserDebt(userAddress)
355362             if ((currentDebt == currentDebt))
356363                 then {
357-                    let $t01118811491 = if ((amount > currentDebt))
364+                    let $t01125511558 = if ((amount > currentDebt))
358365                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
359366                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
360-                    let newDebt = $t01118811491._1
361-                    let totalDebtUpdate = $t01118811491._2
362-                    let payout = $t01118811491._3
363-                    let actions = $t01118811491._4
367+                    let newDebt = $t01125511558._1
368+                    let totalDebtUpdate = $t01125511558._2
369+                    let payout = $t01125511558._3
370+                    let actions = $t01125511558._4
364371                     let repaid = (amount - payout)
365372                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
366373                     }
413420         else false
414421     if ((checks == checks))
415422         then {
416-            let $t01537315564 = if ((amount == -1))
423+            let $t01544015631 = if ((amount == -1))
417424                 then {
418425                     let atokens = aTokenBalance(user)
419426                     $Tuple2(atokens, aTokenToAsset(atokens))
420427                     }
421428                 else $Tuple2(assetToATokenCeil(amount), amount)
422-            let removedAtokens = $t01537315564._1
423-            let withdrawAmount = $t01537315564._2
429+            let removedAtokens = $t01544015631._1
430+            let withdrawAmount = $t01544015631._2
424431             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(if (toMain)
425432                 then mainContract
426433                 else addressFromStringValue(user), withdrawAmount, assetId), changeBy(aTokenBalanceStore(user), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
454461 
455462 @Callable(i)
456463 func getCurrentTotals2 (user1,user2) = {
457-    let $t01649316530 = userTotals(user1)
458-    let d1 = $t01649316530._1
459-    let d2 = $t01649316530._2
460-    let d3 = $t01649316530._3
461-    let d4 = $t01649316530._4
462-    let $t01653516572 = userTotals(user2)
463-    let e1 = $t01653516572._1
464-    let e2 = $t01653516572._2
465-    let e3 = $t01653516572._3
466-    let e4 = $t01653516572._4
464+    let $t01656016597 = userTotals(user1)
465+    let d1 = $t01656016597._1
466+    let d2 = $t01656016597._2
467+    let d3 = $t01656016597._3
468+    let d4 = $t01656016597._4
469+    let $t01660216639 = userTotals(user2)
470+    let e1 = $t01660216639._1
471+    let e2 = $t01660216639._2
472+    let e3 = $t01660216639._3
473+    let e4 = $t01660216639._4
467474     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
468475     }
469476 

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)
21+
22+
23+func asInt (value) = match value {
24+    case int: Int => 
25+        int
26+    case _ => 
27+        throw("1")
28+}
2129 
2230 
2331 func changeBy (key,value) = writeInt(key, (valueOrElse(getI(key), 0) + value))
2432 
2533 
2634 func writeString (key,value) = StringEntry(key, value)
2735 
2836 
2937 func fractionCeil (value,numerator,denominator) = {
3038     let cand = fraction(value, numerator, denominator)
3139     let D = 3037000499
3240     let exact = ((((cand % D) * (denominator % D)) % D) == (((value % D) * (numerator % D)) % D))
3341     if (exact)
3442         then cand
3543         else (cand + 1)
3644     }
3745 
3846 
3947 let BlocksPerYear = 525600
4048 
4149 let RBase = 10000000000000000
4250 
4351 let factorsBase = 1000
4452 
4553 let assetIdStore = "assetId"
4654 
4755 let assetIdStr = valueOrErrorMessage(getS(assetIdStore), "no assetId")
4856 
4957 let assetId = if ((assetIdStr == "WAVES"))
5058     then unit
5159     else fromBase58String(assetIdStr)
5260 
5361 let reserveFactorStore = (assetIdStr + "_ReserveFactor")
5462 
5563 let collateralFactorStore = (assetIdStr + "_CollateralFactor")
5664 
5765 let liquidationThresholdStore = (assetIdStr + "_LiquidationThreshold")
5866 
5967 let overlapChargeStore = "account_health_overlap"
6068 
6169 let liquidationPenaltyStore = (assetIdStr + "_LiquidationPenalty")
6270 
6371 let configAddressStore = "configAddress"
6472 
6573 let aTokenIdStore = "aTokenId"
6674 
6775 let aTokenNameStore = "aTokenName"
6876 
6977 let aTokenCirculationStore = "aTokenCirculation"
7078 
7179 let lastUpdateHeightStore = "lastUpdateHeight"
7280 
7381 let totalDebtStore = "totalBorrow"
7482 
7583 let totalDepositStore = "totalDeposit"
7684 
7785 let totalReserveStore = "totalReserve"
7886 
7987 let indexStore = "storedIndex"
8088 
8189 let aTokenDecimalsStore = "aTokenDecimals"
8290 
8391 func aTokenBalanceStore (userAddress) = (userAddress + "_aTokenBalance")
8492 
8593 
8694 func debtStore (userAddress) = (userAddress + "_debt")
8795 
8896 
8997 func debtIndexStore (userAddress) = (userAddress + "_index")
9098 
9199 
92100 func useAsCollateralStore (userAddress) = (userAddress + "_useAsCollateral")
93101 
94102 
95103 func getBalance (addressOrAlias,assetId) = match assetId {
96104     case bv: ByteVector => 
97105         assetBalance(addressOrAlias, bv)
98106     case u: Unit => 
99107         wavesBalance(addressOrAlias).available
100108     case _ => 
101109         throw("Match error")
102110 }
103111 
104112 
105113 let assetDecimals = valueOrErrorMessage(getI(aTokenDecimalsStore), "no assetDecimals")
106114 
107115 let configAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, configAddressStore), "reserve: no configAddress")), "invalid config address")
108116 
109117 func opAllowed (op) = match invoke(configAddress, "opAllowed", [assetIdStr, op], nil) {
110118     case b: Boolean => 
111119         if (b)
112120             then true
113121             else throw("not allowed")
114122     case _ => 
115123         throw("opAllowed: unexpected result type")
116124 }
117125 
118126 
119127 let mainContract = valueOrErrorMessage(addressFromString(split(valueOrErrorMessage(getString(configAddress, "main"), "no main in config"), "|")[0]), "invalid main address")
120128 
121129 func mainOnly (i) = if (contains(getStringValue(configAddress, "main"), toString(i.caller)))
122130     then true
123131     else throw("only main can do")
124132 
125133 
126134 func divAdminOnly (i) = {
127135     let divAdmins = valueOrErrorMessage(getString(configAddress, "divAdmins"), "no div admins")
128136     if (!(contains(divAdmins, toString(i.caller))))
129137         then throw("only div admin can do")
130138         else true
131139     }
132140 
133141 
134142 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
135143     then (fromBase58String(value) == fromBase58String(""))
136144     else false)
137145     then throw("invalid assetId")
138146     else true
139147 
140148 
141149 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
142150 
143151 let maybeOracleAddress = match getString(configAddress, "oracle_address") {
144152     case s: String => 
145153         addressFromString(s)
146154     case _ => 
147155         unit
148156 }
149157 
150158 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [assetIdStr], nil) {
151159     case i: Int => 
152160         i
153161     case _ => 
154162         throw("bad oracle data")
155163 }
156164 
157165 let HEIGHT = height
158166 
159167 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
160168 
161169 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
162170 
163171 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
164172 
165173 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
166174 
167175 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
168176 
169177 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
170178 
171179 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
172180 
173181 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
174182 
175183 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
176184 
177185 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
178186 
179187 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
180188 
181189 let storedIndex = valueOrElse(getI(indexStore), RBase)
182190 
183191 let utilization = if ((storedTotalDeposit > 0))
184192     then min([factorsBase, fraction(storedTotalDebt, factorsBase, storedTotalDeposit)])
185193     else 0
186194 
187195 let apr = {
188196     let a = getIntegerValue(configAddress, (assetIdStr + "_APoint"))
189197     let b = getIntegerValue(configAddress, (assetIdStr + "_BPoint"))
190198     let c = getIntegerValue(configAddress, (assetIdStr + "_CPoint"))
191199     let d = getIntegerValue(configAddress, (assetIdStr + "_DPoint"))
192200     let lineAC = (fraction((a - c), utilization, -(b)) + a)
193201     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
194202     if ((utilization == 0))
195203         then a
196204         else if ((utilization == b))
197205             then c
198206             else if (if ((b > utilization))
199207                 then true
200208                 else (b == factorsBase))
201209                 then lineAC
202210                 else lineCD
203211     }
204212 
205213 let apy = if ((storedTotalDeposit == 0))
206214     then 0
207215     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
208216 
209217 let currentIndex = if ((HEIGHT == lastUpdateHeight))
210218     then storedIndex
211219     else {
212220         let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
213221         fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
214222         }
215223 
216224 let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
217225 
218226 let actualBalance = match assetId {
219227     case aid: ByteVector => 
220228         assetBalance(this, aid)
221229     case _ => 
222230         wavesBalance(this).available
223231 }
224232 
225233 func liquidityCheck (amount,max,err) = if ((amount > max))
226234     then throw(("not enough liquidity: " + err))
227235     else true
228236 
229237 
230238 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
231239 
232240 
233241 func currentUserDebt (userAddress) = {
234242     let v = storedUserDebt(userAddress)
235243     if ((v == 0))
236244         then 0
237245         else {
238246             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
239247             fraction(v, currentIndex, storedUserIndex)
240248             }
241249     }
242250 
243251 
244252 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
245253 
246254 let addedDebt = (currentTotalDebt - storedTotalDebt)
247255 
248256 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
249257 
250258 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
251259 
252260 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
253261 
254-let claimableDividends = if (stakingEnabled)
255-    then currentTotalReserve
256-    else min([actualBalance, currentTotalReserve])
262+let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
263+
264+let claimableDividends = min([currentTotalReserve, if (stakingEnabled)
265+    then asInt(invoke(stakingAddress, "info", nil, nil))
266+    else actualBalance])
257267 
258268 func paymentAmount (i,assetId) = {
259269     let p = i.payments[0].amount
260270     if ((0 >= p))
261271         then throw(("Payment is less than min allowed amount: " + toString(p)))
262272         else if ((i.payments[0].assetId != assetId))
263273             then throw((" bad asset attached: required " + assetIdStr))
264274             else p
265275     }
266276 
267277 
268278 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
269279     let stakingAction = if ((actualBalance == keepAtBalance))
270280         then unit
271281         else if (!(stakingEnabled))
272282             then unit
273-            else {
274-                let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
275-                if ((actualBalance > keepAtBalance))
276-                    then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
277-                    else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
278-                }
283+            else if ((actualBalance > keepAtBalance))
284+                then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
285+                else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
279286     if ((stakingAction == stakingAction))
280287         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
281288         else throw("Strict value is not equal to itself.")
282289     }
283290 
284291 
285292 func pow10 (n) = if ((n == 6))
286293     then 1000000
287294     else if ((n == 8))
288295         then 100000000
289296         else throw(("bad decimals: " + toString(n)))
290297 
291298 
292299 func assetToUsd (amount) = fraction(amount, oraclePrice, pow10(assetDecimals))
293300 
294301 
295302 func usdToAsset (amount) = fraction(amount, pow10(assetDecimals), oraclePrice)
296303 
297304 
298305 func aTokenToAsset (aTokenAmount) = if ((aTokenAmount == 0))
299306     then 0
300307     else if ((aTokenCirculation > 0))
301308         then fraction(aTokenAmount, currentTotalDeposit, aTokenCirculation)
302309         else aTokenAmount
303310 
304311 
305312 func assetToAToken (assetAmount) = if ((assetAmount == 0))
306313     then 0
307314     else if ((aTokenCirculation > 0))
308315         then fraction(assetAmount, aTokenCirculation, currentTotalDeposit)
309316         else assetAmount
310317 
311318 
312319 func assetToATokenCeil (assetAmount) = if ((assetAmount == 0))
313320     then 0
314321     else if ((aTokenCirculation > 0))
315322         then fractionCeil(assetAmount, aTokenCirculation, currentTotalDeposit)
316323         else assetAmount
317324 
318325 
319326 func aTokenBalance (address) = valueOrElse(getI(aTokenBalanceStore(address)), 0)
320327 
321328 
322329 func enableCol (user) = BooleanEntry(useAsCollateralStore(user), true)
323330 
324331 
325332 func enableColIfNeeded (user) = if ((currentUserDebt(user) > 0))
326333     then [enableCol(user)]
327334     else nil
328335 
329336 
330337 func collapseUser (address,amount) = {
331338     let debt = currentUserDebt(address)
332339     let deposit = aTokenToAsset(aTokenBalance(address))
333340     let maxPossible = min([debt, deposit])
334341     let amt = if ((-1 > amount))
335342         then throw("invalid collapse amount")
336343         else if (if ((maxPossible == 0))
337344             then true
338345             else (amount == 0))
339346             then throw("nothing to collapse")
340347             else if (if ((amount == -1))
341348                 then true
342349                 else (amount > maxPossible))
343350                 then maxPossible
344351                 else amount
345352     let removedAtokens = assetToATokenCeil(amt)
346353     $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
347354     }
348355 
349356 
350357 func repayUser (userAddress,amount) = {
351358     let checks = opAllowed("repay")
352359     if ((checks == checks))
353360         then {
354361             let currentDebt = currentUserDebt(userAddress)
355362             if ((currentDebt == currentDebt))
356363                 then {
357-                    let $t01118811491 = if ((amount > currentDebt))
364+                    let $t01125511558 = if ((amount > currentDebt))
358365                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
359366                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
360-                    let newDebt = $t01118811491._1
361-                    let totalDebtUpdate = $t01118811491._2
362-                    let payout = $t01118811491._3
363-                    let actions = $t01118811491._4
367+                    let newDebt = $t01125511558._1
368+                    let totalDebtUpdate = $t01125511558._2
369+                    let payout = $t01125511558._3
370+                    let actions = $t01125511558._4
364371                     let repaid = (amount - payout)
365372                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
366373                     }
367374                 else throw("Strict value is not equal to itself.")
368375             }
369376         else throw("Strict value is not equal to itself.")
370377     }
371378 
372379 
373380 func getConfig () = {
374381     let a = getIntegerValue(configAddress, (assetIdStr + "_APoint"))
375382     let b = getIntegerValue(configAddress, (assetIdStr + "_BPoint"))
376383     let c = getIntegerValue(configAddress, (assetIdStr + "_CPoint"))
377384     let d = getIntegerValue(configAddress, (assetIdStr + "_DPoint"))
378385     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
379386     }
380387 
381388 
382389 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))
383390 
384391 
385392 func getUserState (user) = {
386393     let aBalance = aTokenBalance(user)
387394     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
388395     ((((((((((((((((("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)))
389396     }
390397 
391398 
392399 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))))
393400 
394401 
395402 func userTotals (user) = {
396403     let atokens = aTokenBalance(user)
397404     let asset = aTokenToAsset(atokens)
398405     let debt = currentUserDebt(user)
399406     if ((HEIGHT == lastUpdateHeight))
400407         then $Tuple4(storedTotalDeposit, storedTotalDebt, asset, debt)
401408         else $Tuple4(currentTotalDeposit, currentTotalDebt, asset, debt)
402409     }
403410 
404411 
405412 func withdrawInternal (i,user,amount,toMain) = {
406413     let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
407414     let checks = if (if (if (mainOnly(i))
408415         then liquidityCheck(amount, maxWithdraw, ("funds in use: max=" + toString(maxWithdraw)))
409416         else false)
410417         then throwIf((-1 > amount), "invalid amount")
411418         else false)
412419         then opAllowed("withdraw")
413420         else false
414421     if ((checks == checks))
415422         then {
416-            let $t01537315564 = if ((amount == -1))
423+            let $t01544015631 = if ((amount == -1))
417424                 then {
418425                     let atokens = aTokenBalance(user)
419426                     $Tuple2(atokens, aTokenToAsset(atokens))
420427                     }
421428                 else $Tuple2(assetToATokenCeil(amount), amount)
422-            let removedAtokens = $t01537315564._1
423-            let withdrawAmount = $t01537315564._2
429+            let removedAtokens = $t01544015631._1
430+            let withdrawAmount = $t01544015631._2
424431             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(if (toMain)
425432                 then mainContract
426433                 else addressFromStringValue(user), withdrawAmount, assetId), changeBy(aTokenBalanceStore(user), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
427434             }
428435         else throw("Strict value is not equal to itself.")
429436     }
430437 
431438 
432439 func replenishInternal (op,user,i) = {
433440     let checks = if (mainOnly(i))
434441         then opAllowed(op)
435442         else false
436443     if ((checks == checks))
437444         then {
438445             let aTokenAmount = paymentAmount(i, aTokenId)
439446             $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
440447             }
441448         else throw("Strict value is not equal to itself.")
442449     }
443450 
444451 
445452 @Callable(i)
446453 func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(claimableDividends, assetIdStr, (currentTotalReserve - claimableDividends)))
447454 
448455 
449456 
450457 @Callable(i)
451458 func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
452459 
453460 
454461 
455462 @Callable(i)
456463 func getCurrentTotals2 (user1,user2) = {
457-    let $t01649316530 = userTotals(user1)
458-    let d1 = $t01649316530._1
459-    let d2 = $t01649316530._2
460-    let d3 = $t01649316530._3
461-    let d4 = $t01649316530._4
462-    let $t01653516572 = userTotals(user2)
463-    let e1 = $t01653516572._1
464-    let e2 = $t01653516572._2
465-    let e3 = $t01653516572._3
466-    let e4 = $t01653516572._4
464+    let $t01656016597 = userTotals(user1)
465+    let d1 = $t01656016597._1
466+    let d2 = $t01656016597._2
467+    let d3 = $t01656016597._3
468+    let d4 = $t01656016597._4
469+    let $t01660216639 = userTotals(user2)
470+    let e1 = $t01660216639._1
471+    let e2 = $t01660216639._2
472+    let e3 = $t01660216639._3
473+    let e4 = $t01660216639._4
467474     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
468475     }
469476 
470477 
471478 
472479 @Callable(i)
473480 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
474481 
475482 
476483 
477484 @Callable(i)
478485 func adviseUser (user) = {
479486     let currentDebtUsd = assetToUsd(currentTotalDebt)
480487     let currentDepositUsd = assetToUsd(currentTotalDeposit)
481488     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
482489     let effectiveDepositUsd = if (asCollateral)
483490         then currentDepositUsd
484491         else 0
485492     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
486493     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
487494     let bp = if ((currentDebtUsd > effectiveDepositUsd))
488495         then 0
489496         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
490497     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
491498         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
492499         else overlapCharge
493500     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
494501     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
495502     }
496503 
497504 
498505 
499506 @Callable(i)
500507 func addInterest () = if ((i.payments[0].assetId != assetId))
501508     then throw("can't add interest with unrelated token")
502509     else syncTotals(i.payments[0].amount, 0, 0, 0)
503510 
504511 
505512 
506513 @Callable(i)
507514 func addToReserve () = if ((i.payments[0].assetId != assetId))
508515     then throw("can't add interest with unrelated token")
509516     else syncTotals(0, 0, i.payments[0].amount, 0)
510517 
511518 
512519 
513520 @Callable(i)
514521 func withdrawFromReserve (amt) = {
515522     let checks = divAdminOnly(i)
516523     if ((checks == checks))
517524         then {
518525             let diff = if ((amt == -1))
519526                 then claimableDividends
520527                 else amt
521528             $Tuple2((syncTotals(0, 0, -(diff), diff) ++ [ScriptTransfer(i.caller, diff, assetId)]), diff)
522529             }
523530         else throw("Strict value is not equal to itself.")
524531     }
525532 
526533 
527534 
528535 @Callable(i)
529536 func forceUpdate () = {
530537     let admin = valueOrErrorMessage(getString(configAddress, "admin"), "reserve:no admin in config")
531538     if ((toString(i.caller) != admin))
532539         then throw("only admin can do")
533540         else syncTotals(0, 0, 0, 0)
534541     }
535542 
536543 
537544 
538545 @Callable(i)
539546 func initialize (cfgAddress,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
540547     let checks = if (notInitialized)
541548         then isAssetIdOrWaves(assetIdOrWaves)
542549         else false
543550     if ((checks == checks))
544551         then {
545552             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
546553 [aToken, writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken)))]
547554             }
548555         else throw("Strict value is not equal to itself.")
549556     }
550557 
551558 
552559 
553560 @Callable(i)
554561 func initialize2 () = if ((i.caller != this))
555562     then throw("only self can continue")
556563     else [writeInt(lastUpdateHeightStore, HEIGHT)]
557564 
558565 
559566 
560567 @Callable(i)
561568 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
562569 
563570 
564571 
565572 @Callable(i)
566573 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
567574 
568575 
569576 
570577 @Callable(i)
571578 func userBalance (address) = {
572579     let atokens = aTokenBalance(address)
573580     let asset = aTokenToAsset(atokens)
574581     let debt = currentUserDebt(address)
575582     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
576583     }
577584 
578585 
579586 
580587 @Callable(i)
581588 func userDebt (address) = {
582589     let debt = currentUserDebt(address)
583590     let debtUsd = assetToUsd(debt)
584591     $Tuple2(nil, $Tuple2(debt, debtUsd))
585592     }
586593 
587594 
588595 
589596 @Callable(i)
590597 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
591598 
592599 
593600 
594601 @Callable(i)
595602 func repayFor (userAddress) = {
596603     let checks = mainOnly(i)
597604     if ((checks == checks))
598605         then repayUser(userAddress, paymentAmount(i, assetId))
599606         else throw("Strict value is not equal to itself.")
600607     }
601608 
602609 
603610 
604611 @Callable(i)
605612 func depositFor (depositor,useAsCollateral) = {
606613     let checks = if (mainOnly(i))
607614         then opAllowed("deposit")
608615         else false
609616     if ((checks == checks))
610617         then if (if ((currentUserDebt(depositor) > 0))
611618             then !(useAsCollateral)
612619             else false)
613620             then throw("can't disable use as collateral for asset with open debt")
614621             else {
615622                 let amount = paymentAmount(i, assetId)
616623                 let aTokenAmount = assetToAToken(amount)
617624                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
618625                 }
619626         else throw("Strict value is not equal to itself.")
620627     }
621628 
622629 
623630 
624631 @Callable(i)
625632 func withdrawFor (address,amount) = withdrawInternal(i, address, amount, false)
626633 
627634 
628635 
629636 @Callable(i)
630637 func withdrawToMain (user,amount) = if ((amount != -1))
631638     then throw("reserve: withdrawToMain amount -1 only")
632639     else withdrawInternal(i, user, amount, true)
633640 
634641 
635642 
636643 @Callable(i)
637644 func replenishWithAtokenFor (user) = replenishInternal("replenish_atokens", user, i)
638645 
639646 
640647 
641648 @Callable(i)
642649 func replenishForRepayWithAtokenFor (user) = replenishInternal("repay_atokens", user, i)
643650 
644651 
645652 
646653 @Callable(i)
647654 func borrowFor (address,amountToBorrow) = {
648655     let checks = if (if (mainOnly(i))
649656         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
650657         else false)
651658         then opAllowed("borrow")
652659         else false
653660     if ((checks == checks))
654661         then {
655662             let currentDebt = currentUserDebt(address)
656663             let newDebt = (currentDebt + amountToBorrow)
657664             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
658665             }
659666         else throw("Strict value is not equal to itself.")
660667     }
661668 
662669 
663670 
664671 @Callable(i)
665672 func mintAtokenFor (address,amountToMint) = {
666673     let userATokenBalance = aTokenBalance(address)
667674     let amount = if ((amountToMint == -1))
668675         then userATokenBalance
669676         else amountToMint
670677     let checks = if (if (if (mainOnly(i))
671678         then opAllowed("mint_atokens")
672679         else false)
673680         then throwIf((-1 > amountToMint), "invalid amountToMint")
674681         else false)
675682         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
676683         else false
677684     if ((checks == checks))
678685         then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
679686         else throw("Strict value is not equal to itself.")
680687     }
681688 
682689 
683690 
684691 @Callable(i)
685692 func redeemAtokensFor (user) = {
686693     let checks = if (mainOnly(i))
687694         then opAllowed("redeem_atokens")
688695         else false
689696     if ((checks == checks))
690697         then {
691698             let aTokenAmount = paymentAmount(i, aTokenId)
692699             let outAmount = aTokenToAsset(aTokenAmount)
693700             $Tuple2((syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(addressFromStringValue(user), outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)]), outAmount)
694701             }
695702         else throw("Strict value is not equal to itself.")
696703     }
697704 
698705 
699706 
700707 @Callable(i)
701708 func transferATokensFor (from,to,valueUsd) = {
702709     let checks = if (mainOnly(i))
703710         then opAllowed("transfer_debt")
704711         else false
705712     if ((checks == checks))
706713         then {
707714             let assets = usdToAsset(valueUsd)
708715             let atokens = assetToAToken(assets)
709716             let aTokensFrom = aTokenBalance(from)
710717             if ((atokens > aTokensFrom))
711718                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
712719                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
713720             }
714721         else throw("Strict value is not equal to itself.")
715722     }
716723 
717724 
718725 
719726 @Callable(i)
720727 func transferDebtFor (from,to,amount) = {
721728     let checks = if (mainOnly(i))
722729         then opAllowed("transfer_debt")
723730         else false
724731     if ((checks == checks))
725732         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)
726733         else throw("Strict value is not equal to itself.")
727734     }
728735 
729736 
730737 
731738 @Callable(i)
732739 func disableUseAsCollateralFor (address) = {
733740     let checks = if (mainOnly(i))
734741         then opAllowed("use_as_col")
735742         else false
736743     if ((checks == checks))
737744         then if ((currentUserDebt(address) > 0))
738745             then throw("can't disable collateral for asset with open debt")
739746             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
740747         else throw("Strict value is not equal to itself.")
741748     }
742749 
743750 
744751 
745752 @Callable(i)
746753 func enableUseAsCollateral () = {
747754     let checks = opAllowed("use_as_col")
748755     if ((checks == checks))
749756         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
750757         else throw("Strict value is not equal to itself.")
751758     }
752759 
753760 
754761 
755762 @Callable(i)
756763 func collapseFor (user) = {
757764     let checks = if (mainOnly(i))
758765         then opAllowed("force_collapse")
759766         else false
760767     if ((checks == checks))
761768         then collapseUser(user, -1)
762769         else throw("Strict value is not equal to itself.")
763770     }
764771 
765772 
766773 
767774 @Callable(i)
768775 func collapseForAmount (user,amount) = {
769776     let checks = if (mainOnly(i))
770777         then opAllowed("collapse")
771778         else false
772779     if ((checks == checks))
773780         then collapseUser(user, amount)
774781         else throw("Strict value is not equal to itself.")
775782     }
776783 
777784 
github/deemru/w8io/786bc32 
93.71 ms ◑