2021.07.18 15:48 [2683837] smart account 3PEiD1zJWTMZNWSCyzhvBw9pxxAWeEwaghR > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Bsgt5FKt768dWF81ZyqrmKgYb2ULE46uS3VKPhtSmKDH",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1626612446547,
    "version": 1,
    "sender": "3PEiD1zJWTMZNWSCyzhvBw9pxxAWeEwaghR",
    "senderPublicKey": "41uiA5UF2zu2zsaRWQJU9G9dt3n9imXQLui4s78uBZK3",
    "proofs": [
        "22sseQkFyiyhCtYrdiLsTUNJ3aG6UBDyPRqD7pAmxfjvuVsD5CPaxkz3tgRdAn26qAcbj9u1oRbcgy8fwf1NjY4P"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2683837,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 2M3TmHE5cs7hYTV22CDEvt1uYJbEf8GcSqP7wEnyeZmp
Next: 68ECs4rvuPvMGEycHYKLjSfJx5MFUjcAkUmUb4Qxg6Kr

Diff: 

OldNewDifferences
5151 let collateralFactorStore = (getSV(assetIdStore) + "_CollateralFactor")
5252 
5353 let liquidationThresholdStore = (getStringValue(assetIdStore) + "_LiquidationThreshold")
54+
55+let overlapChargeStore = "account_health_overlap"
5456 
5557 let liquidationPenaltyStore = (getStringValue(assetIdStore) + "_LiquidationPenalty")
5658 
178180 
179181 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
180182 
183+let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
184+
181185 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
182186 
183187 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
193197     else 0
194198 
195199 let apr = {
196-    let $t053655385 = ABCD
197-    let a = $t053655385._1
198-    let b = $t053655385._2
199-    let c = $t053655385._3
200-    let d = $t053655385._4
200+    let $t055315551 = ABCD
201+    let a = $t055315551._1
202+    let b = $t055315551._2
203+    let c = $t055315551._3
204+    let d = $t055315551._4
201205     let lineAC = (fraction((a - c), utilization, -(b)) + a)
202206     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
203207     if ((utilization == 0))
351355 
352356 
353357 func getConfig () = {
354-    let $t01041610436 = ABCD
355-    let a = $t01041610436._1
356-    let b = $t01041610436._2
357-    let c = $t01041610436._3
358-    let d = $t01041610436._4
358+    let $t01058210602 = ABCD
359+    let a = $t01058210602._1
360+    let b = $t01058210602._2
361+    let c = $t01058210602._3
362+    let d = $t01058210602._4
359363     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
360364     }
361365 
371375 
372376 
373377 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))))
378+
379+
380+@Callable(i)
381+func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
382+
383+
384+
385+@Callable(i)
386+func adviseUser (user) = {
387+    let currentDebtUsd = assetToUsd(currentTotalDebt)
388+    let currentDepositUsd = assetToUsd(currentTotalDeposit)
389+    let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
390+    let effectiveDepositUsd = if (asCollateral)
391+        then currentDepositUsd
392+        else 0
393+    let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
394+    let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
395+    let bp = if ((currentDebtUsd > effectiveDepositUsd))
396+        then 0
397+        else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
398+    let bpu = if ((currentDebtUsd > effectiveDepositUsd))
399+        then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
400+        else overlapCharge
401+    let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
402+    $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
403+    }
404+
374405 
375406 
376407 @Callable(i)
466497             let currentDebt = currentUserDebt(userAddress)
467498             if ((currentDebt == currentDebt))
468499                 then {
469-                    let $t01570515981 = if ((amount > currentDebt))
500+                    let $t01707117347 = if ((amount > currentDebt))
470501                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(i.caller, (amount - currentDebt), assetId)])
471502                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
472-                    let newDebt = $t01570515981._1
473-                    let totalDebtUpdate = $t01570515981._2
474-                    let payout = $t01570515981._3
475-                    let actions = $t01570515981._4
503+                    let newDebt = $t01707117347._1
504+                    let totalDebtUpdate = $t01707117347._2
505+                    let payout = $t01707117347._3
506+                    let actions = $t01707117347._4
476507                     ((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)])
477508                     }
478509                 else throw("Strict value is not equal to itself.")
579610         else false
580611     if ((checks == checks))
581612         then {
582-            let $t01915419348 = if ((amount == -1))
613+            let $t02052020714 = if ((amount == -1))
583614                 then {
584615                     let atokens = aTokenBalance(address)
585616                     $Tuple2(atokens, aTokenToAsset(atokens))
586617                     }
587618                 else $Tuple2(assetToATokenCeil(amount), amount)
588-            let removedAtokens = $t01915419348._1
589-            let withdrawAmount = $t01915419348._2
619+            let removedAtokens = $t02052020714._1
620+            let withdrawAmount = $t02052020714._2
590621             (syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))])
591622             }
592623         else throw("Strict value is not equal to itself.")

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) = value(getString(this, key))
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 mainStore = "main"
4848 
4949 let reserveFactorStore = (getSV(assetIdStore) + "_ReserveFactor")
5050 
5151 let collateralFactorStore = (getSV(assetIdStore) + "_CollateralFactor")
5252 
5353 let liquidationThresholdStore = (getStringValue(assetIdStore) + "_LiquidationThreshold")
54+
55+let overlapChargeStore = "account_health_overlap"
5456 
5557 let liquidationPenaltyStore = (getStringValue(assetIdStore) + "_LiquidationPenalty")
5658 
5759 let configAddressStore = "configAddress"
5860 
5961 let oracleStore = "oracleAddress"
6062 
6163 let aTokenIdStore = "aTokenId"
6264 
6365 let aTokenNameStore = "aTokenName"
6466 
6567 let aTokenCirculationStore = "aTokenCirculation"
6668 
6769 let lastUpdateHeightStore = "lastUpdateHeight"
6870 
6971 let totalDebtStore = "totalBorrow"
7072 
7173 let totalDepositStore = "totalDeposit"
7274 
7375 let totalReserveStore = "totalReserve"
7476 
7577 let indexStore = "storedIndex"
7678 
7779 let aTokenDecimalsStore = "aTokenDecimals"
7880 
7981 func aTokenBalanceStore (userAddress) = (userAddress + "_aTokenBalance")
8082 
8183 
8284 func debtStore (userAddress) = (userAddress + "_debt")
8385 
8486 
8587 func debtIndexStore (userAddress) = (userAddress + "_index")
8688 
8789 
8890 func useAsCollateralStore (userAddress) = (userAddress + "_useAsCollateral")
8991 
9092 
9193 let assetId = {
9294     let id = valueOrErrorMessage(getS(assetIdStore), "no assetId")
9395     if ((id == "WAVES"))
9496         then unit
9597         else fromBase58String(id)
9698     }
9799 
98100 let assetIdStr = match assetId {
99101     case bv: ByteVector => 
100102         toBase58String(bv)
101103     case u: Unit => 
102104         "WAVES"
103105     case _ => 
104106         throw("Match error")
105107 }
106108 
107109 func getBalance (addressOrAlias,assetId) = match assetId {
108110     case bv: ByteVector => 
109111         assetBalance(addressOrAlias, bv)
110112     case u: Unit => 
111113         wavesBalance(addressOrAlias).available
112114     case _ => 
113115         throw("Match error")
114116 }
115117 
116118 
117119 let assetDecimals = valueOrErrorMessage(getI(aTokenDecimalsStore), "no assetDecimals")
118120 
119121 let configAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getS(configAddressStore), "no configAddress")), "invalid config address")
120122 
121123 func opAllowed (op) = {
122124     let aid = valueOrErrorMessage(getS(assetIdStore), "no assetId")
123125     match invoke(configAddress, "opAllowed", [aid, op], nil) {
124126         case b: Boolean => 
125127             if (b)
126128                 then true
127129                 else throw("not allowed")
128130         case _ => 
129131             throw("opAllowed: unexpected result type")
130132     }
131133     }
132134 
133135 
134136 func mainOnly (i) = if ((i.caller != valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")))
135137     then throw("only main can do")
136138     else true
137139 
138140 
139141 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
140142     then (fromBase58String(value) == fromBase58String(""))
141143     else false)
142144     then throw("invalid assetId")
143145     else true
144146 
145147 
146148 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
147149 
148150 let maybeOracleAddress = match getS(oracleStore) {
149151     case s: String => 
150152         addressFromString(s)
151153     case _ => 
152154         unit
153155 }
154156 
155157 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [getSV(assetIdStore)], nil) {
156158     case i: Int => 
157159         i
158160     case _ => 
159161         throw("bad oracle data")
160162 }
161163 
162164 let HEIGHT = height
163165 
164166 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
165167 
166168 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
167169 
168170 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
169171 
170172 let ABCD = {
171173     let id = getSV(assetIdStore)
172174     $Tuple4(getIntegerValue(configAddress, (id + "_APoint")), getIntegerValue(configAddress, (id + "_BPoint")), getIntegerValue(configAddress, (id + "_CPoint")), getIntegerValue(configAddress, (id + "_DPoint")))
173175     }
174176 
175177 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
176178 
177179 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
178180 
179181 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
180182 
183+let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
184+
181185 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
182186 
183187 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
184188 
185189 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
186190 
187191 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
188192 
189193 let storedIndex = valueOrElse(getI(indexStore), RBase)
190194 
191195 let utilization = if ((storedTotalDeposit > 0))
192196     then fraction(storedTotalDebt, factorsBase, storedTotalDeposit)
193197     else 0
194198 
195199 let apr = {
196-    let $t053655385 = ABCD
197-    let a = $t053655385._1
198-    let b = $t053655385._2
199-    let c = $t053655385._3
200-    let d = $t053655385._4
200+    let $t055315551 = ABCD
201+    let a = $t055315551._1
202+    let b = $t055315551._2
203+    let c = $t055315551._3
204+    let d = $t055315551._4
201205     let lineAC = (fraction((a - c), utilization, -(b)) + a)
202206     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
203207     if ((utilization == 0))
204208         then a
205209         else if ((utilization == b))
206210             then c
207211             else if (if ((b > utilization))
208212                 then true
209213                 else (b == factorsBase))
210214                 then lineAC
211215                 else lineCD
212216     }
213217 
214218 let apy = if ((storedTotalDeposit == 0))
215219     then 0
216220     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
217221 
218222 let currentIndex = {
219223     let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
220224     fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
221225     }
222226 
223227 func liquidityCheck (amount,max,err) = if ((amount > max))
224228     then throw(("not enough liquidity: " + err))
225229     else true
226230 
227231 
228232 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
229233 
230234 
231235 func currentUserDebt (userAddress) = {
232236     let v = storedUserDebt(userAddress)
233237     if ((v == 0))
234238         then 0
235239         else {
236240             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
237241             fraction(v, currentIndex, storedUserIndex)
238242             }
239243     }
240244 
241245 
242246 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
243247 
244248 let addedDebt = (currentTotalDebt - storedTotalDebt)
245249 
246250 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
247251 
248252 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
249253 
250254 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
251255 
252256 func paymentAmount (i,assetId) = {
253257     let p = i.payments[0].amount
254258     if ((0 >= p))
255259         then throw("Payment is less than min allowed amount")
256260         else if ((i.payments[0].assetId != assetId))
257261             then throw(("bad asset attached: required " + assetIdStr))
258262             else p
259263     }
260264 
261265 
262266 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
263267     let actualBalance =     match assetId {
264268         case aid: ByteVector => 
265269             assetBalance(this, aid)
266270         case _ => 
267271             wavesBalance(this).available
268272     }
269273     let stakingAction = if ((actualBalance == keepAtBalance))
270274         then unit
271275         else {
272276             let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
273277             if (!(stakingEnabled))
274278                 then unit
275279                 else {
276280                     let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
277281                     if ((actualBalance > keepAtBalance))
278282                         then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
279283                         else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
280284                     }
281285             }
282286     if ((stakingAction == stakingAction))
283287         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
284288         else throw("Strict value is not equal to itself.")
285289     }
286290 
287291 
288292 func pow10 (n) = if ((n == 6))
289293     then 1000000
290294     else if ((n == 8))
291295         then 100000000
292296         else throw(("bad decimals: " + toString(n)))
293297 
294298 
295299 func assetToUsd (amount) = fraction(amount, oraclePrice, pow10(assetDecimals))
296300 
297301 
298302 func usdToAsset (amount) = fraction(amount, pow10(assetDecimals), oraclePrice)
299303 
300304 
301305 func aTokenToAsset (aTokenAmount) = if ((aTokenAmount == 0))
302306     then 0
303307     else if ((aTokenCirculation > 0))
304308         then fraction(aTokenAmount, currentTotalDeposit, aTokenCirculation)
305309         else aTokenAmount
306310 
307311 
308312 func assetToAToken (assetAmount) = if ((assetAmount == 0))
309313     then 0
310314     else if ((aTokenCirculation > 0))
311315         then fraction(assetAmount, aTokenCirculation, currentTotalDeposit)
312316         else assetAmount
313317 
314318 
315319 func assetToATokenCeil (assetAmount) = if ((assetAmount == 0))
316320     then 0
317321     else if ((aTokenCirculation > 0))
318322         then fractionCeil(assetAmount, aTokenCirculation, currentTotalDeposit)
319323         else assetAmount
320324 
321325 
322326 func aTokenBalance (address) = valueOrElse(getI(aTokenBalanceStore(address)), 0)
323327 
324328 
325329 func enableCol (user) = BooleanEntry(useAsCollateralStore(user), true)
326330 
327331 
328332 func enableColIfNeeded (user) = if ((currentUserDebt(user) > 0))
329333     then [enableCol(user)]
330334     else nil
331335 
332336 
333337 func collapseUser (address,amount) = {
334338     let debt = currentUserDebt(address)
335339     let deposit = aTokenToAsset(aTokenBalance(address))
336340     let maxPossible = min([debt, deposit])
337341     let amt = if ((-1 > amount))
338342         then throw("invalid collapse amount")
339343         else if (if ((maxPossible == 0))
340344             then true
341345             else (amount == 0))
342346             then throw("nothing to collapse")
343347             else if (if ((amount == -1))
344348                 then true
345349                 else (amount > maxPossible))
346350                 then maxPossible
347351                 else amount
348352     let removedAtokens = assetToATokenCeil(amt)
349353     (syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)])
350354     }
351355 
352356 
353357 func getConfig () = {
354-    let $t01041610436 = ABCD
355-    let a = $t01041610436._1
356-    let b = $t01041610436._2
357-    let c = $t01041610436._3
358-    let d = $t01041610436._4
358+    let $t01058210602 = ABCD
359+    let a = $t01058210602._1
360+    let b = $t01058210602._2
361+    let c = $t01058210602._3
362+    let d = $t01058210602._4
359363     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
360364     }
361365 
362366 
363367 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))
364368 
365369 
366370 func getUserState (user) = {
367371     let aBalance = aTokenBalance(user)
368372     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
369373     ((((((((((((((((("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)))
370374     }
371375 
372376 
373377 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))))
378+
379+
380+@Callable(i)
381+func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
382+
383+
384+
385+@Callable(i)
386+func adviseUser (user) = {
387+    let currentDebtUsd = assetToUsd(currentTotalDebt)
388+    let currentDepositUsd = assetToUsd(currentTotalDeposit)
389+    let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
390+    let effectiveDepositUsd = if (asCollateral)
391+        then currentDepositUsd
392+        else 0
393+    let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
394+    let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
395+    let bp = if ((currentDebtUsd > effectiveDepositUsd))
396+        then 0
397+        else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
398+    let bpu = if ((currentDebtUsd > effectiveDepositUsd))
399+        then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
400+        else overlapCharge
401+    let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
402+    $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
403+    }
404+
374405 
375406 
376407 @Callable(i)
377408 func addInterest () = if ((i.payments[0].assetId != assetId))
378409     then throw("can't add interest with unrelated token")
379410     else syncTotals(i.payments[0].amount, 0, 0, 0)
380411 
381412 
382413 
383414 @Callable(i)
384415 func addToReserve () = if ((i.payments[0].assetId != assetId))
385416     then throw("can't add interest with unrelated token")
386417     else syncTotals(0, 0, i.payments[0].amount, 0)
387418 
388419 
389420 
390421 @Callable(i)
391422 func withdrawFromReserve (amt) = {
392423     let admin = getStringValue(configAddress, "admin")
393424     if ((toString(i.caller) != admin))
394425         then throw("only admin can do")
395426         else (syncTotals(0, 0, -(amt), amt) ++ [ScriptTransfer(addressFromStringValue(admin), amt, assetId)])
396427     }
397428 
398429 
399430 
400431 @Callable(i)
401432 func forceUpdate () = {
402433     let admin = getStringValue(configAddress, "admin")
403434     if ((toString(i.caller) != admin))
404435         then throw("only admin can do")
405436         else syncTotals(0, 0, 0, 0)
406437     }
407438 
408439 
409440 
410441 @Callable(i)
411442 func initialize (cfgAddress,oracleAddr,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
412443     let checks = if (notInitialized)
413444         then isAssetIdOrWaves(assetIdOrWaves)
414445         else false
415446     if ((checks == checks))
416447         then {
417448             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
418449 [aToken, writeString(oracleStore, oracleAddr), writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken))), writeInt(lastUpdateHeightStore, HEIGHT)]
419450             }
420451         else throw("Strict value is not equal to itself.")
421452     }
422453 
423454 
424455 
425456 @Callable(i)
426457 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
427458 
428459 
429460 
430461 @Callable(i)
431462 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
432463 
433464 
434465 
435466 @Callable(i)
436467 func userBalance (address) = {
437468     let atokens = aTokenBalance(address)
438469     let asset = aTokenToAsset(atokens)
439470     let debt = currentUserDebt(address)
440471     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
441472     }
442473 
443474 
444475 
445476 @Callable(i)
446477 func userDebt (address) = {
447478     let debt = currentUserDebt(address)
448479     let debtUsd = assetToUsd(debt)
449480     $Tuple2(nil, $Tuple2(debt, debtUsd))
450481     }
451482 
452483 
453484 
454485 @Callable(i)
455486 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
456487 
457488 
458489 
459490 @Callable(i)
460491 func repay () = {
461492     let checks = opAllowed("repay")
462493     if ((checks == checks))
463494         then {
464495             let userAddress = toString(i.caller)
465496             let amount = paymentAmount(i, assetId)
466497             let currentDebt = currentUserDebt(userAddress)
467498             if ((currentDebt == currentDebt))
468499                 then {
469-                    let $t01570515981 = if ((amount > currentDebt))
500+                    let $t01707117347 = if ((amount > currentDebt))
470501                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(i.caller, (amount - currentDebt), assetId)])
471502                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
472-                    let newDebt = $t01570515981._1
473-                    let totalDebtUpdate = $t01570515981._2
474-                    let payout = $t01570515981._3
475-                    let actions = $t01570515981._4
503+                    let newDebt = $t01707117347._1
504+                    let totalDebtUpdate = $t01707117347._2
505+                    let payout = $t01707117347._3
506+                    let actions = $t01707117347._4
476507                     ((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)])
477508                     }
478509                 else throw("Strict value is not equal to itself.")
479510             }
480511         else throw("Strict value is not equal to itself.")
481512     }
482513 
483514 
484515 
485516 @Callable(i)
486517 func depositFor (depositor,useAsCollateral) = {
487518     let checks = if (mainOnly(i))
488519         then opAllowed("deposit")
489520         else false
490521     if ((checks == checks))
491522         then if (if ((currentUserDebt(depositor) > 0))
492523             then !(useAsCollateral)
493524             else false)
494525             then throw("can't disable use as collateral for asset with open debt")
495526             else {
496527                 let amount = paymentAmount(i, assetId)
497528                 let aTokenAmount = assetToAToken(amount)
498529                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
499530                 }
500531         else throw("Strict value is not equal to itself.")
501532     }
502533 
503534 
504535 
505536 @Callable(i)
506537 func replenishWithAtoken () = {
507538     let checks = opAllowed("atokens")
508539     if ((checks == checks))
509540         then {
510541             let aTokenAmount = paymentAmount(i, aTokenId)
511542             let user = toString(i.caller)
512543             ((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user))
513544             }
514545         else throw("Strict value is not equal to itself.")
515546     }
516547 
517548 
518549 
519550 @Callable(i)
520551 func borrowFor (address,amountToBorrow) = {
521552     let checks = if (if (mainOnly(i))
522553         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
523554         else false)
524555         then opAllowed("borrow")
525556         else false
526557     if ((checks == checks))
527558         then {
528559             let newDebt = (currentUserDebt(address) + amountToBorrow)
529560             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
530561             }
531562         else throw("Strict value is not equal to itself.")
532563     }
533564 
534565 
535566 
536567 @Callable(i)
537568 func mintAtokenFor (address,amountToMint) = {
538569     let userATokenBalance = aTokenBalance(address)
539570     let amount = if ((amountToMint == -1))
540571         then userATokenBalance
541572         else amountToMint
542573     let checks = if (if (if (mainOnly(i))
543574         then opAllowed("atokens")
544575         else false)
545576         then throwIf((-1 > amountToMint), "invalid amountToMint")
546577         else false)
547578         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
548579         else false
549580     if ((checks == checks))
550581         then (syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)])
551582         else throw("Strict value is not equal to itself.")
552583     }
553584 
554585 
555586 
556587 @Callable(i)
557588 func redeemAtokens () = {
558589     let checks = opAllowed("atokens")
559590     if ((checks == checks))
560591         then {
561592             let aTokenAmount = paymentAmount(i, aTokenId)
562593             let outAmount = aTokenToAsset(aTokenAmount)
563594             (syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(i.caller, outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)])
564595             }
565596         else throw("Strict value is not equal to itself.")
566597     }
567598 
568599 
569600 
570601 @Callable(i)
571602 func withdrawFor (address,amount) = {
572603     let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
573604     let checks = if (if (if (mainOnly(i))
574605         then liquidityCheck(amount, maxWithdraw, "funds in use")
575606         else false)
576607         then throwIf((-1 > amount), "invalid amount")
577608         else false)
578609         then opAllowed("withdraw")
579610         else false
580611     if ((checks == checks))
581612         then {
582-            let $t01915419348 = if ((amount == -1))
613+            let $t02052020714 = if ((amount == -1))
583614                 then {
584615                     let atokens = aTokenBalance(address)
585616                     $Tuple2(atokens, aTokenToAsset(atokens))
586617                     }
587618                 else $Tuple2(assetToATokenCeil(amount), amount)
588-            let removedAtokens = $t01915419348._1
589-            let withdrawAmount = $t01915419348._2
619+            let removedAtokens = $t02052020714._1
620+            let withdrawAmount = $t02052020714._2
590621             (syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))])
591622             }
592623         else throw("Strict value is not equal to itself.")
593624     }
594625 
595626 
596627 
597628 @Callable(i)
598629 func transferATokensFor (from,to,valueUsd) = {
599630     let checks = if (mainOnly(i))
600631         then opAllowed("transfer_debt")
601632         else false
602633     if ((checks == checks))
603634         then {
604635             let assets = usdToAsset(valueUsd)
605636             let atokens = assetToAToken(assets)
606637             let aTokensFrom = aTokenBalance(from)
607638             if ((atokens > aTokensFrom))
608639                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
609640                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
610641             }
611642         else throw("Strict value is not equal to itself.")
612643     }
613644 
614645 
615646 
616647 @Callable(i)
617648 func transferDebtFor (from,to,amount) = {
618649     let checks = if (mainOnly(i))
619650         then opAllowed("transfer_debt")
620651         else false
621652     if ((checks == checks))
622653         then (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)])
623654         else throw("Strict value is not equal to itself.")
624655     }
625656 
626657 
627658 
628659 @Callable(i)
629660 func disableUseAsCollateralFor (address) = {
630661     let checks = if (mainOnly(i))
631662         then opAllowed("use_as_col")
632663         else false
633664     if ((checks == checks))
634665         then if ((currentUserDebt(address) > 0))
635666             then throw("can't disable collateral for asset with open debt")
636667             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
637668         else throw("Strict value is not equal to itself.")
638669     }
639670 
640671 
641672 
642673 @Callable(i)
643674 func enableUseAsCollateral () = {
644675     let checks = opAllowed("use_as_col")
645676     if ((checks == checks))
646677         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
647678         else throw("Strict value is not equal to itself.")
648679     }
649680 
650681 
651682 
652683 @Callable(i)
653684 func collapseFor (user) = {
654685     let checks = if (mainOnly(i))
655686         then opAllowed("force_collapse")
656687         else false
657688     if ((checks == checks))
658689         then collapseUser(user, -1)
659690         else throw("Strict value is not equal to itself.")
660691     }
661692 
662693 
663694 
664695 @Callable(i)
665696 func collapseDebt (amount) = {
666697     let checks = opAllowed("collapse")
667698     if ((checks == checks))
668699         then collapseUser(toString(i.caller), amount)
669700         else throw("Strict value is not equal to itself.")
670701     }
671702 
672703 
github/deemru/w8io/786bc32 
95.16 ms ◑