2022.01.24 20:20 [2958430] smart account 3PCwFXSq8vj8iKitA5zrrLRbuqehfmimpce > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9AarjCEw53nVdUUf3frhNK6fJLBujkeBD13vcH7xBXNE",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1643044713650,
    "version": 1,
    "sender": "3PCwFXSq8vj8iKitA5zrrLRbuqehfmimpce",
    "senderPublicKey": "9iqTo4hVx8TfXiitFf4xY1DGQbccrLGt37iRETBSeBXx",
    "proofs": [
        "2zJHCrkFJBrYQakiwZHNVzREhYX9sDKpUHRFTWgWiNnrbzdwiXdxDuiq5ryQrFCuxrpJH8eWh5ufxkZRiNKLxPAS"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2958430,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8YVgVNtxx2NSP2Dnm8xM3k7sB1sz1ChE5tgF3dRroPXN
Next: 2nR7BBnuWTynb28i6t6bPujt5R1a9DPuGCaTU8hkyW2D

Diff: 

OldNewDifferences
133133     }
134134 
135135 
136-func mainOnly (i) = if ((i.caller != valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")))
136+let mainContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")
137+
138+func mainOnly (i) = if ((i.caller != mainContract))
137139     then throw("only main can do")
138140     else true
139141 
205207     else 0
206208 
207209 let apr = {
208-    let $t057585778 = ABCD
209-    let a = $t057585778._1
210-    let b = $t057585778._2
211-    let c = $t057585778._3
212-    let d = $t057585778._4
210+    let $t057915811 = ABCD
211+    let a = $t057915811._1
212+    let b = $t057915811._2
213+    let c = $t057915811._3
214+    let d = $t057915811._4
213215     let lineAC = (fraction((a - c), utilization, -(b)) + a)
214216     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
215217     if ((utilization == 0))
268270     if ((0 >= p))
269271         then throw("Payment is less than min allowed amount")
270272         else if ((i.payments[0].assetId != assetId))
271-            then throw(("bad asset attached: required " + assetIdStr))
273+            then throw((" bad asset attached: required " + assetIdStr))
272274             else p
273275     }
274276 
371373             let currentDebt = currentUserDebt(userAddress)
372374             if ((currentDebt == currentDebt))
373375                 then {
374-                    let $t01109511398 = if ((amount > currentDebt))
376+                    let $t01112911432 = if ((amount > currentDebt))
375377                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
376378                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
377-                    let newDebt = $t01109511398._1
378-                    let totalDebtUpdate = $t01109511398._2
379-                    let payout = $t01109511398._3
380-                    let actions = $t01109511398._4
379+                    let newDebt = $t01112911432._1
380+                    let totalDebtUpdate = $t01112911432._2
381+                    let payout = $t01112911432._3
382+                    let actions = $t01112911432._4
381383                     let repaid = (amount - payout)
382384                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
383385                     }
388390 
389391 
390392 func getConfig () = {
391-    let $t01163111651 = ABCD
392-    let a = $t01163111651._1
393-    let b = $t01163111651._2
394-    let c = $t01163111651._3
395-    let d = $t01163111651._4
393+    let $t01166511685 = ABCD
394+    let a = $t01166511685._1
395+    let b = $t01166511685._2
396+    let c = $t01166511685._3
397+    let d = $t01166511685._4
396398     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
397399     }
398400 
420422     }
421423 
422424 
425+func withdrawInternal (i,user,amount,toMain) = {
426+    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
427+    let checks = if (if (if (mainOnly(i))
428+        then liquidityCheck(amount, maxWithdraw, "funds in use")
429+        else false)
430+        then throwIf((-1 > amount), "invalid amount")
431+        else false)
432+        then opAllowed("withdraw")
433+        else false
434+    if ((checks == checks))
435+        then {
436+            let $t01504815239 = if ((amount == -1))
437+                then {
438+                    let atokens = aTokenBalance(user)
439+                    $Tuple2(atokens, aTokenToAsset(atokens))
440+                    }
441+                else $Tuple2(assetToATokenCeil(amount), amount)
442+            let removedAtokens = $t01504815239._1
443+            let withdrawAmount = $t01504815239._2
444+            $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(if (toMain)
445+                then mainContract
446+                else addressFromStringValue(user), withdrawAmount, assetId), changeBy(aTokenBalanceStore(user), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
447+            }
448+        else throw("Strict value is not equal to itself.")
449+    }
450+
451+
423452 @Callable(i)
424453 func getReserveDivsInfo () = $Tuple2(nil, $Tuple2(currentTotalReserve, assetIdStr))
425454 
432461 
433462 @Callable(i)
434463 func getCurrentTotals2 (user1,user2) = {
435-    let $t01486214899 = userTotals(user1)
436-    let d1 = $t01486214899._1
437-    let d2 = $t01486214899._2
438-    let d3 = $t01486214899._3
439-    let d4 = $t01486214899._4
440-    let $t01490414941 = userTotals(user2)
441-    let e1 = $t01490414941._1
442-    let e2 = $t01490414941._2
443-    let e3 = $t01490414941._3
444-    let e4 = $t01490414941._4
464+    let $t01578715824 = userTotals(user1)
465+    let d1 = $t01578715824._1
466+    let d2 = $t01578715824._2
467+    let d3 = $t01578715824._3
468+    let d4 = $t01578715824._4
469+    let $t01582915866 = userTotals(user2)
470+    let e1 = $t01582915866._1
471+    let e2 = $t01582915866._2
472+    let e3 = $t01582915866._3
473+    let e4 = $t01582915866._4
445474     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
446475     }
447476 
593622 
594623 
595624 @Callable(i)
596-func withdrawFor (address,amount) = {
597-    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
598-    let checks = if (if (if (mainOnly(i))
599-        then liquidityCheck(amount, maxWithdraw, "funds in use")
600-        else false)
601-        then throwIf((-1 > amount), "invalid amount")
602-        else false)
603-        then opAllowed("withdraw")
604-        else false
605-    if ((checks == checks))
606-        then {
607-            let $t01957619770 = if ((amount == -1))
608-                then {
609-                    let atokens = aTokenBalance(address)
610-                    $Tuple2(atokens, aTokenToAsset(atokens))
611-                    }
612-                else $Tuple2(assetToATokenCeil(amount), amount)
613-            let removedAtokens = $t01957619770._1
614-            let withdrawAmount = $t01957619770._2
615-            $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
616-            }
617-        else throw("Strict value is not equal to itself.")
618-    }
625+func withdrawFor (address,amount) = withdrawInternal(i, address, amount, false)
626+
627+
628+
629+@Callable(i)
630+func withdrawToMain (user,amount) = if ((amount != -1))
631+    then throw("reserve: withdrawToMain amount -1 only")
632+    else withdrawInternal(i, user, amount, true)
619633 
620634 
621635 

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 
136-func mainOnly (i) = if ((i.caller != valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")))
136+let mainContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")
137+
138+func mainOnly (i) = if ((i.caller != mainContract))
137139     then throw("only main can do")
138140     else true
139141 
140142 
141143 func divAdminOnly (i) = {
142144     let divAdmins = valueOrErrorMessage(getString(configAddress, "divAdmins"), "no div admins")
143145     if (!(contains(divAdmins, toString(i.caller))))
144146         then throw("only div admin can do")
145147         else true
146148     }
147149 
148150 
149151 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
150152     then (fromBase58String(value) == fromBase58String(""))
151153     else false)
152154     then throw("invalid assetId")
153155     else true
154156 
155157 
156158 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
157159 
158160 let maybeOracleAddress = match getS(oracleStore) {
159161     case s: String => 
160162         addressFromString(s)
161163     case _ => 
162164         unit
163165 }
164166 
165167 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [getSV(assetIdStore)], nil) {
166168     case i: Int => 
167169         i
168170     case _ => 
169171         throw("bad oracle data")
170172 }
171173 
172174 let HEIGHT = height
173175 
174176 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
175177 
176178 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
177179 
178180 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
179181 
180182 let ABCD = {
181183     let id = getSV(assetIdStore)
182184     $Tuple4(getIntegerValue(configAddress, (id + "_APoint")), getIntegerValue(configAddress, (id + "_BPoint")), getIntegerValue(configAddress, (id + "_CPoint")), getIntegerValue(configAddress, (id + "_DPoint")))
183185     }
184186 
185187 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
186188 
187189 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
188190 
189191 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
190192 
191193 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
192194 
193195 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
194196 
195197 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
196198 
197199 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
198200 
199201 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
200202 
201203 let storedIndex = valueOrElse(getI(indexStore), RBase)
202204 
203205 let utilization = if ((storedTotalDeposit > 0))
204206     then fraction(storedTotalDebt, factorsBase, storedTotalDeposit)
205207     else 0
206208 
207209 let apr = {
208-    let $t057585778 = ABCD
209-    let a = $t057585778._1
210-    let b = $t057585778._2
211-    let c = $t057585778._3
212-    let d = $t057585778._4
210+    let $t057915811 = ABCD
211+    let a = $t057915811._1
212+    let b = $t057915811._2
213+    let c = $t057915811._3
214+    let d = $t057915811._4
213215     let lineAC = (fraction((a - c), utilization, -(b)) + a)
214216     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
215217     if ((utilization == 0))
216218         then a
217219         else if ((utilization == b))
218220             then c
219221             else if (if ((b > utilization))
220222                 then true
221223                 else (b == factorsBase))
222224                 then lineAC
223225                 else lineCD
224226     }
225227 
226228 let apy = if ((storedTotalDeposit == 0))
227229     then 0
228230     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
229231 
230232 let currentIndex = if ((HEIGHT == lastUpdateHeight))
231233     then storedIndex
232234     else {
233235         let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
234236         fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
235237         }
236238 
237239 func liquidityCheck (amount,max,err) = if ((amount > max))
238240     then throw(("not enough liquidity: " + err))
239241     else true
240242 
241243 
242244 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
243245 
244246 
245247 func currentUserDebt (userAddress) = {
246248     let v = storedUserDebt(userAddress)
247249     if ((v == 0))
248250         then 0
249251         else {
250252             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
251253             fraction(v, currentIndex, storedUserIndex)
252254             }
253255     }
254256 
255257 
256258 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
257259 
258260 let addedDebt = (currentTotalDebt - storedTotalDebt)
259261 
260262 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
261263 
262264 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
263265 
264266 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
265267 
266268 func paymentAmount (i,assetId) = {
267269     let p = i.payments[0].amount
268270     if ((0 >= p))
269271         then throw("Payment is less than min allowed amount")
270272         else if ((i.payments[0].assetId != assetId))
271-            then throw(("bad asset attached: required " + assetIdStr))
273+            then throw((" bad asset attached: required " + assetIdStr))
272274             else p
273275     }
274276 
275277 
276278 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
277279     let actualBalance =     match assetId {
278280         case aid: ByteVector => 
279281             assetBalance(this, aid)
280282         case _ => 
281283             wavesBalance(this).available
282284     }
283285     let stakingAction = if ((actualBalance == keepAtBalance))
284286         then unit
285287         else {
286288             let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
287289             if (!(stakingEnabled))
288290                 then unit
289291                 else {
290292                     let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
291293                     if ((actualBalance > keepAtBalance))
292294                         then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
293295                         else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
294296                     }
295297             }
296298     if ((stakingAction == stakingAction))
297299         then [writeInt(indexStore, currentIndex), writeInt(lastUpdateHeightStore, HEIGHT), writeInt(totalDepositStore, (currentTotalDeposit + additionalDeposit)), writeInt(totalDebtStore, (currentTotalDebt + additionalDebt)), writeInt(totalReserveStore, (currentTotalReserve + additionalReserve))]
298300         else throw("Strict value is not equal to itself.")
299301     }
300302 
301303 
302304 func pow10 (n) = if ((n == 6))
303305     then 1000000
304306     else if ((n == 8))
305307         then 100000000
306308         else throw(("bad decimals: " + toString(n)))
307309 
308310 
309311 func assetToUsd (amount) = fraction(amount, oraclePrice, pow10(assetDecimals))
310312 
311313 
312314 func usdToAsset (amount) = fraction(amount, pow10(assetDecimals), oraclePrice)
313315 
314316 
315317 func aTokenToAsset (aTokenAmount) = if ((aTokenAmount == 0))
316318     then 0
317319     else if ((aTokenCirculation > 0))
318320         then fraction(aTokenAmount, currentTotalDeposit, aTokenCirculation)
319321         else aTokenAmount
320322 
321323 
322324 func assetToAToken (assetAmount) = if ((assetAmount == 0))
323325     then 0
324326     else if ((aTokenCirculation > 0))
325327         then fraction(assetAmount, aTokenCirculation, currentTotalDeposit)
326328         else assetAmount
327329 
328330 
329331 func assetToATokenCeil (assetAmount) = if ((assetAmount == 0))
330332     then 0
331333     else if ((aTokenCirculation > 0))
332334         then fractionCeil(assetAmount, aTokenCirculation, currentTotalDeposit)
333335         else assetAmount
334336 
335337 
336338 func aTokenBalance (address) = valueOrElse(getI(aTokenBalanceStore(address)), 0)
337339 
338340 
339341 func enableCol (user) = BooleanEntry(useAsCollateralStore(user), true)
340342 
341343 
342344 func enableColIfNeeded (user) = if ((currentUserDebt(user) > 0))
343345     then [enableCol(user)]
344346     else nil
345347 
346348 
347349 func collapseUser (address,amount) = {
348350     let debt = currentUserDebt(address)
349351     let deposit = aTokenToAsset(aTokenBalance(address))
350352     let maxPossible = min([debt, deposit])
351353     let amt = if ((-1 > amount))
352354         then throw("invalid collapse amount")
353355         else if (if ((maxPossible == 0))
354356             then true
355357             else (amount == 0))
356358             then throw("nothing to collapse")
357359             else if (if ((amount == -1))
358360                 then true
359361                 else (amount > maxPossible))
360362                 then maxPossible
361363                 else amount
362364     let removedAtokens = assetToATokenCeil(amt)
363365     $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
364366     }
365367 
366368 
367369 func repayUser (userAddress,amount) = {
368370     let checks = opAllowed("repay")
369371     if ((checks == checks))
370372         then {
371373             let currentDebt = currentUserDebt(userAddress)
372374             if ((currentDebt == currentDebt))
373375                 then {
374-                    let $t01109511398 = if ((amount > currentDebt))
376+                    let $t01112911432 = if ((amount > currentDebt))
375377                         then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
376378                         else $Tuple4((currentDebt - amount), -(amount), 0, nil)
377-                    let newDebt = $t01109511398._1
378-                    let totalDebtUpdate = $t01109511398._2
379-                    let payout = $t01109511398._3
380-                    let actions = $t01109511398._4
379+                    let newDebt = $t01112911432._1
380+                    let totalDebtUpdate = $t01112911432._2
381+                    let payout = $t01112911432._3
382+                    let actions = $t01112911432._4
381383                     let repaid = (amount - payout)
382384                     $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
383385                     }
384386                 else throw("Strict value is not equal to itself.")
385387             }
386388         else throw("Strict value is not equal to itself.")
387389     }
388390 
389391 
390392 func getConfig () = {
391-    let $t01163111651 = ABCD
392-    let a = $t01163111651._1
393-    let b = $t01163111651._2
394-    let c = $t01163111651._3
395-    let d = $t01163111651._4
393+    let $t01166511685 = ABCD
394+    let a = $t01166511685._1
395+    let b = $t01166511685._2
396+    let c = $t01166511685._3
397+    let d = $t01166511685._4
396398     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
397399     }
398400 
399401 
400402 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))
401403 
402404 
403405 func getUserState (user) = {
404406     let aBalance = aTokenBalance(user)
405407     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
406408     ((((((((((((((((("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)))
407409     }
408410 
409411 
410412 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))))
411413 
412414 
413415 func userTotals (user) = {
414416     let atokens = aTokenBalance(user)
415417     let asset = aTokenToAsset(atokens)
416418     let debt = currentUserDebt(user)
417419     if ((HEIGHT == lastUpdateHeight))
418420         then $Tuple4(storedTotalDeposit, storedTotalDebt, asset, debt)
419421         else $Tuple4(currentTotalDeposit, currentTotalDebt, asset, debt)
420422     }
421423 
422424 
425+func withdrawInternal (i,user,amount,toMain) = {
426+    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
427+    let checks = if (if (if (mainOnly(i))
428+        then liquidityCheck(amount, maxWithdraw, "funds in use")
429+        else false)
430+        then throwIf((-1 > amount), "invalid amount")
431+        else false)
432+        then opAllowed("withdraw")
433+        else false
434+    if ((checks == checks))
435+        then {
436+            let $t01504815239 = if ((amount == -1))
437+                then {
438+                    let atokens = aTokenBalance(user)
439+                    $Tuple2(atokens, aTokenToAsset(atokens))
440+                    }
441+                else $Tuple2(assetToATokenCeil(amount), amount)
442+            let removedAtokens = $t01504815239._1
443+            let withdrawAmount = $t01504815239._2
444+            $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(if (toMain)
445+                then mainContract
446+                else addressFromStringValue(user), withdrawAmount, assetId), changeBy(aTokenBalanceStore(user), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
447+            }
448+        else throw("Strict value is not equal to itself.")
449+    }
450+
451+
423452 @Callable(i)
424453 func getReserveDivsInfo () = $Tuple2(nil, $Tuple2(currentTotalReserve, assetIdStr))
425454 
426455 
427456 
428457 @Callable(i)
429458 func getCurrentTotals (user) = $Tuple2(nil, userTotals(user))
430459 
431460 
432461 
433462 @Callable(i)
434463 func getCurrentTotals2 (user1,user2) = {
435-    let $t01486214899 = userTotals(user1)
436-    let d1 = $t01486214899._1
437-    let d2 = $t01486214899._2
438-    let d3 = $t01486214899._3
439-    let d4 = $t01486214899._4
440-    let $t01490414941 = userTotals(user2)
441-    let e1 = $t01490414941._1
442-    let e2 = $t01490414941._2
443-    let e3 = $t01490414941._3
444-    let e4 = $t01490414941._4
464+    let $t01578715824 = userTotals(user1)
465+    let d1 = $t01578715824._1
466+    let d2 = $t01578715824._2
467+    let d3 = $t01578715824._3
468+    let d4 = $t01578715824._4
469+    let $t01582915866 = userTotals(user2)
470+    let e1 = $t01582915866._1
471+    let e2 = $t01582915866._2
472+    let e3 = $t01582915866._3
473+    let e4 = $t01582915866._4
445474     $Tuple2(nil, $Tuple6(d1, d2, d3, d4, e3, e4))
446475     }
447476 
448477 
449478 
450479 @Callable(i)
451480 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
452481 
453482 
454483 
455484 @Callable(i)
456485 func adviseUser (user) = {
457486     let currentDebtUsd = assetToUsd(currentTotalDebt)
458487     let currentDepositUsd = assetToUsd(currentTotalDeposit)
459488     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
460489     let effectiveDepositUsd = if (asCollateral)
461490         then currentDepositUsd
462491         else 0
463492     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
464493     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
465494     let bp = if ((currentDebtUsd > effectiveDepositUsd))
466495         then 0
467496         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
468497     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
469498         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
470499         else overlapCharge
471500     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
472501     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
473502     }
474503 
475504 
476505 
477506 @Callable(i)
478507 func addInterest () = if ((i.payments[0].assetId != assetId))
479508     then throw("can't add interest with unrelated token")
480509     else syncTotals(i.payments[0].amount, 0, 0, 0)
481510 
482511 
483512 
484513 @Callable(i)
485514 func addToReserve () = if ((i.payments[0].assetId != assetId))
486515     then throw("can't add interest with unrelated token")
487516     else syncTotals(0, 0, i.payments[0].amount, 0)
488517 
489518 
490519 
491520 @Callable(i)
492521 func withdrawFromReserve (amt) = {
493522     let checks = divAdminOnly(i)
494523     if ((checks == checks))
495524         then {
496525             let diff = if ((amt == -1))
497526                 then currentTotalReserve
498527                 else amt
499528             $Tuple2((syncTotals(0, 0, -(diff), diff) ++ [ScriptTransfer(i.caller, diff, assetId)]), diff)
500529             }
501530         else throw("Strict value is not equal to itself.")
502531     }
503532 
504533 
505534 
506535 @Callable(i)
507536 func forceUpdate () = {
508537     let admin = getStringValue(configAddress, "admin")
509538     if ((toString(i.caller) != admin))
510539         then throw("only admin can do")
511540         else syncTotals(0, 0, 0, 0)
512541     }
513542 
514543 
515544 
516545 @Callable(i)
517546 func initialize (cfgAddress,oracleAddr,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
518547     let checks = if (notInitialized)
519548         then isAssetIdOrWaves(assetIdOrWaves)
520549         else false
521550     if ((checks == checks))
522551         then {
523552             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
524553 [aToken, writeString(oracleStore, oracleAddr), writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken))), writeInt(lastUpdateHeightStore, HEIGHT)]
525554             }
526555         else throw("Strict value is not equal to itself.")
527556     }
528557 
529558 
530559 
531560 @Callable(i)
532561 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
533562 
534563 
535564 
536565 @Callable(i)
537566 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
538567 
539568 
540569 
541570 @Callable(i)
542571 func userBalance (address) = {
543572     let atokens = aTokenBalance(address)
544573     let asset = aTokenToAsset(atokens)
545574     let debt = currentUserDebt(address)
546575     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
547576     }
548577 
549578 
550579 
551580 @Callable(i)
552581 func userDebt (address) = {
553582     let debt = currentUserDebt(address)
554583     let debtUsd = assetToUsd(debt)
555584     $Tuple2(nil, $Tuple2(debt, debtUsd))
556585     }
557586 
558587 
559588 
560589 @Callable(i)
561590 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
562591 
563592 
564593 
565594 @Callable(i)
566595 func repayFor (userAddress) = {
567596     let checks = mainOnly(i)
568597     if ((checks == checks))
569598         then repayUser(userAddress, paymentAmount(i, assetId))
570599         else throw("Strict value is not equal to itself.")
571600     }
572601 
573602 
574603 
575604 @Callable(i)
576605 func depositFor (depositor,useAsCollateral) = {
577606     let checks = if (mainOnly(i))
578607         then opAllowed("deposit")
579608         else false
580609     if ((checks == checks))
581610         then if (if ((currentUserDebt(depositor) > 0))
582611             then !(useAsCollateral)
583612             else false)
584613             then throw("can't disable use as collateral for asset with open debt")
585614             else {
586615                 let amount = paymentAmount(i, assetId)
587616                 let aTokenAmount = assetToAToken(amount)
588617                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
589618                 }
590619         else throw("Strict value is not equal to itself.")
591620     }
592621 
593622 
594623 
595624 @Callable(i)
596-func withdrawFor (address,amount) = {
597-    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
598-    let checks = if (if (if (mainOnly(i))
599-        then liquidityCheck(amount, maxWithdraw, "funds in use")
600-        else false)
601-        then throwIf((-1 > amount), "invalid amount")
602-        else false)
603-        then opAllowed("withdraw")
604-        else false
605-    if ((checks == checks))
606-        then {
607-            let $t01957619770 = if ((amount == -1))
608-                then {
609-                    let atokens = aTokenBalance(address)
610-                    $Tuple2(atokens, aTokenToAsset(atokens))
611-                    }
612-                else $Tuple2(assetToATokenCeil(amount), amount)
613-            let removedAtokens = $t01957619770._1
614-            let withdrawAmount = $t01957619770._2
615-            $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
616-            }
617-        else throw("Strict value is not equal to itself.")
618-    }
625+func withdrawFor (address,amount) = withdrawInternal(i, address, amount, false)
626+
627+
628+
629+@Callable(i)
630+func withdrawToMain (user,amount) = if ((amount != -1))
631+    then throw("reserve: withdrawToMain amount -1 only")
632+    else withdrawInternal(i, user, amount, true)
619633 
620634 
621635 
622636 @Callable(i)
623637 func replenishWithAtokenFor (user) = {
624638     let checks = if (mainOnly(i))
625639         then opAllowed("atokens")
626640         else false
627641     if ((checks == checks))
628642         then {
629643             let aTokenAmount = paymentAmount(i, aTokenId)
630644             $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
631645             }
632646         else throw("Strict value is not equal to itself.")
633647     }
634648 
635649 
636650 
637651 @Callable(i)
638652 func borrowFor (address,amountToBorrow) = {
639653     let checks = if (if (mainOnly(i))
640654         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
641655         else false)
642656         then opAllowed("borrow")
643657         else false
644658     if ((checks == checks))
645659         then {
646660             let currentDebt = currentUserDebt(address)
647661             let newDebt = (currentDebt + amountToBorrow)
648662             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
649663             }
650664         else throw("Strict value is not equal to itself.")
651665     }
652666 
653667 
654668 
655669 @Callable(i)
656670 func mintAtokenFor (address,amountToMint) = {
657671     let userATokenBalance = aTokenBalance(address)
658672     let amount = if ((amountToMint == -1))
659673         then userATokenBalance
660674         else amountToMint
661675     let checks = if (if (if (mainOnly(i))
662676         then opAllowed("atokens")
663677         else false)
664678         then throwIf((-1 > amountToMint), "invalid amountToMint")
665679         else false)
666680         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
667681         else false
668682     if ((checks == checks))
669683         then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
670684         else throw("Strict value is not equal to itself.")
671685     }
672686 
673687 
674688 
675689 @Callable(i)
676690 func redeemAtokensFor (user) = {
677691     let checks = if (mainOnly(i))
678692         then opAllowed("atokens")
679693         else false
680694     if ((checks == checks))
681695         then {
682696             let aTokenAmount = paymentAmount(i, aTokenId)
683697             let outAmount = aTokenToAsset(aTokenAmount)
684698             $Tuple2((syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(addressFromStringValue(user), outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)]), outAmount)
685699             }
686700         else throw("Strict value is not equal to itself.")
687701     }
688702 
689703 
690704 
691705 @Callable(i)
692706 func transferATokensFor (from,to,valueUsd) = {
693707     let checks = if (mainOnly(i))
694708         then opAllowed("transfer_debt")
695709         else false
696710     if ((checks == checks))
697711         then {
698712             let assets = usdToAsset(valueUsd)
699713             let atokens = assetToAToken(assets)
700714             let aTokensFrom = aTokenBalance(from)
701715             if ((atokens > aTokensFrom))
702716                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
703717                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
704718             }
705719         else throw("Strict value is not equal to itself.")
706720     }
707721 
708722 
709723 
710724 @Callable(i)
711725 func transferDebtFor (from,to,amount) = {
712726     let checks = if (mainOnly(i))
713727         then opAllowed("transfer_debt")
714728         else false
715729     if ((checks == checks))
716730         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)
717731         else throw("Strict value is not equal to itself.")
718732     }
719733 
720734 
721735 
722736 @Callable(i)
723737 func disableUseAsCollateralFor (address) = {
724738     let checks = if (mainOnly(i))
725739         then opAllowed("use_as_col")
726740         else false
727741     if ((checks == checks))
728742         then if ((currentUserDebt(address) > 0))
729743             then throw("can't disable collateral for asset with open debt")
730744             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
731745         else throw("Strict value is not equal to itself.")
732746     }
733747 
734748 
735749 
736750 @Callable(i)
737751 func enableUseAsCollateral () = {
738752     let checks = opAllowed("use_as_col")
739753     if ((checks == checks))
740754         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
741755         else throw("Strict value is not equal to itself.")
742756     }
743757 
744758 
745759 
746760 @Callable(i)
747761 func collapseFor (user) = {
748762     let checks = if (mainOnly(i))
749763         then opAllowed("force_collapse")
750764         else false
751765     if ((checks == checks))
752766         then collapseUser(user, -1)
753767         else throw("Strict value is not equal to itself.")
754768     }
755769 
756770 
757771 
758772 @Callable(i)
759773 func collapseForAmount (user,amount) = {
760774     let checks = if (mainOnly(i))
761775         then opAllowed("collapse")
762776         else false
763777     if ((checks == checks))
764778         then collapseUser(user, amount)
765779         else throw("Strict value is not equal to itself.")
766780     }
767781 
768782 
github/deemru/w8io/786bc32 
120.31 ms ◑