2021.09.28 14:58 [2787790] smart account 3PGCkrHBxFMi7tz1xqnxgBpeNvn5E4M4g8S > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7GmXE3eG5gUtMJEEnSA7oNVkncYsUEnaH58pjPJVbDRp",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1632830184144,
    "version": 1,
    "sender": "3PGCkrHBxFMi7tz1xqnxgBpeNvn5E4M4g8S",
    "senderPublicKey": "CRRN9T4LWdYfw63q5x9XxR8P93XshdCac31Z65PbE6zv",
    "proofs": [
        "3ag6Dv7Q4qzdUSNgNuLecaCdcEZjVtwYbPLebbpQPeJwjj6yB5So8SSzPZsspJTeAHZPBvYwzqK9W4ShR2hmM782"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2787790,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: B5nZmyvVj1ppqHmEFj69cmsjLJSVrj35iX7gA2hBGxjt
Next: AHpGvd5jPFnPnk9vV8UpEgJjjm7mYw3mCGWKJCjnwzhg

Diff: 

OldNewDifferences
197197     else 0
198198 
199199 let apr = {
200-    let $t055315551 = ABCD
201-    let a = $t055315551._1
202-    let b = $t055315551._2
203-    let c = $t055315551._3
204-    let d = $t055315551._4
200+    let $t055325552 = ABCD
201+    let a = $t055325552._1
202+    let b = $t055325552._2
203+    let c = $t055325552._3
204+    let d = $t055325552._4
205205     let lineAC = (fraction((a - c), utilization, -(b)) + a)
206206     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
207207     if ((utilization == 0))
350350                 then maxPossible
351351                 else amount
352352     let removedAtokens = assetToATokenCeil(amt)
353-    (syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)])
353+    $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
354+    }
355+
356+
357+func repayUser (userAddress,amount) = {
358+    let checks = opAllowed("repay")
359+    if ((checks == checks))
360+        then {
361+            let currentDebt = currentUserDebt(userAddress)
362+            if ((currentDebt == currentDebt))
363+                then {
364+                    let $t01080011103 = if ((amount > currentDebt))
365+                        then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
366+                        else $Tuple4((currentDebt - amount), -(amount), 0, nil)
367+                    let newDebt = $t01080011103._1
368+                    let totalDebtUpdate = $t01080011103._2
369+                    let payout = $t01080011103._3
370+                    let actions = $t01080011103._4
371+                    let repaid = (amount - payout)
372+                    $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
373+                    }
374+                else throw("Strict value is not equal to itself.")
375+            }
376+        else throw("Strict value is not equal to itself.")
354377     }
355378 
356379 
357380 func getConfig () = {
358-    let $t01058410604 = ABCD
359-    let a = $t01058410604._1
360-    let b = $t01058410604._2
361-    let c = $t01058410604._3
362-    let d = $t01058410604._4
381+    let $t01133611356 = ABCD
382+    let a = $t01133611356._1
383+    let b = $t01133611356._2
384+    let c = $t01133611356._3
385+    let d = $t01133611356._4
363386     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
364387     }
365388 
375398 
376399 
377400 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))))
401+
402+
403+@Callable(i)
404+func getCurrentTotals () = $Tuple2(nil, $Tuple2(currentTotalDeposit, currentTotalDebt))
405+
378406 
379407 
380408 @Callable(i)
488516 
489517 
490518 @Callable(i)
491-func repay () = {
492-    let checks = opAllowed("repay")
519+func repayFor (userAddress) = {
520+    let checks = mainOnly(i)
493521     if ((checks == checks))
494-        then {
495-            let userAddress = toString(i.caller)
496-            let amount = paymentAmount(i, assetId)
497-            let currentDebt = currentUserDebt(userAddress)
498-            if ((currentDebt == currentDebt))
499-                then {
500-                    let $t01707317349 = if ((amount > currentDebt))
501-                        then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(i.caller, (amount - currentDebt), assetId)])
502-                        else $Tuple4((currentDebt - amount), -(amount), 0, nil)
503-                    let newDebt = $t01707317349._1
504-                    let totalDebtUpdate = $t01707317349._2
505-                    let payout = $t01707317349._3
506-                    let actions = $t01707317349._4
507-                    ((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)])
508-                    }
509-                else throw("Strict value is not equal to itself.")
510-            }
522+        then repayUser(userAddress, paymentAmount(i, assetId))
511523         else throw("Strict value is not equal to itself.")
512524     }
525+
526+
527+
528+@Callable(i)
529+func repay () = repayUser(toString(i.caller), paymentAmount(i, assetId))
513530 
514531 
515532 
534551 
535552 
536553 @Callable(i)
537-func replenishWithAtoken () = {
538-    let checks = opAllowed("atokens")
554+func withdrawFor (address,amount) = {
555+    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
556+    let checks = if (if (if (mainOnly(i))
557+        then liquidityCheck(amount, maxWithdraw, "funds in use")
558+        else false)
559+        then throwIf((-1 > amount), "invalid amount")
560+        else false)
561+        then opAllowed("withdraw")
562+        else false
563+    if ((checks == checks))
564+        then {
565+            let $t01891119105 = if ((amount == -1))
566+                then {
567+                    let atokens = aTokenBalance(address)
568+                    $Tuple2(atokens, aTokenToAsset(atokens))
569+                    }
570+                else $Tuple2(assetToATokenCeil(amount), amount)
571+            let removedAtokens = $t01891119105._1
572+            let withdrawAmount = $t01891119105._2
573+            $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
574+            }
575+        else throw("Strict value is not equal to itself.")
576+    }
577+
578+
579+
580+@Callable(i)
581+func replenishWithAtokenFor (user) = {
582+    let checks = if (mainOnly(i))
583+        then opAllowed("atokens")
584+        else false
539585     if ((checks == checks))
540586         then {
541587             let aTokenAmount = paymentAmount(i, aTokenId)
542-            let user = toString(i.caller)
543-            ((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user))
588+            $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
544589             }
545590         else throw("Strict value is not equal to itself.")
546591     }
556601         else false
557602     if ((checks == checks))
558603         then {
559-            let newDebt = (currentUserDebt(address) + amountToBorrow)
604+            let currentDebt = currentUserDebt(address)
605+            let newDebt = (currentDebt + amountToBorrow)
560606             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
561607             }
562608         else throw("Strict value is not equal to itself.")
578624         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
579625         else false
580626     if ((checks == checks))
581-        then (syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)])
627+        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
582628         else throw("Strict value is not equal to itself.")
583629     }
584630 
592638             let aTokenAmount = paymentAmount(i, aTokenId)
593639             let outAmount = aTokenToAsset(aTokenAmount)
594640             (syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(i.caller, outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)])
595-            }
596-        else throw("Strict value is not equal to itself.")
597-    }
598-
599-
600-
601-@Callable(i)
602-func withdrawFor (address,amount) = {
603-    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
604-    let checks = if (if (if (mainOnly(i))
605-        then liquidityCheck(amount, maxWithdraw, "funds in use")
606-        else false)
607-        then throwIf((-1 > amount), "invalid amount")
608-        else false)
609-        then opAllowed("withdraw")
610-        else false
611-    if ((checks == checks))
612-        then {
613-            let $t02051820712 = if ((amount == -1))
614-                then {
615-                    let atokens = aTokenBalance(address)
616-                    $Tuple2(atokens, aTokenToAsset(atokens))
617-                    }
618-                else $Tuple2(assetToATokenCeil(amount), amount)
619-            let removedAtokens = $t02051820712._1
620-            let withdrawAmount = $t02051820712._2
621-            (syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))])
622641             }
623642         else throw("Strict value is not equal to itself.")
624643     }
650669         then opAllowed("transfer_debt")
651670         else false
652671     if ((checks == checks))
653-        then (syncTotals(0, 0, 0, 0) ++ [writeInt(debtStore(from), (currentUserDebt(from) - amount)), writeInt(debtStore(to), (currentUserDebt(to) + amount)), writeInt(debtIndexStore(from), currentIndex), writeInt(debtIndexStore(to), currentIndex), enableCol(to)])
672+        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)
654673         else throw("Strict value is not equal to itself.")
655674     }
656675 
693712 
694713 
695714 @Callable(i)
715+func collapseForAmount (user,amount) = {
716+    let checks = if (mainOnly(i))
717+        then opAllowed("collapse")
718+        else false
719+    if ((checks == checks))
720+        then collapseUser(user, amount)
721+        else throw("Strict value is not equal to itself.")
722+    }
723+
724+
725+
726+@Callable(i)
696727 func collapseDebt (amount) = {
697728     let checks = opAllowed("collapse")
698729     if ((checks == checks))

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 func getI (key) = getInteger(this, key)
55 
66 
77 func getS (key) = getString(this, key)
88 
99 
1010 func getSV (key) = value(getString(this, key))
1111 
1212 
1313 func throwIf (condition,error) = if (condition)
1414     then throw(error)
1515     else true
1616 
1717 
1818 func writeInt (key,value) = if ((0 > value))
1919     then throw(((("writing negative value " + toString(value)) + " for key ") + key))
2020     else IntegerEntry(key, value)
2121 
2222 
2323 func changeBy (key,value) = writeInt(key, (valueOrElse(getI(key), 0) + value))
2424 
2525 
2626 func writeString (key,value) = StringEntry(key, value)
2727 
2828 
2929 func fractionCeil (value,numerator,denominator) = {
3030     let cand = fraction(value, numerator, denominator)
3131     let D = 3037000499
3232     let exact = ((((cand % D) * (denominator % D)) % D) == (((value % D) * (numerator % D)) % D))
3333     if (exact)
3434         then cand
3535         else (cand + 1)
3636     }
3737 
3838 
3939 let BlocksPerYear = 525600
4040 
4141 let RBase = 10000000000000000
4242 
4343 let factorsBase = 1000
4444 
4545 let assetIdStore = "assetId"
4646 
4747 let mainStore = "main"
4848 
4949 let reserveFactorStore = (getSV(assetIdStore) + "_ReserveFactor")
5050 
5151 let collateralFactorStore = (getSV(assetIdStore) + "_CollateralFactor")
5252 
5353 let liquidationThresholdStore = (getStringValue(assetIdStore) + "_LiquidationThreshold")
5454 
5555 let overlapChargeStore = "account_health_overlap"
5656 
5757 let liquidationPenaltyStore = (getStringValue(assetIdStore) + "_LiquidationPenalty")
5858 
5959 let configAddressStore = "configAddress"
6060 
6161 let oracleStore = "oracleAddress"
6262 
6363 let aTokenIdStore = "aTokenId"
6464 
6565 let aTokenNameStore = "aTokenName"
6666 
6767 let aTokenCirculationStore = "aTokenCirculation"
6868 
6969 let lastUpdateHeightStore = "lastUpdateHeight"
7070 
7171 let totalDebtStore = "totalBorrow"
7272 
7373 let totalDepositStore = "totalDeposit"
7474 
7575 let totalReserveStore = "totalReserve"
7676 
7777 let indexStore = "storedIndex"
7878 
7979 let aTokenDecimalsStore = "aTokenDecimals"
8080 
8181 func aTokenBalanceStore (userAddress) = (userAddress + "_aTokenBalance")
8282 
8383 
8484 func debtStore (userAddress) = (userAddress + "_debt")
8585 
8686 
8787 func debtIndexStore (userAddress) = (userAddress + "_index")
8888 
8989 
9090 func useAsCollateralStore (userAddress) = (userAddress + "_useAsCollateral")
9191 
9292 
9393 let assetId = {
9494     let id = valueOrErrorMessage(getS(assetIdStore), "no assetId")
9595     if ((id == "WAVES"))
9696         then unit
9797         else fromBase58String(id)
9898     }
9999 
100100 let assetIdStr = match assetId {
101101     case bv: ByteVector => 
102102         toBase58String(bv)
103103     case u: Unit => 
104104         "WAVES"
105105     case _ => 
106106         throw("Match error")
107107 }
108108 
109109 func getBalance (addressOrAlias,assetId) = match assetId {
110110     case bv: ByteVector => 
111111         assetBalance(addressOrAlias, bv)
112112     case u: Unit => 
113113         wavesBalance(addressOrAlias).available
114114     case _ => 
115115         throw("Match error")
116116 }
117117 
118118 
119119 let assetDecimals = valueOrErrorMessage(getI(aTokenDecimalsStore), "no assetDecimals")
120120 
121121 let configAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getS(configAddressStore), "no configAddress")), "invalid config address")
122122 
123123 func opAllowed (op) = {
124124     let aid = valueOrErrorMessage(getS(assetIdStore), "no assetId")
125125     match invoke(configAddress, "opAllowed", [aid, op], nil) {
126126         case b: Boolean => 
127127             if (b)
128128                 then true
129129                 else throw("not allowed")
130130         case _ => 
131131             throw("opAllowed: unexpected result type")
132132     }
133133     }
134134 
135135 
136136 func mainOnly (i) = if ((i.caller != valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, mainStore), "no main in config")), "invalid main address")))
137137     then throw("only main can do")
138138     else true
139139 
140140 
141141 func isAssetIdOrWaves (value) = if (if ((value != "WAVES"))
142142     then (fromBase58String(value) == fromBase58String(""))
143143     else false)
144144     then throw("invalid assetId")
145145     else true
146146 
147147 
148148 let notInitialized = throwIf(isDefined(getS(assetIdStore)), "already initialized")
149149 
150150 let maybeOracleAddress = match getS(oracleStore) {
151151     case s: String => 
152152         addressFromString(s)
153153     case _ => 
154154         unit
155155 }
156156 
157157 let oraclePrice = match invoke(valueOrErrorMessage(maybeOracleAddress, "no oracle"), "price", [getSV(assetIdStore)], nil) {
158158     case i: Int => 
159159         i
160160     case _ => 
161161         throw("bad oracle data")
162162 }
163163 
164164 let HEIGHT = height
165165 
166166 let lastUpdateHeight = valueOrErrorMessage(getI(lastUpdateHeightStore), "no lastUpdateHeight")
167167 
168168 let aTokenId = fromBase58String(valueOrErrorMessage(getS(aTokenIdStore), "no aTokenId"))
169169 
170170 let aTokenCirculation = valueOrElse(getI(aTokenCirculationStore), 0)
171171 
172172 let ABCD = {
173173     let id = getSV(assetIdStore)
174174     $Tuple4(getIntegerValue(configAddress, (id + "_APoint")), getIntegerValue(configAddress, (id + "_BPoint")), getIntegerValue(configAddress, (id + "_CPoint")), getIntegerValue(configAddress, (id + "_DPoint")))
175175     }
176176 
177177 let reserveFactor = valueOrErrorMessage(getInteger(configAddress, reserveFactorStore), "no reserveFactor")
178178 
179179 let collateralFactor = valueOrErrorMessage(getInteger(configAddress, collateralFactorStore), "no collateralFactor")
180180 
181181 let liquidationThreshold = valueOrErrorMessage(getInteger(configAddress, liquidationThresholdStore), "no liquidationThreshold")
182182 
183183 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, overlapChargeStore), "no overlapCharge")
184184 
185185 let liquidationPenalty = valueOrErrorMessage(getInteger(configAddress, liquidationPenaltyStore), "no liquidationPenalty")
186186 
187187 let storedTotalDeposit = valueOrElse(getI(totalDepositStore), 0)
188188 
189189 let storedTotalReserve = valueOrElse(getI(totalReserveStore), 0)
190190 
191191 let storedTotalDebt = valueOrElse(getI(totalDebtStore), 0)
192192 
193193 let storedIndex = valueOrElse(getI(indexStore), RBase)
194194 
195195 let utilization = if ((storedTotalDeposit > 0))
196196     then fraction(storedTotalDebt, factorsBase, storedTotalDeposit)
197197     else 0
198198 
199199 let apr = {
200-    let $t055315551 = ABCD
201-    let a = $t055315551._1
202-    let b = $t055315551._2
203-    let c = $t055315551._3
204-    let d = $t055315551._4
200+    let $t055325552 = ABCD
201+    let a = $t055325552._1
202+    let b = $t055325552._2
203+    let c = $t055325552._3
204+    let d = $t055325552._4
205205     let lineAC = (fraction((a - c), utilization, -(b)) + a)
206206     let lineCD = (fraction((c - d), (utilization - b), (b - factorsBase)) + c)
207207     if ((utilization == 0))
208208         then a
209209         else if ((utilization == b))
210210             then c
211211             else if (if ((b > utilization))
212212                 then true
213213                 else (b == factorsBase))
214214                 then lineAC
215215                 else lineCD
216216     }
217217 
218218 let apy = if ((storedTotalDeposit == 0))
219219     then 0
220220     else fraction(fraction(storedTotalDebt, apr, storedTotalDeposit), (factorsBase - reserveFactor), factorsBase)
221221 
222222 let currentIndex = {
223223     let bpr = fractionCeil(apr, RBase, (BlocksPerYear * factorsBase))
224224     fractionCeil(storedIndex, (RBase + (bpr * (HEIGHT - lastUpdateHeight))), RBase)
225225     }
226226 
227227 func liquidityCheck (amount,max,err) = if ((amount > max))
228228     then throw(("not enough liquidity: " + err))
229229     else true
230230 
231231 
232232 func storedUserDebt (userAddress) = valueOrElse(getI(debtStore(userAddress)), 0)
233233 
234234 
235235 func currentUserDebt (userAddress) = {
236236     let v = storedUserDebt(userAddress)
237237     if ((v == 0))
238238         then 0
239239         else {
240240             let storedUserIndex = valueOrErrorMessage(getI(debtIndexStore(userAddress)), "has debt but does not have index")
241241             fraction(v, currentIndex, storedUserIndex)
242242             }
243243     }
244244 
245245 
246246 let currentTotalDebt = fraction(storedTotalDebt, currentIndex, storedIndex)
247247 
248248 let addedDebt = (currentTotalDebt - storedTotalDebt)
249249 
250250 let addedDeposit = fraction(addedDebt, (factorsBase - reserveFactor), factorsBase)
251251 
252252 let currentTotalDeposit = (storedTotalDeposit + addedDeposit)
253253 
254254 let currentTotalReserve = ((storedTotalReserve + addedDebt) - addedDeposit)
255255 
256256 func paymentAmount (i,assetId) = {
257257     let p = i.payments[0].amount
258258     if ((0 >= p))
259259         then throw("Payment is less than min allowed amount")
260260         else if ((i.payments[0].assetId != assetId))
261261             then throw(("bad asset attached: required " + assetIdStr))
262262             else p
263263     }
264264 
265265 
266266 func syncTotals (additionalDeposit,additionalDebt,additionalReserve,keepAtBalance) = {
267267     let actualBalance =     match assetId {
268268         case aid: ByteVector => 
269269             assetBalance(this, aid)
270270         case _ => 
271271             wavesBalance(this).available
272272     }
273273     let stakingAction = if ((actualBalance == keepAtBalance))
274274         then unit
275275         else {
276276             let stakingEnabled = valueOrElse(getBoolean(configAddress, ("staking_enabled_" + assetIdStr)), false)
277277             if (!(stakingEnabled))
278278                 then unit
279279                 else {
280280                     let stakingAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, ("staking_config_" + assetIdStr)), ("no staking address for " + assetIdStr))), ("bad staking address for " + assetIdStr))
281281                     if ((actualBalance > keepAtBalance))
282282                         then invoke(stakingAddress, "put", nil, [AttachedPayment(assetId, (actualBalance - keepAtBalance))])
283283                         else invoke(stakingAddress, "get", [(keepAtBalance - actualBalance)], nil)
284284                     }
285285             }
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)
353-    (syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)])
353+    $Tuple2((syncTotals(-(amt), -(amt), 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens)), writeInt(debtStore(address), (debt - amt)), writeInt(debtIndexStore(address), currentIndex)]), amt)
354+    }
355+
356+
357+func repayUser (userAddress,amount) = {
358+    let checks = opAllowed("repay")
359+    if ((checks == checks))
360+        then {
361+            let currentDebt = currentUserDebt(userAddress)
362+            if ((currentDebt == currentDebt))
363+                then {
364+                    let $t01080011103 = if ((amount > currentDebt))
365+                        then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(addressFromStringValue(userAddress), (amount - currentDebt), assetId)])
366+                        else $Tuple4((currentDebt - amount), -(amount), 0, nil)
367+                    let newDebt = $t01080011103._1
368+                    let totalDebtUpdate = $t01080011103._2
369+                    let payout = $t01080011103._3
370+                    let actions = $t01080011103._4
371+                    let repaid = (amount - payout)
372+                    $Tuple2(((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)]), repaid)
373+                    }
374+                else throw("Strict value is not equal to itself.")
375+            }
376+        else throw("Strict value is not equal to itself.")
354377     }
355378 
356379 
357380 func getConfig () = {
358-    let $t01058410604 = ABCD
359-    let a = $t01058410604._1
360-    let b = $t01058410604._2
361-    let c = $t01058410604._3
362-    let d = $t01058410604._4
381+    let $t01133611356 = ABCD
382+    let a = $t01133611356._1
383+    let b = $t01133611356._2
384+    let c = $t01133611356._3
385+    let d = $t01133611356._4
363386     ((((((((((((((("ABCD: " + toString(a)) + ";") + toString(b)) + ";") + toString(c)) + ";") + toString(d)) + ", reserveFactor: ") + toString(reserveFactor)) + ", collateralFactor: ") + toString(collateralFactor)) + ", liquidationThreshold: ") + toString(liquidationThreshold)) + ", liquidationPenalty: ") + toString(liquidationPenalty))
364387     }
365388 
366389 
367390 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))
368391 
369392 
370393 func getUserState (user) = {
371394     let aBalance = aTokenBalance(user)
372395     let aBalanceWallet = getBalance(addressFromStringValue(user), aTokenId)
373396     ((((((((((((((((("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)))
374397     }
375398 
376399 
377400 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))))
401+
402+
403+@Callable(i)
404+func getCurrentTotals () = $Tuple2(nil, $Tuple2(currentTotalDeposit, currentTotalDebt))
405+
378406 
379407 
380408 @Callable(i)
381409 func advise () = $Tuple2(nil, ((((("reserveAddress: " + toString(this)) + ", ") + getConfig()) + ", ") + getState()))
382410 
383411 
384412 
385413 @Callable(i)
386414 func adviseUser (user) = {
387415     let currentDebtUsd = assetToUsd(currentTotalDebt)
388416     let currentDepositUsd = assetToUsd(currentTotalDeposit)
389417     let asCollateral = valueOrElse(getBoolean(this, useAsCollateralStore(user)), true)
390418     let effectiveDepositUsd = if (asCollateral)
391419         then currentDepositUsd
392420         else 0
393421     let overlapUsd = min([currentDebtUsd, effectiveDepositUsd])
394422     let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
395423     let bp = if ((currentDebtUsd > effectiveDepositUsd))
396424         then 0
397425         else fraction((effectiveDepositUsd - currentDebtUsd), collateralFactor, factorsBase)
398426     let bpu = if ((currentDebtUsd > effectiveDepositUsd))
399427         then (fraction((currentDebtUsd - effectiveDepositUsd), factorsBase, liquidationThreshold) + overlapCharge)
400428         else overlapCharge
401429     let enriched = ((((((((("reserveAddress: " + toString(this)) + ", currentDebtUsd: ") + toString(currentDebtUsd)) + ", currentDepositUsd: ") + toString(currentDepositUsd)) + ", bp: ") + toString(bp)) + ", bpu: ") + toString(bpu))
402430     $Tuple2(nil, ((enriched + ", ") + getUserState(user)))
403431     }
404432 
405433 
406434 
407435 @Callable(i)
408436 func addInterest () = if ((i.payments[0].assetId != assetId))
409437     then throw("can't add interest with unrelated token")
410438     else syncTotals(i.payments[0].amount, 0, 0, 0)
411439 
412440 
413441 
414442 @Callable(i)
415443 func addToReserve () = if ((i.payments[0].assetId != assetId))
416444     then throw("can't add interest with unrelated token")
417445     else syncTotals(0, 0, i.payments[0].amount, 0)
418446 
419447 
420448 
421449 @Callable(i)
422450 func withdrawFromReserve (amt) = {
423451     let admin = getStringValue(configAddress, "admin")
424452     if ((toString(i.caller) != admin))
425453         then throw("only admin can do")
426454         else (syncTotals(0, 0, -(amt), amt) ++ [ScriptTransfer(addressFromStringValue(admin), amt, assetId)])
427455     }
428456 
429457 
430458 
431459 @Callable(i)
432460 func forceUpdate () = {
433461     let admin = getStringValue(configAddress, "admin")
434462     if ((toString(i.caller) != admin))
435463         then throw("only admin can do")
436464         else syncTotals(0, 0, 0, 0)
437465     }
438466 
439467 
440468 
441469 @Callable(i)
442470 func initialize (cfgAddress,oracleAddr,assetIdOrWaves,aTokenName,aTokenDescription,aTokenDecimals) = {
443471     let checks = if (notInitialized)
444472         then isAssetIdOrWaves(assetIdOrWaves)
445473         else false
446474     if ((checks == checks))
447475         then {
448476             let aToken = Issue(aTokenName, aTokenDescription, 0, aTokenDecimals, true)
449477 [aToken, writeString(oracleStore, oracleAddr), writeInt(aTokenDecimalsStore, aTokenDecimals), writeString(aTokenNameStore, aTokenName), writeString(assetIdStore, assetIdOrWaves), writeString(configAddressStore, cfgAddress), writeString(aTokenIdStore, toBase58String(calculateAssetId(aToken))), writeInt(lastUpdateHeightStore, HEIGHT)]
450478             }
451479         else throw("Strict value is not equal to itself.")
452480     }
453481 
454482 
455483 
456484 @Callable(i)
457485 func userDepositUSD (address) = $Tuple2(nil, assetToUsd(aTokenToAsset(aTokenBalance(address))))
458486 
459487 
460488 
461489 @Callable(i)
462490 func userDebtUSD (address) = $Tuple2(nil, assetToUsd(currentUserDebt(address)))
463491 
464492 
465493 
466494 @Callable(i)
467495 func userBalance (address) = {
468496     let atokens = aTokenBalance(address)
469497     let asset = aTokenToAsset(atokens)
470498     let debt = currentUserDebt(address)
471499     $Tuple2(nil, $Tuple6(atokens, asset, assetToUsd(asset), debt, assetToUsd(debt), valueOrElse(getBoolean(this, useAsCollateralStore(address)), true)))
472500     }
473501 
474502 
475503 
476504 @Callable(i)
477505 func userDebt (address) = {
478506     let debt = currentUserDebt(address)
479507     let debtUsd = assetToUsd(debt)
480508     $Tuple2(nil, $Tuple2(debt, debtUsd))
481509     }
482510 
483511 
484512 
485513 @Callable(i)
486514 func assetUsdValue (assetAmount) = $Tuple2(nil, assetToUsd(assetAmount))
487515 
488516 
489517 
490518 @Callable(i)
491-func repay () = {
492-    let checks = opAllowed("repay")
519+func repayFor (userAddress) = {
520+    let checks = mainOnly(i)
493521     if ((checks == checks))
494-        then {
495-            let userAddress = toString(i.caller)
496-            let amount = paymentAmount(i, assetId)
497-            let currentDebt = currentUserDebt(userAddress)
498-            if ((currentDebt == currentDebt))
499-                then {
500-                    let $t01707317349 = if ((amount > currentDebt))
501-                        then $Tuple4(0, -(currentDebt), (amount - currentDebt), [ScriptTransfer(i.caller, (amount - currentDebt), assetId)])
502-                        else $Tuple4((currentDebt - amount), -(amount), 0, nil)
503-                    let newDebt = $t01707317349._1
504-                    let totalDebtUpdate = $t01707317349._2
505-                    let payout = $t01707317349._3
506-                    let actions = $t01707317349._4
507-                    ((syncTotals(0, totalDebtUpdate, 0, payout) ++ actions) ++ [writeInt(debtStore(userAddress), newDebt), writeInt(debtIndexStore(userAddress), currentIndex)])
508-                    }
509-                else throw("Strict value is not equal to itself.")
510-            }
522+        then repayUser(userAddress, paymentAmount(i, assetId))
511523         else throw("Strict value is not equal to itself.")
512524     }
525+
526+
527+
528+@Callable(i)
529+func repay () = repayUser(toString(i.caller), paymentAmount(i, assetId))
513530 
514531 
515532 
516533 @Callable(i)
517534 func depositFor (depositor,useAsCollateral) = {
518535     let checks = if (mainOnly(i))
519536         then opAllowed("deposit")
520537         else false
521538     if ((checks == checks))
522539         then if (if ((currentUserDebt(depositor) > 0))
523540             then !(useAsCollateral)
524541             else false)
525542             then throw("can't disable use as collateral for asset with open debt")
526543             else {
527544                 let amount = paymentAmount(i, assetId)
528545                 let aTokenAmount = assetToAToken(amount)
529546                 (syncTotals(amount, 0, 0, 0) ++ [changeBy(aTokenCirculationStore, aTokenAmount), changeBy(aTokenBalanceStore(depositor), aTokenAmount), BooleanEntry(useAsCollateralStore(depositor), useAsCollateral)])
530547                 }
531548         else throw("Strict value is not equal to itself.")
532549     }
533550 
534551 
535552 
536553 @Callable(i)
537-func replenishWithAtoken () = {
538-    let checks = opAllowed("atokens")
554+func withdrawFor (address,amount) = {
555+    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
556+    let checks = if (if (if (mainOnly(i))
557+        then liquidityCheck(amount, maxWithdraw, "funds in use")
558+        else false)
559+        then throwIf((-1 > amount), "invalid amount")
560+        else false)
561+        then opAllowed("withdraw")
562+        else false
563+    if ((checks == checks))
564+        then {
565+            let $t01891119105 = if ((amount == -1))
566+                then {
567+                    let atokens = aTokenBalance(address)
568+                    $Tuple2(atokens, aTokenToAsset(atokens))
569+                    }
570+                else $Tuple2(assetToATokenCeil(amount), amount)
571+            let removedAtokens = $t01891119105._1
572+            let withdrawAmount = $t01891119105._2
573+            $Tuple2((syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))]), withdrawAmount)
574+            }
575+        else throw("Strict value is not equal to itself.")
576+    }
577+
578+
579+
580+@Callable(i)
581+func replenishWithAtokenFor (user) = {
582+    let checks = if (mainOnly(i))
583+        then opAllowed("atokens")
584+        else false
539585     if ((checks == checks))
540586         then {
541587             let aTokenAmount = paymentAmount(i, aTokenId)
542-            let user = toString(i.caller)
543-            ((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user))
588+            $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(user), aTokenAmount), Burn(aTokenId, aTokenAmount)]) ++ enableColIfNeeded(user)), aTokenToAsset(aTokenAmount))
544589             }
545590         else throw("Strict value is not equal to itself.")
546591     }
547592 
548593 
549594 
550595 @Callable(i)
551596 func borrowFor (address,amountToBorrow) = {
552597     let checks = if (if (mainOnly(i))
553598         then liquidityCheck(amountToBorrow, (storedTotalDeposit - storedTotalDebt), "too much borrow requested")
554599         else false)
555600         then opAllowed("borrow")
556601         else false
557602     if ((checks == checks))
558603         then {
559-            let newDebt = (currentUserDebt(address) + amountToBorrow)
604+            let currentDebt = currentUserDebt(address)
605+            let newDebt = (currentDebt + amountToBorrow)
560606             (syncTotals(0, amountToBorrow, 0, amountToBorrow) ++ [writeInt(debtStore(address), newDebt), enableCol(address), writeInt(debtIndexStore(address), currentIndex), ScriptTransfer(addressFromStringValue(address), amountToBorrow, assetId)])
561607             }
562608         else throw("Strict value is not equal to itself.")
563609     }
564610 
565611 
566612 
567613 @Callable(i)
568614 func mintAtokenFor (address,amountToMint) = {
569615     let userATokenBalance = aTokenBalance(address)
570616     let amount = if ((amountToMint == -1))
571617         then userATokenBalance
572618         else amountToMint
573619     let checks = if (if (if (mainOnly(i))
574620         then opAllowed("atokens")
575621         else false)
576622         then throwIf((-1 > amountToMint), "invalid amountToMint")
577623         else false)
578624         then throwIf((amount > userATokenBalance), ("Trying to mint more than available, max: " + toString(userATokenBalance)))
579625         else false
580626     if ((checks == checks))
581-        then (syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)])
627+        then $Tuple2((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(address), -(amount)), Reissue(aTokenId, amount, true), ScriptTransfer(addressFromStringValue(address), amount, aTokenId)]), aTokenToAsset(amount))
582628         else throw("Strict value is not equal to itself.")
583629     }
584630 
585631 
586632 
587633 @Callable(i)
588634 func redeemAtokens () = {
589635     let checks = opAllowed("atokens")
590636     if ((checks == checks))
591637         then {
592638             let aTokenAmount = paymentAmount(i, aTokenId)
593639             let outAmount = aTokenToAsset(aTokenAmount)
594640             (syncTotals(-(outAmount), 0, 0, outAmount) ++ [ScriptTransfer(i.caller, outAmount, assetId), changeBy(aTokenCirculationStore, -(aTokenAmount)), Burn(aTokenId, aTokenAmount)])
595-            }
596-        else throw("Strict value is not equal to itself.")
597-    }
598-
599-
600-
601-@Callable(i)
602-func withdrawFor (address,amount) = {
603-    let maxWithdraw = ((storedTotalDeposit + storedTotalReserve) - storedTotalDebt)
604-    let checks = if (if (if (mainOnly(i))
605-        then liquidityCheck(amount, maxWithdraw, "funds in use")
606-        else false)
607-        then throwIf((-1 > amount), "invalid amount")
608-        else false)
609-        then opAllowed("withdraw")
610-        else false
611-    if ((checks == checks))
612-        then {
613-            let $t02051820712 = if ((amount == -1))
614-                then {
615-                    let atokens = aTokenBalance(address)
616-                    $Tuple2(atokens, aTokenToAsset(atokens))
617-                    }
618-                else $Tuple2(assetToATokenCeil(amount), amount)
619-            let removedAtokens = $t02051820712._1
620-            let withdrawAmount = $t02051820712._2
621-            (syncTotals(-(withdrawAmount), 0, 0, withdrawAmount) ++ [ScriptTransfer(addressFromStringValue(address), withdrawAmount, assetId), changeBy(aTokenBalanceStore(address), -(removedAtokens)), changeBy(aTokenCirculationStore, -(removedAtokens))])
622641             }
623642         else throw("Strict value is not equal to itself.")
624643     }
625644 
626645 
627646 
628647 @Callable(i)
629648 func transferATokensFor (from,to,valueUsd) = {
630649     let checks = if (mainOnly(i))
631650         then opAllowed("transfer_debt")
632651         else false
633652     if ((checks == checks))
634653         then {
635654             let assets = usdToAsset(valueUsd)
636655             let atokens = assetToAToken(assets)
637656             let aTokensFrom = aTokenBalance(from)
638657             if ((atokens > aTokensFrom))
639658                 then throw((((((((((("transferAtokensFor error:" + " transfer.valueUsd: ") + toString(valueUsd)) + " transfer.assets: ") + toString(assets)) + " transfer.atokens: ") + toString(atokens)) + " from.atokens: ") + toString(aTokensFrom)) + " at ") + toString(this)))
640659                 else $Tuple2(((syncTotals(0, 0, 0, 0) ++ [changeBy(aTokenBalanceStore(from), -(atokens)), changeBy(aTokenBalanceStore(to), atokens)]) ++ enableColIfNeeded(to)), aTokenToAsset(atokens))
641660             }
642661         else throw("Strict value is not equal to itself.")
643662     }
644663 
645664 
646665 
647666 @Callable(i)
648667 func transferDebtFor (from,to,amount) = {
649668     let checks = if (mainOnly(i))
650669         then opAllowed("transfer_debt")
651670         else false
652671     if ((checks == checks))
653-        then (syncTotals(0, 0, 0, 0) ++ [writeInt(debtStore(from), (currentUserDebt(from) - amount)), writeInt(debtStore(to), (currentUserDebt(to) + amount)), writeInt(debtIndexStore(from), currentIndex), writeInt(debtIndexStore(to), currentIndex), enableCol(to)])
672+        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)
654673         else throw("Strict value is not equal to itself.")
655674     }
656675 
657676 
658677 
659678 @Callable(i)
660679 func disableUseAsCollateralFor (address) = {
661680     let checks = if (mainOnly(i))
662681         then opAllowed("use_as_col")
663682         else false
664683     if ((checks == checks))
665684         then if ((currentUserDebt(address) > 0))
666685             then throw("can't disable collateral for asset with open debt")
667686             else (syncTotals(0, 0, 0, 0) ++ [BooleanEntry(useAsCollateralStore(address), false)])
668687         else throw("Strict value is not equal to itself.")
669688     }
670689 
671690 
672691 
673692 @Callable(i)
674693 func enableUseAsCollateral () = {
675694     let checks = opAllowed("use_as_col")
676695     if ((checks == checks))
677696         then (syncTotals(0, 0, 0, 0) ++ [enableCol(toString(i.caller))])
678697         else throw("Strict value is not equal to itself.")
679698     }
680699 
681700 
682701 
683702 @Callable(i)
684703 func collapseFor (user) = {
685704     let checks = if (mainOnly(i))
686705         then opAllowed("force_collapse")
687706         else false
688707     if ((checks == checks))
689708         then collapseUser(user, -1)
690709         else throw("Strict value is not equal to itself.")
691710     }
692711 
693712 
694713 
695714 @Callable(i)
715+func collapseForAmount (user,amount) = {
716+    let checks = if (mainOnly(i))
717+        then opAllowed("collapse")
718+        else false
719+    if ((checks == checks))
720+        then collapseUser(user, amount)
721+        else throw("Strict value is not equal to itself.")
722+    }
723+
724+
725+
726+@Callable(i)
696727 func collapseDebt (amount) = {
697728     let checks = opAllowed("collapse")
698729     if ((checks == checks))
699730         then collapseUser(toString(i.caller), amount)
700731         else throw("Strict value is not equal to itself.")
701732     }
702733 
703734 
github/deemru/w8io/786bc32 
88.79 ms ◑