2022.05.21 16:11 [3126951] smart account 3PBjqiMwwag72VWUtHNnVrxTBrNK8D7bVcN > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6UuBq7sz3c8Yjh5DNqmT3wDS5DRzKA44Jj56bXkE3B4o",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1653138585543,
    "version": 1,
    "sender": "3PBjqiMwwag72VWUtHNnVrxTBrNK8D7bVcN",
    "senderPublicKey": "5M9sKnq7evAcztZEeWBNJoGsW3Xeygnv1DjCqzBLtPQZ",
    "proofs": [
        "3UVxj9L9dFQ9EWaJP7NLnFGTqdPrHihw2fFBJXtRm5hoVRehN1ewtzZRdodjDM2PNWivdHdvHNcpTMF7TAgvwxiT"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3126951,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9pDQzVBFoZPSXMMJdZNfUE3hWoLrYsrVzxN6Edb8gqmP
Next: EeSsirTxsJ6vLpEukbjh99hn4mxhNAatcm9mbixn8hp3

Diff: 

OldNewDifferences
449449     }
450450 
451451 
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+
452470 @Callable(i)
453471 func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(claimableDividends, assetIdStr, (currentTotalReserve - claimableDividends)))
454472 
461479 
462480 @Callable(i)
463481 func getCurrentTotals2 (user1,user2) = {
464-    let $t01656016597 = userTotals(user1)
465-    let d1 = $t01656016597._1
466-    let d2 = $t01656016597._2
467-    let d3 = $t01656016597._3
468-    let d4 = $t01656016597._4
469-    let $t01660216639 = userTotals(user2)
470-    let e1 = $t01660216639._1
471-    let e2 = $t01660216639._2
472-    let e3 = $t01660216639._3
473-    let e4 = $t01660216639._4
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
474492     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
475493     }
476494 
669687 
670688 
671689 @Callable(i)
672-func mintAtokenFor (address,amountToMint) = {
673-    let userATokenBalance = aTokenBalance(address)
674-    let amount = if ((amountToMint == -1))
675-        then userATokenBalance
676-        else amountToMint
677-    let checks = if (if (if (mainOnly(i))
678-        then opAllowed("mint_atokens")
679-        else false)
680-        then throwIf((-1 > amountToMint), "invalid amountToMint")
681-        else false)
682-        then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
683-        else false
684-    if ((checks == checks))
685-        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
686-        else throw("Strict value is not equal to itself.")
687-    }
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)
688696 
689697 
690698 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 func getI (key) = getInteger(this, key)
55 
66 
77 func getS (key) = getString(this, key)
88 
99 
1010 func getSV (key) = valueOrErrorMessage(getString(this, key), ((("no string value for key " + key) + " at address ") + toString(this)))
1111 
1212 
1313 func throwIf (condition,error) = if (condition)
1414     then throw(error)
1515     else true
1616 
1717 
1818 func writeInt (key,value) = if ((0 > value))
1919     then throw(((("writing negative value " + toString(value)) + " for key ") + key))
2020     else IntegerEntry(key, value)
2121 
2222 
2323 func asInt (value) = match value {
2424     case int: Int => 
2525         int
2626     case _ => 
2727         throw("1")
2828 }
2929 
3030 
3131 func changeBy (key,value) = writeInt(key, (valueOrElse(getI(key), 0) + value))
3232 
3333 
3434 func writeString (key,value) = StringEntry(key, value)
3535 
3636 
3737 func fractionCeil (value,numerator,denominator) = {
3838     let cand = fraction(value, numerator, denominator)
3939     let D = 3037000499
4040     let exact = ((((cand % D) * (denominator % D)) % D) == (((value % D) * (numerator % D)) % D))
4141     if (exact)
4242         then cand
4343         else (cand + 1)
4444     }
4545 
4646 
4747 let BlocksPerYear = 525600
4848 
4949 let RBase = 10000000000000000
5050 
5151 let factorsBase = 1000
5252 
5353 let assetIdStore = "assetId"
5454 
5555 let assetIdStr = valueOrErrorMessage(getS(assetIdStore), "no assetId")
5656 
5757 let assetId = if ((assetIdStr == "WAVES"))
5858     then unit
5959     else fromBase58String(assetIdStr)
6060 
6161 let reserveFactorStore = (assetIdStr + "_ReserveFactor")
6262 
6363 let collateralFactorStore = (assetIdStr + "_CollateralFactor")
6464 
6565 let liquidationThresholdStore = (assetIdStr + "_LiquidationThreshold")
6666 
6767 let overlapChargeStore = "account_health_overlap"
6868 
6969 let liquidationPenaltyStore = (assetIdStr + "_LiquidationPenalty")
7070 
7171 let configAddressStore = "configAddress"
7272 
7373 let aTokenIdStore = "aTokenId"
7474 
7575 let aTokenNameStore = "aTokenName"
7676 
7777 let aTokenCirculationStore = "aTokenCirculation"
7878 
7979 let lastUpdateHeightStore = "lastUpdateHeight"
8080 
8181 let totalDebtStore = "totalBorrow"
8282 
8383 let totalDepositStore = "totalDeposit"
8484 
8585 let totalReserveStore = "totalReserve"
8686 
8787 let indexStore = "storedIndex"
8888 
8989 let aTokenDecimalsStore = "aTokenDecimals"
9090 
9191 func aTokenBalanceStore (userAddress) = (userAddress + "_aTokenBalance")
9292 
9393 
9494 func debtStore (userAddress) = (userAddress + "_debt")
9595 
9696 
9797 func debtIndexStore (userAddress) = (userAddress + "_index")
9898 
9999 
100100 func useAsCollateralStore (userAddress) = (userAddress + "_useAsCollateral")
101101 
102102 
103103 func getBalance (addressOrAlias,assetId) = match assetId {
104104     case bv: ByteVector => 
105105         assetBalance(addressOrAlias, bv)
106106     case u: Unit => 
107107         wavesBalance(addressOrAlias).available
108108     case _ => 
109109         throw("Match error")
110110 }
111111 
112112 
113113 let assetDecimals = valueOrErrorMessage(getI(aTokenDecimalsStore), "no assetDecimals")
114114 
115115 let configAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, configAddressStore), "reserve: no configAddress")), "invalid config address")
116116 
117117 func opAllowed (op) = match invoke(configAddress, "opAllowed", [assetIdStr, op], nil) {
118118     case b: Boolean => 
119119         if (b)
120120             then true
121121             else throw("not allowed")
122122     case _ => 
123123         throw("opAllowed: unexpected result type")
124124 }
125125 
126126 
127127 let mainContract = valueOrErrorMessage(addressFromString(split(valueOrErrorMessage(getString(configAddress, "main"), "no main in config"), "|")[0]), "invalid main address")
128128 
129129 func mainOnly (i) = if (contains(getStringValue(configAddress, "main"), toString(i.caller)))
130130     then true
131131     else throw("only main can do")
132132 
133133 
134134 func divAdminOnly (i) = {
135135     let divAdmins = valueOrErrorMessage(getString(configAddress, "divAdmins"), "no div admins")
136136     if (!(contains(divAdmins, toString(i.caller))))
137137         then throw("only div admin can do")
138138         else true
139139     }
140140 
141141 
142142 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
143143     then (fromBase58String(value) == fromBase58String(""))
144144     else false)
145145     then throw("invalid assetId")
146146     else true
147147 
148148 
149149 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
150150 
151151 let maybeOracleAddress = match getString(configAddress, "oracle_address") {
152152     case s: String => 
153153         addressFromString(s)
154154     case _ => 
155155         unit
156156 }
157157 
158158 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [assetIdStr], nil) {
159159     case i: Int => 
160160         i
161161     case _ => 
162162         throw("bad oracle data")
163163 }
164164 
165165 let HEIGHT = height
166166 
167167 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
168168 
169169 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
170170 
171171 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
172172 
173173 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
174174 
175175 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
176176 
177177 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
178178 
179179 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
180180 
181181 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
182182 
183183 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
184184 
185185 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
186186 
187187 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
188188 
189189 let storedIndex = valueOrElse(getI(indexStore), RBase)
190190 
191191 let utilization = if ((storedTotalDeposit > 0))
192192     then min([factorsBase, fraction(storedTotalDebt, factorsBase, storedTotalDeposit)])
193193     else 0
194194 
195195 let apr = {
196196     let a = getIntegerValue(configAddress, (assetIdStr + "_APoint"))
197197     let b = getIntegerValue(configAddress, (assetIdStr + "_BPoint"))
198198     let c = getIntegerValue(configAddress, (assetIdStr + "_CPoint"))
199199     let d = getIntegerValue(configAddress, (assetIdStr + "_DPoint"))
200200     let lineAC = (fraction((a - c), utilization, -(b)) + a)
201201     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
202202     if ((utilization == 0))
203203         then a
204204         else if ((utilization == b))
205205             then c
206206             else if (if ((b > utilization))
207207                 then true
208208                 else (b == factorsBase))
209209                 then lineAC
210210                 else lineCD
211211     }
212212 
213213 let apy = if ((storedTotalDeposit == 0))
214214     then 0
215215     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
216216 
217217 let currentIndex = if ((HEIGHT == lastUpdateHeight))
218218     then storedIndex
219219     else {
220220         let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
221221         fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
222222         }
223223 
224224 let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
225225 
226226 let actualBalance = match assetId {
227227     case aid: ByteVector => 
228228         assetBalance(this, aid)
229229     case _ => 
230230         wavesBalance(this).available
231231 }
232232 
233233 func liquidityCheck (amount,max,err) = if ((amount > max))
234234     then throw(("not enough liquidity: " + err))
235235     else true
236236 
237237 
238238 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
239239 
240240 
241241 func currentUserDebt (userAddress) = {
242242     let v = storedUserDebt(userAddress)
243243     if ((v == 0))
244244         then 0
245245         else {
246246             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
247247             fraction(v, currentIndex, storedUserIndex)
248248             }
249249     }
250250 
251251 
252252 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
253253 
254254 let addedDebt = (currentTotalDebt - storedTotalDebt)
255255 
256256 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
257257 
258258 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
259259 
260260 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
261261 
262262 let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
263263 
264264 let claimableDividends = min([currentTotalReserve, if (stakingEnabled)
265265     then asInt(invoke(stakingAddress, "info", nil, nil))
266266     else actualBalance])
267267 
268268 func paymentAmount (i,assetId) = {
269269     let p = i.payments[0].amount
270270     if ((0 >= p))
271271         then throw(("Payment is less than min allowed amount: " + toString(p)))
272272         else if ((i.payments[0].assetId != assetId))
273273             then throw((" bad asset attached: required " + assetIdStr))
274274             else p
275275     }
276276 
277277 
278278 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
279279     let stakingAction = if ((actualBalance == keepAtBalance))
280280         then unit
281281         else if (!(stakingEnabled))
282282             then unit
283283             else if ((actualBalance > keepAtBalance))
284284                 then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
285285                 else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
286286     if ((stakingAction == stakingAction))
287287         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
288288         else throw("Strict value is not equal to itself.")
289289     }
290290 
291291 
292292 func pow10 (n) = if ((n == 6))
293293     then 1000000
294294     else if ((n == 8))
295295         then 100000000
296296         else throw(("bad decimals: " + toString(n)))
297297 
298298 
299299 func assetToUsd (amount) = fraction(amount, oraclePrice, pow10(assetDecimals))
300300 
301301 
302302 func usdToAsset (amount) = fraction(amount, pow10(assetDecimals), oraclePrice)
303303 
304304 
305305 func aTokenToAsset (aTokenAmount) = if ((aTokenAmount == 0))
306306     then 0
307307     else if ((aTokenCirculation > 0))
308308         then fraction(aTokenAmount, currentTotalDeposit, aTokenCirculation)
309309         else aTokenAmount
310310 
311311 
312312 func assetToAToken (assetAmount) = if ((assetAmount == 0))
313313     then 0
314314     else if ((aTokenCirculation > 0))
315315         then fraction(assetAmount, aTokenCirculation, currentTotalDeposit)
316316         else assetAmount
317317 
318318 
319319 func assetToATokenCeil (assetAmount) = if ((assetAmount == 0))
320320     then 0
321321     else if ((aTokenCirculation > 0))
322322         then fractionCeil(assetAmount, aTokenCirculation, currentTotalDeposit)
323323         else assetAmount
324324 
325325 
326326 func aTokenBalance (address) = valueOrElse(getI(aTokenBalanceStore(address)), 0)
327327 
328328 
329329 func enableCol (user) = BooleanEntry(useAsCollateralStore(user), true)
330330 
331331 
332332 func enableColIfNeeded (user) = if ((currentUserDebt(user) > 0))
333333     then [enableCol(user)]
334334     else nil
335335 
336336 
337337 func collapseUser (address,amount) = {
338338     let debt = currentUserDebt(address)
339339     let deposit = aTokenToAsset(aTokenBalance(address))
340340     let maxPossible = min([debt, deposit])
341341     let amt = if ((-1 > amount))
342342         then throw("invalid collapse amount")
343343         else if (if ((maxPossible == 0))
344344             then true
345345             else (amount == 0))
346346             then throw("nothing to collapse")
347347             else if (if ((amount == -1))
348348                 then true
349349                 else (amount > maxPossible))
350350                 then maxPossible
351351                 else amount
352352     let removedAtokens = assetToATokenCeil(amt)
353353     $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
354354     }
355355 
356356 
357357 func repayUser (userAddress,amount) = {
358358     let checks = opAllowed("repay")
359359     if ((checks == checks))
360360         then {
361361             let currentDebt = currentUserDebt(userAddress)
362362             if ((currentDebt == currentDebt))
363363                 then {
364364                     let $t01125511558 = if ((amount > currentDebt))
365365                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
366366                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
367367                     let newDebt = $t01125511558._1
368368                     let totalDebtUpdate = $t01125511558._2
369369                     let payout = $t01125511558._3
370370                     let actions = $t01125511558._4
371371                     let repaid = (amount - payout)
372372                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
373373                     }
374374                 else throw("Strict value is not equal to itself.")
375375             }
376376         else throw("Strict value is not equal to itself.")
377377     }
378378 
379379 
380380 func getConfig () = {
381381     let a = getIntegerValue(configAddress, (assetIdStr + "_APoint"))
382382     let b = getIntegerValue(configAddress, (assetIdStr + "_BPoint"))
383383     let c = getIntegerValue(configAddress, (assetIdStr + "_CPoint"))
384384     let d = getIntegerValue(configAddress, (assetIdStr + "_DPoint"))
385385     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
386386     }
387387 
388388 
389389 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))
390390 
391391 
392392 func getUserState (user) = {
393393     let aBalance = aTokenBalance(user)
394394     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
395395     ((((((((((((((((("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)))
396396     }
397397 
398398 
399399 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))))
400400 
401401 
402402 func userTotals (user) = {
403403     let atokens = aTokenBalance(user)
404404     let asset = aTokenToAsset(atokens)
405405     let debt = currentUserDebt(user)
406406     if ((HEIGHT == lastUpdateHeight))
407407         then $Tuple4(storedTotalDeposit, storedTotalDebt, asset, debt)
408408         else $Tuple4(currentTotalDeposit, currentTotalDebt, asset, debt)
409409     }
410410 
411411 
412412 func withdrawInternal (i,user,amount,toMain) = {
413413     let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
414414     let checks = if (if (if (mainOnly(i))
415415         then liquidityCheck(amount, maxWithdraw, ("funds in use: max=" + toString(maxWithdraw)))
416416         else false)
417417         then throwIf((-1 > amount), "invalid amount")
418418         else false)
419419         then opAllowed("withdraw")
420420         else false
421421     if ((checks == checks))
422422         then {
423423             let $t01544015631 = if ((amount == -1))
424424                 then {
425425                     let atokens = aTokenBalance(user)
426426                     $Tuple2(atokens, aTokenToAsset(atokens))
427427                     }
428428                 else $Tuple2(assetToATokenCeil(amount), amount)
429429             let removedAtokens = $t01544015631._1
430430             let withdrawAmount = $t01544015631._2
431431             $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(if (toMain)
432432                 then mainContract
433433                 else addressFromStringValue(user), withdrawAmount, assetId), changeBy(aTokenBalanceStore(user), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
434434             }
435435         else throw("Strict value is not equal to itself.")
436436     }
437437 
438438 
439439 func replenishInternal (op,user,i) = {
440440     let checks = if (mainOnly(i))
441441         then opAllowed(op)
442442         else false
443443     if ((checks == checks))
444444         then {
445445             let aTokenAmount = paymentAmount(i, aTokenId)
446446             $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
447447             }
448448         else throw("Strict value is not equal to itself.")
449449     }
450450 
451451 
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+
452470 @Callable(i)
453471 func getReserveDivsInfo () = $Tuple2(nil, $Tuple3(claimableDividends, assetIdStr, (currentTotalReserve - claimableDividends)))
454472 
455473 
456474 
457475 @Callable(i)
458476 func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
459477 
460478 
461479 
462480 @Callable(i)
463481 func getCurrentTotals2 (user1,user2) = {
464-    let $t01656016597 = userTotals(user1)
465-    let d1 = $t01656016597._1
466-    let d2 = $t01656016597._2
467-    let d3 = $t01656016597._3
468-    let d4 = $t01656016597._4
469-    let $t01660216639 = userTotals(user2)
470-    let e1 = $t01660216639._1
471-    let e2 = $t01660216639._2
472-    let e3 = $t01660216639._3
473-    let e4 = $t01660216639._4
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
474492     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
475493     }
476494 
477495 
478496 
479497 @Callable(i)
480498 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
481499 
482500 
483501 
484502 @Callable(i)
485503 func adviseUser (user) = {
486504     let currentDebtUsd = assetToUsd(currentTotalDebt)
487505     let currentDepositUsd = assetToUsd(currentTotalDeposit)
488506     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
489507     let effectiveDepositUsd = if (asCollateral)
490508         then currentDepositUsd
491509         else 0
492510     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
493511     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
494512     let bp = if ((currentDebtUsd > effectiveDepositUsd))
495513         then 0
496514         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
497515     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
498516         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
499517         else overlapCharge
500518     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
501519     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
502520     }
503521 
504522 
505523 
506524 @Callable(i)
507525 func addInterest () = if ((i.payments[0].assetId != assetId))
508526     then throw("can't add interest with unrelated token")
509527     else syncTotals(i.payments[0].amount, 0, 0, 0)
510528 
511529 
512530 
513531 @Callable(i)
514532 func addToReserve () = if ((i.payments[0].assetId != assetId))
515533     then throw("can't add interest with unrelated token")
516534     else syncTotals(0, 0, i.payments[0].amount, 0)
517535 
518536 
519537 
520538 @Callable(i)
521539 func withdrawFromReserve (amt) = {
522540     let checks = divAdminOnly(i)
523541     if ((checks == checks))
524542         then {
525543             let diff = if ((amt == -1))
526544                 then claimableDividends
527545                 else amt
528546             $Tuple2((syncTotals(0, 0, -(diff), diff) ++ [ScriptTransfer(i.caller, diff, assetId)]), diff)
529547             }
530548         else throw("Strict value is not equal to itself.")
531549     }
532550 
533551 
534552 
535553 @Callable(i)
536554 func forceUpdate () = {
537555     let admin = valueOrErrorMessage(getString(configAddress, "admin"), "reserve:no admin in config")
538556     if ((toString(i.caller) != admin))
539557         then throw("only admin can do")
540558         else syncTotals(0, 0, 0, 0)
541559     }
542560 
543561 
544562 
545563 @Callable(i)
546564 func initialize (cfgAddress,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
547565     let checks = if (notInitialized)
548566         then isAssetIdOrWaves(assetIdOrWaves)
549567         else false
550568     if ((checks == checks))
551569         then {
552570             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
553571 [aToken, writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken)))]
554572             }
555573         else throw("Strict value is not equal to itself.")
556574     }
557575 
558576 
559577 
560578 @Callable(i)
561579 func initialize2 () = if ((i.caller != this))
562580     then throw("only self can continue")
563581     else [writeInt(lastUpdateHeightStore, HEIGHT)]
564582 
565583 
566584 
567585 @Callable(i)
568586 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
569587 
570588 
571589 
572590 @Callable(i)
573591 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
574592 
575593 
576594 
577595 @Callable(i)
578596 func userBalance (address) = {
579597     let atokens = aTokenBalance(address)
580598     let asset = aTokenToAsset(atokens)
581599     let debt = currentUserDebt(address)
582600     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
583601     }
584602 
585603 
586604 
587605 @Callable(i)
588606 func userDebt (address) = {
589607     let debt = currentUserDebt(address)
590608     let debtUsd = assetToUsd(debt)
591609     $Tuple2(nil, $Tuple2(debt, debtUsd))
592610     }
593611 
594612 
595613 
596614 @Callable(i)
597615 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
598616 
599617 
600618 
601619 @Callable(i)
602620 func repayFor (userAddress) = {
603621     let checks = mainOnly(i)
604622     if ((checks == checks))
605623         then repayUser(userAddress, paymentAmount(i, assetId))
606624         else throw("Strict value is not equal to itself.")
607625     }
608626 
609627 
610628 
611629 @Callable(i)
612630 func depositFor (depositor,useAsCollateral) = {
613631     let checks = if (mainOnly(i))
614632         then opAllowed("deposit")
615633         else false
616634     if ((checks == checks))
617635         then if (if ((currentUserDebt(depositor) > 0))
618636             then !(useAsCollateral)
619637             else false)
620638             then throw("can't disable use as collateral for asset with open debt")
621639             else {
622640                 let amount = paymentAmount(i, assetId)
623641                 let aTokenAmount = assetToAToken(amount)
624642                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
625643                 }
626644         else throw("Strict value is not equal to itself.")
627645     }
628646 
629647 
630648 
631649 @Callable(i)
632650 func withdrawFor (address,amount) = withdrawInternal(i, address, amount, false)
633651 
634652 
635653 
636654 @Callable(i)
637655 func withdrawToMain (user,amount) = if ((amount != -1))
638656     then throw("reserve: withdrawToMain amount -1 only")
639657     else withdrawInternal(i, user, amount, true)
640658 
641659 
642660 
643661 @Callable(i)
644662 func replenishWithAtokenFor (user) = replenishInternal("replenish_atokens", user, i)
645663 
646664 
647665 
648666 @Callable(i)
649667 func replenishForRepayWithAtokenFor (user) = replenishInternal("repay_atokens", user, i)
650668 
651669 
652670 
653671 @Callable(i)
654672 func borrowFor (address,amountToBorrow) = {
655673     let checks = if (if (mainOnly(i))
656674         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
657675         else false)
658676         then opAllowed("borrow")
659677         else false
660678     if ((checks == checks))
661679         then {
662680             let currentDebt = currentUserDebt(address)
663681             let newDebt = (currentDebt + amountToBorrow)
664682             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
665683             }
666684         else throw("Strict value is not equal to itself.")
667685     }
668686 
669687 
670688 
671689 @Callable(i)
672-func mintAtokenFor (address,amountToMint) = {
673-    let userATokenBalance = aTokenBalance(address)
674-    let amount = if ((amountToMint == -1))
675-        then userATokenBalance
676-        else amountToMint
677-    let checks = if (if (if (mainOnly(i))
678-        then opAllowed("mint_atokens")
679-        else false)
680-        then throwIf((-1 > amountToMint), "invalid amountToMint")
681-        else false)
682-        then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
683-        else false
684-    if ((checks == checks))
685-        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
686-        else throw("Strict value is not equal to itself.")
687-    }
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)
688696 
689697 
690698 
691699 @Callable(i)
692700 func redeemAtokensFor (user) = {
693701     let checks = if (mainOnly(i))
694702         then opAllowed("redeem_atokens")
695703         else false
696704     if ((checks == checks))
697705         then {
698706             let aTokenAmount = paymentAmount(i, aTokenId)
699707             let outAmount = aTokenToAsset(aTokenAmount)
700708             $Tuple2((syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(addressFromStringValue(user), outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)]), outAmount)
701709             }
702710         else throw("Strict value is not equal to itself.")
703711     }
704712 
705713 
706714 
707715 @Callable(i)
708716 func transferATokensFor (from,to,valueUsd) = {
709717     let checks = if (mainOnly(i))
710718         then opAllowed("transfer_debt")
711719         else false
712720     if ((checks == checks))
713721         then {
714722             let assets = usdToAsset(valueUsd)
715723             let atokens = assetToAToken(assets)
716724             let aTokensFrom = aTokenBalance(from)
717725             if ((atokens > aTokensFrom))
718726                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
719727                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
720728             }
721729         else throw("Strict value is not equal to itself.")
722730     }
723731 
724732 
725733 
726734 @Callable(i)
727735 func transferDebtFor (from,to,amount) = {
728736     let checks = if (mainOnly(i))
729737         then opAllowed("transfer_debt")
730738         else false
731739     if ((checks == checks))
732740         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)
733741         else throw("Strict value is not equal to itself.")
734742     }
735743 
736744 
737745 
738746 @Callable(i)
739747 func disableUseAsCollateralFor (address) = {
740748     let checks = if (mainOnly(i))
741749         then opAllowed("use_as_col")
742750         else false
743751     if ((checks == checks))
744752         then if ((currentUserDebt(address) > 0))
745753             then throw("can't disable collateral for asset with open debt")
746754             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
747755         else throw("Strict value is not equal to itself.")
748756     }
749757 
750758 
751759 
752760 @Callable(i)
753761 func enableUseAsCollateral () = {
754762     let checks = opAllowed("use_as_col")
755763     if ((checks == checks))
756764         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
757765         else throw("Strict value is not equal to itself.")
758766     }
759767 
760768 
761769 
762770 @Callable(i)
763771 func collapseFor (user) = {
764772     let checks = if (mainOnly(i))
765773         then opAllowed("force_collapse")
766774         else false
767775     if ((checks == checks))
768776         then collapseUser(user, -1)
769777         else throw("Strict value is not equal to itself.")
770778     }
771779 
772780 
773781 
774782 @Callable(i)
775783 func collapseForAmount (user,amount) = {
776784     let checks = if (mainOnly(i))
777785         then opAllowed("collapse")
778786         else false
779787     if ((checks == checks))
780788         then collapseUser(user, amount)
781789         else throw("Strict value is not equal to itself.")
782790     }
783791 
784792 
github/deemru/w8io/786bc32 
102.76 ms ◑