2022.05.21 16:07 [3126945] smart account 3PPdeWwrzaxqgr6BuReoF3sWfxW8SYv743D > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 8Dkms2oKeyV4BsW7aNBGCtCksTG3o6gEtdtKMwmVniM4
Next: 2QiuiqiHxpsH3AeTUUqVQRjV5Ub9dLf9r6GGck3PyzfZ

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)
442449     }
443450 
444451 
452+func mintInternal (i,address,amountToMint,to) = {
453+    let userATokenBalance = aTokenBalance(address)
454+    let amount = if ((amountToMint == -1))
455+        then userATokenBalance
456+        else amountToMint
457+    let checks = if (if (if (mainOnly(i))
458+        then opAllowed("mint_atokens")
459+        else false)
460+        then throwIf((-1 > amountToMint), "invalid amountToMint")
461+        else false)
462+        then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
463+        else false
464+    if ((checks == checks))
465+        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(to), amount, aTokenId)]), aTokenToAsset(amount))
466+        else throw("Strict value is not equal to itself.")
467+    }
468+
469+
445470 @Callable(i)
446471 func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(claimableDividends, assetIdStr, (currentTotalReserve - claimableDividends)))
447472 
454479 
455480 @Callable(i)
456481 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
482+    let $t01721717254 = userTotals(user1)
483+    let d1 = $t01721717254._1
484+    let d2 = $t01721717254._2
485+    let d3 = $t01721717254._3
486+    let d4 = $t01721717254._4
487+    let $t01725917296 = userTotals(user2)
488+    let e1 = $t01725917296._1
489+    let e2 = $t01725917296._2
490+    let e3 = $t01725917296._3
491+    let e4 = $t01725917296._4
467492     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
468493     }
469494 
662687 
663688 
664689 @Callable(i)
665-func mintAtokenFor (address,amountToMint) = {
666-    let userATokenBalance = aTokenBalance(address)
667-    let amount = if ((amountToMint == -1))
668-        then userATokenBalance
669-        else amountToMint
670-    let checks = if (if (if (mainOnly(i))
671-        then opAllowed("mint_atokens")
672-        else false)
673-        then throwIf((-1 > amountToMint), "invalid amountToMint")
674-        else false)
675-        then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
676-        else false
677-    if ((checks == checks))
678-        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
679-        else throw("Strict value is not equal to itself.")
680-    }
690+func mintAtokenFor (address,amountToMint) = mintInternal(i, address, amountToMint, address)
691+
692+
693+
694+@Callable(i)
695+func mintAtokenForTo (from,amountToMint,to) = mintInternal(i, from, amountToMint, to)
681696 
682697 
683698 

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 
452+func mintInternal (i,address,amountToMint,to) = {
453+    let userATokenBalance = aTokenBalance(address)
454+    let amount = if ((amountToMint == -1))
455+        then userATokenBalance
456+        else amountToMint
457+    let checks = if (if (if (mainOnly(i))
458+        then opAllowed("mint_atokens")
459+        else false)
460+        then throwIf((-1 > amountToMint), "invalid amountToMint")
461+        else false)
462+        then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
463+        else false
464+    if ((checks == checks))
465+        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(to), amount, aTokenId)]), aTokenToAsset(amount))
466+        else throw("Strict value is not equal to itself.")
467+    }
468+
469+
445470 @Callable(i)
446471 func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(claimableDividends, assetIdStr, (currentTotalReserve - claimableDividends)))
447472 
448473 
449474 
450475 @Callable(i)
451476 func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
452477 
453478 
454479 
455480 @Callable(i)
456481 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
482+    let $t01721717254 = userTotals(user1)
483+    let d1 = $t01721717254._1
484+    let d2 = $t01721717254._2
485+    let d3 = $t01721717254._3
486+    let d4 = $t01721717254._4
487+    let $t01725917296 = userTotals(user2)
488+    let e1 = $t01725917296._1
489+    let e2 = $t01725917296._2
490+    let e3 = $t01725917296._3
491+    let e4 = $t01725917296._4
467492     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
468493     }
469494 
470495 
471496 
472497 @Callable(i)
473498 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
474499 
475500 
476501 
477502 @Callable(i)
478503 func adviseUser (user) = {
479504     let currentDebtUsd = assetToUsd(currentTotalDebt)
480505     let currentDepositUsd = assetToUsd(currentTotalDeposit)
481506     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
482507     let effectiveDepositUsd = if (asCollateral)
483508         then currentDepositUsd
484509         else 0
485510     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
486511     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
487512     let bp = if ((currentDebtUsd > effectiveDepositUsd))
488513         then 0
489514         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
490515     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
491516         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
492517         else overlapCharge
493518     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
494519     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
495520     }
496521 
497522 
498523 
499524 @Callable(i)
500525 func addInterest () = if ((i.payments[0].assetId != assetId))
501526     then throw("can't add interest with unrelated token")
502527     else syncTotals(i.payments[0].amount, 0, 0, 0)
503528 
504529 
505530 
506531 @Callable(i)
507532 func addToReserve () = if ((i.payments[0].assetId != assetId))
508533     then throw("can't add interest with unrelated token")
509534     else syncTotals(0, 0, i.payments[0].amount, 0)
510535 
511536 
512537 
513538 @Callable(i)
514539 func withdrawFromReserve (amt) = {
515540     let checks = divAdminOnly(i)
516541     if ((checks == checks))
517542         then {
518543             let diff = if ((amt == -1))
519544                 then claimableDividends
520545                 else amt
521546             $Tuple2((syncTotals(0, 0, -(diff), diff) ++ [ScriptTransfer(i.caller, diff, assetId)]), diff)
522547             }
523548         else throw("Strict value is not equal to itself.")
524549     }
525550 
526551 
527552 
528553 @Callable(i)
529554 func forceUpdate () = {
530555     let admin = valueOrErrorMessage(getString(configAddress, "admin"), "reserve:no admin in config")
531556     if ((toString(i.caller) != admin))
532557         then throw("only admin can do")
533558         else syncTotals(0, 0, 0, 0)
534559     }
535560 
536561 
537562 
538563 @Callable(i)
539564 func initialize (cfgAddress,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
540565     let checks = if (notInitialized)
541566         then isAssetIdOrWaves(assetIdOrWaves)
542567         else false
543568     if ((checks == checks))
544569         then {
545570             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
546571 [aToken, writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken)))]
547572             }
548573         else throw("Strict value is not equal to itself.")
549574     }
550575 
551576 
552577 
553578 @Callable(i)
554579 func initialize2 () = if ((i.caller != this))
555580     then throw("only self can continue")
556581     else [writeInt(lastUpdateHeightStore, HEIGHT)]
557582 
558583 
559584 
560585 @Callable(i)
561586 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
562587 
563588 
564589 
565590 @Callable(i)
566591 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
567592 
568593 
569594 
570595 @Callable(i)
571596 func userBalance (address) = {
572597     let atokens = aTokenBalance(address)
573598     let asset = aTokenToAsset(atokens)
574599     let debt = currentUserDebt(address)
575600     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
576601     }
577602 
578603 
579604 
580605 @Callable(i)
581606 func userDebt (address) = {
582607     let debt = currentUserDebt(address)
583608     let debtUsd = assetToUsd(debt)
584609     $Tuple2(nil, $Tuple2(debt, debtUsd))
585610     }
586611 
587612 
588613 
589614 @Callable(i)
590615 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
591616 
592617 
593618 
594619 @Callable(i)
595620 func repayFor (userAddress) = {
596621     let checks = mainOnly(i)
597622     if ((checks == checks))
598623         then repayUser(userAddress, paymentAmount(i, assetId))
599624         else throw("Strict value is not equal to itself.")
600625     }
601626 
602627 
603628 
604629 @Callable(i)
605630 func depositFor (depositor,useAsCollateral) = {
606631     let checks = if (mainOnly(i))
607632         then opAllowed("deposit")
608633         else false
609634     if ((checks == checks))
610635         then if (if ((currentUserDebt(depositor) > 0))
611636             then !(useAsCollateral)
612637             else false)
613638             then throw("can't disable use as collateral for asset with open debt")
614639             else {
615640                 let amount = paymentAmount(i, assetId)
616641                 let aTokenAmount = assetToAToken(amount)
617642                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
618643                 }
619644         else throw("Strict value is not equal to itself.")
620645     }
621646 
622647 
623648 
624649 @Callable(i)
625650 func withdrawFor (address,amount) = withdrawInternal(i, address, amount, false)
626651 
627652 
628653 
629654 @Callable(i)
630655 func withdrawToMain (user,amount) = if ((amount != -1))
631656     then throw("reserve: withdrawToMain amount -1 only")
632657     else withdrawInternal(i, user, amount, true)
633658 
634659 
635660 
636661 @Callable(i)
637662 func replenishWithAtokenFor (user) = replenishInternal("replenish_atokens", user, i)
638663 
639664 
640665 
641666 @Callable(i)
642667 func replenishForRepayWithAtokenFor (user) = replenishInternal("repay_atokens", user, i)
643668 
644669 
645670 
646671 @Callable(i)
647672 func borrowFor (address,amountToBorrow) = {
648673     let checks = if (if (mainOnly(i))
649674         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
650675         else false)
651676         then opAllowed("borrow")
652677         else false
653678     if ((checks == checks))
654679         then {
655680             let currentDebt = currentUserDebt(address)
656681             let newDebt = (currentDebt + amountToBorrow)
657682             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
658683             }
659684         else throw("Strict value is not equal to itself.")
660685     }
661686 
662687 
663688 
664689 @Callable(i)
665-func mintAtokenFor (address,amountToMint) = {
666-    let userATokenBalance = aTokenBalance(address)
667-    let amount = if ((amountToMint == -1))
668-        then userATokenBalance
669-        else amountToMint
670-    let checks = if (if (if (mainOnly(i))
671-        then opAllowed("mint_atokens")
672-        else false)
673-        then throwIf((-1 > amountToMint), "invalid amountToMint")
674-        else false)
675-        then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
676-        else false
677-    if ((checks == checks))
678-        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
679-        else throw("Strict value is not equal to itself.")
680-    }
690+func mintAtokenFor (address,amountToMint) = mintInternal(i, address, amountToMint, address)
691+
692+
693+
694+@Callable(i)
695+func mintAtokenForTo (from,amountToMint,to) = mintInternal(i, from, amountToMint, to)
681696 
682697 
683698 
684699 @Callable(i)
685700 func redeemAtokensFor (user) = {
686701     let checks = if (mainOnly(i))
687702         then opAllowed("redeem_atokens")
688703         else false
689704     if ((checks == checks))
690705         then {
691706             let aTokenAmount = paymentAmount(i, aTokenId)
692707             let outAmount = aTokenToAsset(aTokenAmount)
693708             $Tuple2((syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(addressFromStringValue(user), outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)]), outAmount)
694709             }
695710         else throw("Strict value is not equal to itself.")
696711     }
697712 
698713 
699714 
700715 @Callable(i)
701716 func transferATokensFor (from,to,valueUsd) = {
702717     let checks = if (mainOnly(i))
703718         then opAllowed("transfer_debt")
704719         else false
705720     if ((checks == checks))
706721         then {
707722             let assets = usdToAsset(valueUsd)
708723             let atokens = assetToAToken(assets)
709724             let aTokensFrom = aTokenBalance(from)
710725             if ((atokens > aTokensFrom))
711726                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
712727                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
713728             }
714729         else throw("Strict value is not equal to itself.")
715730     }
716731 
717732 
718733 
719734 @Callable(i)
720735 func transferDebtFor (from,to,amount) = {
721736     let checks = if (mainOnly(i))
722737         then opAllowed("transfer_debt")
723738         else false
724739     if ((checks == checks))
725740         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)
726741         else throw("Strict value is not equal to itself.")
727742     }
728743 
729744 
730745 
731746 @Callable(i)
732747 func disableUseAsCollateralFor (address) = {
733748     let checks = if (mainOnly(i))
734749         then opAllowed("use_as_col")
735750         else false
736751     if ((checks == checks))
737752         then if ((currentUserDebt(address) > 0))
738753             then throw("can't disable collateral for asset with open debt")
739754             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
740755         else throw("Strict value is not equal to itself.")
741756     }
742757 
743758 
744759 
745760 @Callable(i)
746761 func enableUseAsCollateral () = {
747762     let checks = opAllowed("use_as_col")
748763     if ((checks == checks))
749764         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
750765         else throw("Strict value is not equal to itself.")
751766     }
752767 
753768 
754769 
755770 @Callable(i)
756771 func collapseFor (user) = {
757772     let checks = if (mainOnly(i))
758773         then opAllowed("force_collapse")
759774         else false
760775     if ((checks == checks))
761776         then collapseUser(user, -1)
762777         else throw("Strict value is not equal to itself.")
763778     }
764779 
765780 
766781 
767782 @Callable(i)
768783 func collapseForAmount (user,amount) = {
769784     let checks = if (mainOnly(i))
770785         then opAllowed("collapse")
771786         else false
772787     if ((checks == checks))
773788         then collapseUser(user, amount)
774789         else throw("Strict value is not equal to itself.")
775790     }
776791 
777792 
github/deemru/w8io/786bc32 
107.72 ms ◑