2021.10.12 16:24 [2808091] smart account 3PPdeWwrzaxqgr6BuReoF3sWfxW8SYv743D > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FDTZCFH4KLn7nqey6YgGLvjBnzWAN7am2RfJqfrGXSyD",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1634045000745,
    "version": 1,
    "sender": "3PPdeWwrzaxqgr6BuReoF3sWfxW8SYv743D",
    "senderPublicKey": "C3fFhhdansbg2NWwzu6z87qa7RTEYVqqFHbmzz7mBcok",
    "proofs": [
        "y57HHhSoR3jRhASMtHhMHvzHq7zWpcrmsbYPwFUfZ5VkQpNXg7SGbCCZgxjE2EcXiXHMq6oDx2ouDL9K9voSYnK"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2808091,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: AfWZ8ZAe59vmojZr2HnUD7pMGhbM7p9LTtnukrCh9TJF
Next: DjSaU8Kn5D9yH2J6vmbq7XyH2DnLzQawu1oxq7JLT5Dc

Diff: 

OldNewDifferences
219219     then 0
220220     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
221221 
222-let currentIndex = {
223-    let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
224-    fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
225-    }
222+let currentIndex = if ((HEIGHT == lastUpdateHeight))
223+    then storedIndex
224+    else {
225+        let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
226+        fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
227+        }
226228 
227229 func liquidityCheck (amount,max,err) = if ((amount > max))
228230     then throw(("not enough liquidity: " + err))
361363             let currentDebt = currentUserDebt(userAddress)
362364             if ((currentDebt == currentDebt))
363365                 then {
364-                    let $t01080011103 = if ((amount > currentDebt))
366+                    let $t01086911172 = if ((amount > currentDebt))
365367                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
366368                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
367-                    let newDebt = $t01080011103._1
368-                    let totalDebtUpdate = $t01080011103._2
369-                    let payout = $t01080011103._3
370-                    let actions = $t01080011103._4
369+                    let newDebt = $t01086911172._1
370+                    let totalDebtUpdate = $t01086911172._2
371+                    let payout = $t01086911172._3
372+                    let actions = $t01086911172._4
371373                     let repaid = (amount - payout)
372374                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
373375                     }
378380 
379381 
380382 func getConfig () = {
381-    let $t01133611356 = ABCD
382-    let a = $t01133611356._1
383-    let b = $t01133611356._2
384-    let c = $t01133611356._3
385-    let d = $t01133611356._4
383+    let $t01140511425 = ABCD
384+    let a = $t01140511425._1
385+    let b = $t01140511425._2
386+    let c = $t01140511425._3
387+    let d = $t01140511425._4
386388     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
387389     }
388390 
400402 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))))
401403 
402404 
405+func userTotals (user) = {
406+    let atokens = aTokenBalance(user)
407+    let asset = aTokenToAsset(atokens)
408+    let debt = currentUserDebt(user)
409+    if ((HEIGHT == lastUpdateHeight))
410+        then $Tuple4(storedTotalDeposit, storedTotalDebt, asset, debt)
411+        else $Tuple4(currentTotalDeposit, currentTotalDebt, asset, debt)
412+    }
413+
414+
403415 @Callable(i)
404-func getCurrentTotals () = $Tuple2(nil, $Tuple2(currentTotalDeposit, currentTotalDebt))
416+func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
417+
418+
419+
420+@Callable(i)
421+func getCurrentTotals2 (user1,user2) = {
422+    let $t01455314590 = userTotals(user1)
423+    let d1 = $t01455314590._1
424+    let d2 = $t01455314590._2
425+    let d3 = $t01455314590._3
426+    let d4 = $t01455314590._4
427+    let $t01459514632 = userTotals(user2)
428+    let e1 = $t01459514632._1
429+    let e2 = $t01459514632._2
430+    let e3 = $t01459514632._3
431+    let e4 = $t01459514632._4
432+    $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
433+    }
405434 
406435 
407436 
526555 
527556 
528557 @Callable(i)
529-func repay () = repayUser(toString(i.caller), paymentAmount(i, assetId))
530-
531-
532-
533-@Callable(i)
534558 func depositFor (depositor,useAsCollateral) = {
535559     let checks = if (mainOnly(i))
536560         then opAllowed("deposit")
562586         else false
563587     if ((checks == checks))
564588         then {
565-            let $t01891119105 = if ((amount == -1))
589+            let $t01932119515 = if ((amount == -1))
566590                 then {
567591                     let atokens = aTokenBalance(address)
568592                     $Tuple2(atokens, aTokenToAsset(atokens))
569593                     }
570594                 else $Tuple2(assetToATokenCeil(amount), amount)
571-            let removedAtokens = $t01891119105._1
572-            let withdrawAmount = $t01891119105._2
595+            let removedAtokens = $t01932119515._1
596+            let withdrawAmount = $t01932119515._2
573597             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
574598             }
575599         else throw("Strict value is not equal to itself.")
722746     }
723747 
724748 
725-
726-@Callable(i)
727-func collapseDebt (amount) = {
728-    let checks = opAllowed("collapse")
729-    if ((checks == checks))
730-        then collapseUser(toString(i.caller), amount)
731-        else throw("Strict value is not equal to itself.")
732-    }
733-
734-

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")
5454 
5555 let overlapChargeStore = "account_health_overlap"
5656 
5757 let liquidationPenaltyStore = (getStringValue(assetIdStore) + "_LiquidationPenalty")
5858 
5959 let configAddressStore = "configAddress"
6060 
6161 let oracleStore = "oracleAddress"
6262 
6363 let aTokenIdStore = "aTokenId"
6464 
6565 let aTokenNameStore = "aTokenName"
6666 
6767 let aTokenCirculationStore = "aTokenCirculation"
6868 
6969 let lastUpdateHeightStore = "lastUpdateHeight"
7070 
7171 let totalDebtStore = "totalBorrow"
7272 
7373 let totalDepositStore = "totalDeposit"
7474 
7575 let totalReserveStore = "totalReserve"
7676 
7777 let indexStore = "storedIndex"
7878 
7979 let aTokenDecimalsStore = "aTokenDecimals"
8080 
8181 func aTokenBalanceStore (userAddress) = (userAddress + "_aTokenBalance")
8282 
8383 
8484 func debtStore (userAddress) = (userAddress + "_debt")
8585 
8686 
8787 func debtIndexStore (userAddress) = (userAddress + "_index")
8888 
8989 
9090 func useAsCollateralStore (userAddress) = (userAddress + "_useAsCollateral")
9191 
9292 
9393 let assetId = {
9494     let id = valueOrErrorMessage(getS(assetIdStore), "no assetId")
9595     if ((id == "WAVES"))
9696         then unit
9797         else fromBase58String(id)
9898     }
9999 
100100 let assetIdStr = match assetId {
101101     case bv: ByteVector => 
102102         toBase58String(bv)
103103     case u: Unit => 
104104         "WAVES"
105105     case _ => 
106106         throw("Match error")
107107 }
108108 
109109 func getBalance (addressOrAlias,assetId) = match assetId {
110110     case bv: ByteVector => 
111111         assetBalance(addressOrAlias, bv)
112112     case u: Unit => 
113113         wavesBalance(addressOrAlias).available
114114     case _ => 
115115         throw("Match error")
116116 }
117117 
118118 
119119 let assetDecimals = valueOrErrorMessage(getI(aTokenDecimalsStore), "no assetDecimals")
120120 
121121 let configAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getS(configAddressStore), "no configAddress")), "invalid config address")
122122 
123123 func opAllowed (op) = {
124124     let aid = valueOrErrorMessage(getS(assetIdStore), "no assetId")
125125     match invoke(configAddress, "opAllowed", [aid, op], nil) {
126126         case b: Boolean => 
127127             if (b)
128128                 then true
129129                 else throw("not allowed")
130130         case _ => 
131131             throw("opAllowed: unexpected result type")
132132     }
133133     }
134134 
135135 
136136 func mainOnly (i) = if ((i.caller != valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")))
137137     then throw("only main can do")
138138     else true
139139 
140140 
141141 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
142142     then (fromBase58String(value) == fromBase58String(""))
143143     else false)
144144     then throw("invalid assetId")
145145     else true
146146 
147147 
148148 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
149149 
150150 let maybeOracleAddress = match getS(oracleStore) {
151151     case s: String => 
152152         addressFromString(s)
153153     case _ => 
154154         unit
155155 }
156156 
157157 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [getSV(assetIdStore)], nil) {
158158     case i: Int => 
159159         i
160160     case _ => 
161161         throw("bad oracle data")
162162 }
163163 
164164 let HEIGHT = height
165165 
166166 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
167167 
168168 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
169169 
170170 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
171171 
172172 let ABCD = {
173173     let id = getSV(assetIdStore)
174174     $Tuple4(getIntegerValue(configAddress, (id + "_APoint")), getIntegerValue(configAddress, (id + "_BPoint")), getIntegerValue(configAddress, (id + "_CPoint")), getIntegerValue(configAddress, (id + "_DPoint")))
175175     }
176176 
177177 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
178178 
179179 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
180180 
181181 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
182182 
183183 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
184184 
185185 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
186186 
187187 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
188188 
189189 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
190190 
191191 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
192192 
193193 let storedIndex = valueOrElse(getI(indexStore), RBase)
194194 
195195 let utilization = if ((storedTotalDeposit > 0))
196196     then fraction(storedTotalDebt, factorsBase, storedTotalDeposit)
197197     else 0
198198 
199199 let apr = {
200200     let $t055325552 = ABCD
201201     let a = $t055325552._1
202202     let b = $t055325552._2
203203     let c = $t055325552._3
204204     let d = $t055325552._4
205205     let lineAC = (fraction((a - c), utilization, -(b)) + a)
206206     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
207207     if ((utilization == 0))
208208         then a
209209         else if ((utilization == b))
210210             then c
211211             else if (if ((b > utilization))
212212                 then true
213213                 else (b == factorsBase))
214214                 then lineAC
215215                 else lineCD
216216     }
217217 
218218 let apy = if ((storedTotalDeposit == 0))
219219     then 0
220220     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
221221 
222-let currentIndex = {
223-    let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
224-    fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
225-    }
222+let currentIndex = if ((HEIGHT == lastUpdateHeight))
223+    then storedIndex
224+    else {
225+        let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
226+        fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
227+        }
226228 
227229 func liquidityCheck (amount,max,err) = if ((amount > max))
228230     then throw(("not enough liquidity: " + err))
229231     else true
230232 
231233 
232234 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
233235 
234236 
235237 func currentUserDebt (userAddress) = {
236238     let v = storedUserDebt(userAddress)
237239     if ((v == 0))
238240         then 0
239241         else {
240242             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
241243             fraction(v, currentIndex, storedUserIndex)
242244             }
243245     }
244246 
245247 
246248 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
247249 
248250 let addedDebt = (currentTotalDebt - storedTotalDebt)
249251 
250252 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
251253 
252254 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
253255 
254256 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
255257 
256258 func paymentAmount (i,assetId) = {
257259     let p = i.payments[0].amount
258260     if ((0 >= p))
259261         then throw("Payment is less than min allowed amount")
260262         else if ((i.payments[0].assetId != assetId))
261263             then throw(("bad asset attached: required " + assetIdStr))
262264             else p
263265     }
264266 
265267 
266268 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
267269     let actualBalance =     match assetId {
268270         case aid: ByteVector => 
269271             assetBalance(this, aid)
270272         case _ => 
271273             wavesBalance(this).available
272274     }
273275     let stakingAction = if ((actualBalance == keepAtBalance))
274276         then unit
275277         else {
276278             let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
277279             if (!(stakingEnabled))
278280                 then unit
279281                 else {
280282                     let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
281283                     if ((actualBalance > keepAtBalance))
282284                         then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
283285                         else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
284286                     }
285287             }
286288     if ((stakingAction == stakingAction))
287289         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
288290         else throw("Strict value is not equal to itself.")
289291     }
290292 
291293 
292294 func pow10 (n) = if ((n == 6))
293295     then 1000000
294296     else if ((n == 8))
295297         then 100000000
296298         else throw(("bad decimals: " + toString(n)))
297299 
298300 
299301 func assetToUsd (amount) = fraction(amount, oraclePrice, pow10(assetDecimals))
300302 
301303 
302304 func usdToAsset (amount) = fraction(amount, pow10(assetDecimals), oraclePrice)
303305 
304306 
305307 func aTokenToAsset (aTokenAmount) = if ((aTokenAmount == 0))
306308     then 0
307309     else if ((aTokenCirculation > 0))
308310         then fraction(aTokenAmount, currentTotalDeposit, aTokenCirculation)
309311         else aTokenAmount
310312 
311313 
312314 func assetToAToken (assetAmount) = if ((assetAmount == 0))
313315     then 0
314316     else if ((aTokenCirculation > 0))
315317         then fraction(assetAmount, aTokenCirculation, currentTotalDeposit)
316318         else assetAmount
317319 
318320 
319321 func assetToATokenCeil (assetAmount) = if ((assetAmount == 0))
320322     then 0
321323     else if ((aTokenCirculation > 0))
322324         then fractionCeil(assetAmount, aTokenCirculation, currentTotalDeposit)
323325         else assetAmount
324326 
325327 
326328 func aTokenBalance (address) = valueOrElse(getI(aTokenBalanceStore(address)), 0)
327329 
328330 
329331 func enableCol (user) = BooleanEntry(useAsCollateralStore(user), true)
330332 
331333 
332334 func enableColIfNeeded (user) = if ((currentUserDebt(user) > 0))
333335     then [enableCol(user)]
334336     else nil
335337 
336338 
337339 func collapseUser (address,amount) = {
338340     let debt = currentUserDebt(address)
339341     let deposit = aTokenToAsset(aTokenBalance(address))
340342     let maxPossible = min([debt, deposit])
341343     let amt = if ((-1 > amount))
342344         then throw("invalid collapse amount")
343345         else if (if ((maxPossible == 0))
344346             then true
345347             else (amount == 0))
346348             then throw("nothing to collapse")
347349             else if (if ((amount == -1))
348350                 then true
349351                 else (amount > maxPossible))
350352                 then maxPossible
351353                 else amount
352354     let removedAtokens = assetToATokenCeil(amt)
353355     $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
354356     }
355357 
356358 
357359 func repayUser (userAddress,amount) = {
358360     let checks = opAllowed("repay")
359361     if ((checks == checks))
360362         then {
361363             let currentDebt = currentUserDebt(userAddress)
362364             if ((currentDebt == currentDebt))
363365                 then {
364-                    let $t01080011103 = if ((amount > currentDebt))
366+                    let $t01086911172 = if ((amount > currentDebt))
365367                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
366368                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
367-                    let newDebt = $t01080011103._1
368-                    let totalDebtUpdate = $t01080011103._2
369-                    let payout = $t01080011103._3
370-                    let actions = $t01080011103._4
369+                    let newDebt = $t01086911172._1
370+                    let totalDebtUpdate = $t01086911172._2
371+                    let payout = $t01086911172._3
372+                    let actions = $t01086911172._4
371373                     let repaid = (amount - payout)
372374                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
373375                     }
374376                 else throw("Strict value is not equal to itself.")
375377             }
376378         else throw("Strict value is not equal to itself.")
377379     }
378380 
379381 
380382 func getConfig () = {
381-    let $t01133611356 = ABCD
382-    let a = $t01133611356._1
383-    let b = $t01133611356._2
384-    let c = $t01133611356._3
385-    let d = $t01133611356._4
383+    let $t01140511425 = ABCD
384+    let a = $t01140511425._1
385+    let b = $t01140511425._2
386+    let c = $t01140511425._3
387+    let d = $t01140511425._4
386388     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
387389     }
388390 
389391 
390392 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))
391393 
392394 
393395 func getUserState (user) = {
394396     let aBalance = aTokenBalance(user)
395397     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
396398     ((((((((((((((((("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)))
397399     }
398400 
399401 
400402 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))))
401403 
402404 
405+func userTotals (user) = {
406+    let atokens = aTokenBalance(user)
407+    let asset = aTokenToAsset(atokens)
408+    let debt = currentUserDebt(user)
409+    if ((HEIGHT == lastUpdateHeight))
410+        then $Tuple4(storedTotalDeposit, storedTotalDebt, asset, debt)
411+        else $Tuple4(currentTotalDeposit, currentTotalDebt, asset, debt)
412+    }
413+
414+
403415 @Callable(i)
404-func getCurrentTotals () = $Tuple2(nil, $Tuple2(currentTotalDeposit, currentTotalDebt))
416+func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
417+
418+
419+
420+@Callable(i)
421+func getCurrentTotals2 (user1,user2) = {
422+    let $t01455314590 = userTotals(user1)
423+    let d1 = $t01455314590._1
424+    let d2 = $t01455314590._2
425+    let d3 = $t01455314590._3
426+    let d4 = $t01455314590._4
427+    let $t01459514632 = userTotals(user2)
428+    let e1 = $t01459514632._1
429+    let e2 = $t01459514632._2
430+    let e3 = $t01459514632._3
431+    let e4 = $t01459514632._4
432+    $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
433+    }
405434 
406435 
407436 
408437 @Callable(i)
409438 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
410439 
411440 
412441 
413442 @Callable(i)
414443 func adviseUser (user) = {
415444     let currentDebtUsd = assetToUsd(currentTotalDebt)
416445     let currentDepositUsd = assetToUsd(currentTotalDeposit)
417446     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
418447     let effectiveDepositUsd = if (asCollateral)
419448         then currentDepositUsd
420449         else 0
421450     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
422451     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
423452     let bp = if ((currentDebtUsd > effectiveDepositUsd))
424453         then 0
425454         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
426455     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
427456         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
428457         else overlapCharge
429458     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
430459     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
431460     }
432461 
433462 
434463 
435464 @Callable(i)
436465 func addInterest () = if ((i.payments[0].assetId != assetId))
437466     then throw("can't add interest with unrelated token")
438467     else syncTotals(i.payments[0].amount, 0, 0, 0)
439468 
440469 
441470 
442471 @Callable(i)
443472 func addToReserve () = if ((i.payments[0].assetId != assetId))
444473     then throw("can't add interest with unrelated token")
445474     else syncTotals(0, 0, i.payments[0].amount, 0)
446475 
447476 
448477 
449478 @Callable(i)
450479 func withdrawFromReserve (amt) = {
451480     let admin = getStringValue(configAddress, "admin")
452481     if ((toString(i.caller) != admin))
453482         then throw("only admin can do")
454483         else (syncTotals(0, 0, -(amt), amt) ++ [ScriptTransfer(addressFromStringValue(admin), amt, assetId)])
455484     }
456485 
457486 
458487 
459488 @Callable(i)
460489 func forceUpdate () = {
461490     let admin = getStringValue(configAddress, "admin")
462491     if ((toString(i.caller) != admin))
463492         then throw("only admin can do")
464493         else syncTotals(0, 0, 0, 0)
465494     }
466495 
467496 
468497 
469498 @Callable(i)
470499 func initialize (cfgAddress,oracleAddr,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
471500     let checks = if (notInitialized)
472501         then isAssetIdOrWaves(assetIdOrWaves)
473502         else false
474503     if ((checks == checks))
475504         then {
476505             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
477506 [aToken, writeString(oracleStore, oracleAddr), writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken))), writeInt(lastUpdateHeightStore, HEIGHT)]
478507             }
479508         else throw("Strict value is not equal to itself.")
480509     }
481510 
482511 
483512 
484513 @Callable(i)
485514 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
486515 
487516 
488517 
489518 @Callable(i)
490519 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
491520 
492521 
493522 
494523 @Callable(i)
495524 func userBalance (address) = {
496525     let atokens = aTokenBalance(address)
497526     let asset = aTokenToAsset(atokens)
498527     let debt = currentUserDebt(address)
499528     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
500529     }
501530 
502531 
503532 
504533 @Callable(i)
505534 func userDebt (address) = {
506535     let debt = currentUserDebt(address)
507536     let debtUsd = assetToUsd(debt)
508537     $Tuple2(nil, $Tuple2(debt, debtUsd))
509538     }
510539 
511540 
512541 
513542 @Callable(i)
514543 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
515544 
516545 
517546 
518547 @Callable(i)
519548 func repayFor (userAddress) = {
520549     let checks = mainOnly(i)
521550     if ((checks == checks))
522551         then repayUser(userAddress, paymentAmount(i, assetId))
523552         else throw("Strict value is not equal to itself.")
524553     }
525554 
526555 
527556 
528557 @Callable(i)
529-func repay () = repayUser(toString(i.caller), paymentAmount(i, assetId))
530-
531-
532-
533-@Callable(i)
534558 func depositFor (depositor,useAsCollateral) = {
535559     let checks = if (mainOnly(i))
536560         then opAllowed("deposit")
537561         else false
538562     if ((checks == checks))
539563         then if (if ((currentUserDebt(depositor) > 0))
540564             then !(useAsCollateral)
541565             else false)
542566             then throw("can't disable use as collateral for asset with open debt")
543567             else {
544568                 let amount = paymentAmount(i, assetId)
545569                 let aTokenAmount = assetToAToken(amount)
546570                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
547571                 }
548572         else throw("Strict value is not equal to itself.")
549573     }
550574 
551575 
552576 
553577 @Callable(i)
554578 func withdrawFor (address,amount) = {
555579     let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
556580     let checks = if (if (if (mainOnly(i))
557581         then liquidityCheck(amount, maxWithdraw, "funds in use")
558582         else false)
559583         then throwIf((-1 > amount), "invalid amount")
560584         else false)
561585         then opAllowed("withdraw")
562586         else false
563587     if ((checks == checks))
564588         then {
565-            let $t01891119105 = if ((amount == -1))
589+            let $t01932119515 = if ((amount == -1))
566590                 then {
567591                     let atokens = aTokenBalance(address)
568592                     $Tuple2(atokens, aTokenToAsset(atokens))
569593                     }
570594                 else $Tuple2(assetToATokenCeil(amount), amount)
571-            let removedAtokens = $t01891119105._1
572-            let withdrawAmount = $t01891119105._2
595+            let removedAtokens = $t01932119515._1
596+            let withdrawAmount = $t01932119515._2
573597             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
574598             }
575599         else throw("Strict value is not equal to itself.")
576600     }
577601 
578602 
579603 
580604 @Callable(i)
581605 func replenishWithAtokenFor (user) = {
582606     let checks = if (mainOnly(i))
583607         then opAllowed("atokens")
584608         else false
585609     if ((checks == checks))
586610         then {
587611             let aTokenAmount = paymentAmount(i, aTokenId)
588612             $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
589613             }
590614         else throw("Strict value is not equal to itself.")
591615     }
592616 
593617 
594618 
595619 @Callable(i)
596620 func borrowFor (address,amountToBorrow) = {
597621     let checks = if (if (mainOnly(i))
598622         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
599623         else false)
600624         then opAllowed("borrow")
601625         else false
602626     if ((checks == checks))
603627         then {
604628             let currentDebt = currentUserDebt(address)
605629             let newDebt = (currentDebt + amountToBorrow)
606630             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
607631             }
608632         else throw("Strict value is not equal to itself.")
609633     }
610634 
611635 
612636 
613637 @Callable(i)
614638 func mintAtokenFor (address,amountToMint) = {
615639     let userATokenBalance = aTokenBalance(address)
616640     let amount = if ((amountToMint == -1))
617641         then userATokenBalance
618642         else amountToMint
619643     let checks = if (if (if (mainOnly(i))
620644         then opAllowed("atokens")
621645         else false)
622646         then throwIf((-1 > amountToMint), "invalid amountToMint")
623647         else false)
624648         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
625649         else false
626650     if ((checks == checks))
627651         then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
628652         else throw("Strict value is not equal to itself.")
629653     }
630654 
631655 
632656 
633657 @Callable(i)
634658 func redeemAtokens () = {
635659     let checks = opAllowed("atokens")
636660     if ((checks == checks))
637661         then {
638662             let aTokenAmount = paymentAmount(i, aTokenId)
639663             let outAmount = aTokenToAsset(aTokenAmount)
640664             (syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(i.caller, outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)])
641665             }
642666         else throw("Strict value is not equal to itself.")
643667     }
644668 
645669 
646670 
647671 @Callable(i)
648672 func transferATokensFor (from,to,valueUsd) = {
649673     let checks = if (mainOnly(i))
650674         then opAllowed("transfer_debt")
651675         else false
652676     if ((checks == checks))
653677         then {
654678             let assets = usdToAsset(valueUsd)
655679             let atokens = assetToAToken(assets)
656680             let aTokensFrom = aTokenBalance(from)
657681             if ((atokens > aTokensFrom))
658682                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
659683                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
660684             }
661685         else throw("Strict value is not equal to itself.")
662686     }
663687 
664688 
665689 
666690 @Callable(i)
667691 func transferDebtFor (from,to,amount) = {
668692     let checks = if (mainOnly(i))
669693         then opAllowed("transfer_debt")
670694         else false
671695     if ((checks == checks))
672696         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)
673697         else throw("Strict value is not equal to itself.")
674698     }
675699 
676700 
677701 
678702 @Callable(i)
679703 func disableUseAsCollateralFor (address) = {
680704     let checks = if (mainOnly(i))
681705         then opAllowed("use_as_col")
682706         else false
683707     if ((checks == checks))
684708         then if ((currentUserDebt(address) > 0))
685709             then throw("can't disable collateral for asset with open debt")
686710             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
687711         else throw("Strict value is not equal to itself.")
688712     }
689713 
690714 
691715 
692716 @Callable(i)
693717 func enableUseAsCollateral () = {
694718     let checks = opAllowed("use_as_col")
695719     if ((checks == checks))
696720         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
697721         else throw("Strict value is not equal to itself.")
698722     }
699723 
700724 
701725 
702726 @Callable(i)
703727 func collapseFor (user) = {
704728     let checks = if (mainOnly(i))
705729         then opAllowed("force_collapse")
706730         else false
707731     if ((checks == checks))
708732         then collapseUser(user, -1)
709733         else throw("Strict value is not equal to itself.")
710734     }
711735 
712736 
713737 
714738 @Callable(i)
715739 func collapseForAmount (user,amount) = {
716740     let checks = if (mainOnly(i))
717741         then opAllowed("collapse")
718742         else false
719743     if ((checks == checks))
720744         then collapseUser(user, amount)
721745         else throw("Strict value is not equal to itself.")
722746     }
723747 
724748 
725-
726-@Callable(i)
727-func collapseDebt (amount) = {
728-    let checks = opAllowed("collapse")
729-    if ((checks == checks))
730-        then collapseUser(toString(i.caller), amount)
731-        else throw("Strict value is not equal to itself.")
732-    }
733-
734-
github/deemru/w8io/786bc32 
104.37 ms ◑