2022.03.11 10:35 [3024124] smart account 3PAZv9tgK1PX7dKR7b4kchq5qdpUS3G5sYT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Dmgi6FXUV4QaEQPFGxxa25dYa9m7YXitjLV5Eko4j5gw",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1646984002461,
    "version": 1,
    "sender": "3PAZv9tgK1PX7dKR7b4kchq5qdpUS3G5sYT",
    "senderPublicKey": "2cFG5wZimjVSeCT8ZCRybx7Mzo5tJF879aw2b31uLRmR",
    "proofs": [
        "2x7TTZ9aaNcwp9vWdvvV8eqntkSWqaWPh19q49S9QFEkyGfN5EKakJA3F7wNR7wUnyQzTKQtYRw3vDCpwKu6Bjw4"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3024124,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9t3TBRnN6tq3JWXAUDXjn1TJcgxGFLPQn8t7M9HaEhSo
Next: GPqPcWqYHNssKezTg34GapBCp2YKXCSBdqKAssMxg6xp

Diff: 

OldNewDifferences
348348     let claimedEb = asInt(invoke(ebR, "claimEbRewardFor", [user, -1], nil))
349349     if ((claimedEb == claimedEb))
350350         then {
351-            let rewardReserves = split(valueOrErrorMessage(getString(VD, "reward_reserves"), "no string"), "|")
351+            let rewardReserves = split(valueOrErrorMessage(getString(configAddress, "rewardable_reserves"), "no string"), "|")
352352             func fold (acc,reserve) =             {
353353                 let claimed = asInt(invoke(VD, "claimRewardFor", [reserve, user, -1], nil))
354354                 if ((claimed == claimed))
410410                         else if ((liquidator == borrower))
411411                             then throw("can't liquidate self")
412412                             else {
413-                                let $t01049710532 = userPower(borrower)
414-                                let bp = $t01049710532._1
415-                                let bpu = $t01049710532._2
413+                                let $t01051210547 = userPower(borrower)
414+                                let bp = $t01051210547._1
415+                                let bpu = $t01051210547._2
416416                                 if ((bp > bpu))
417417                                     then throw(((((("can't liquidate healthy user: u=" + borrower) + ", bp=") + toString(bp)) + ", bpu=") + toString(bpu)))
418418                                     else {
427427                                                 else false)
428428                                                 then throw("can't liquidate deposit not used as collateral")
429429                                                 else {
430-                                                    let $t01119711287 = userBalance(br, borrower)
431-                                                    if (($t01119711287 == $t01119711287))
430+                                                    let $t01121211302 = userBalance(br, borrower)
431+                                                    if (($t01121211302 == $t01121211302))
432432                                                         then {
433-                                                            let userDebtUsd = $t01119711287._5
434-                                                            let userDebt = $t01119711287._4
435-                                                            let userAssetUsd = $t01119711287._3
436-                                                            let userAsset = $t01119711287._2
437-                                                            let ignore = $t01119711287._1
433+                                                            let userDebtUsd = $t01121211302._5
434+                                                            let userDebt = $t01121211302._4
435+                                                            let userAssetUsd = $t01121211302._3
436+                                                            let userAsset = $t01121211302._2
437+                                                            let ignore = $t01121211302._1
438438                                                             if ((userAsset >= userDebt))
439439                                                                 then throw("can't liquidate debt of asset of positive saldo")
440440                                                                 else if ((0 >= liquidateDebtAmount))
499499                 then if ((liquidator == borrower))
500500                     then throw("can't collapse self in this function")
501501                     else {
502-                        let $t01297413009 = userPower(borrower)
503-                        let bp = $t01297413009._1
504-                        let bpu = $t01297413009._2
502+                        let $t01298913024 = userPower(borrower)
503+                        let bp = $t01298913024._1
504+                        let bpu = $t01298913024._2
505505                         if ((bp > bpu))
506506                             then throw(((((("can't force collapse healthy user: u=" + borrower) + ", bp=") + toString(bp)) + ", bpu=") + toString(bpu)))
507507                             else {
511511                                     else unit
512512                                 if ((mc == mc))
513513                                     then {
514-                                        let $t01338513493 = userBalance(reserveAddress, borrower)
515-                                        if (($t01338513493 == $t01338513493))
514+                                        let $t01340013508 = userBalance(reserveAddress, borrower)
515+                                        if (($t01340013508 == $t01340013508))
516516                                             then {
517-                                                let userDebtUsd = $t01338513493._5
518-                                                let userDebt = $t01338513493._4
519-                                                let userAssetUsd = $t01338513493._3
520-                                                let borrowerDeposit = $t01338513493._2
521-                                                let ignore = $t01338513493._1
517+                                                let userDebtUsd = $t01340013508._5
518+                                                let userDebt = $t01340013508._4
519+                                                let userAssetUsd = $t01340013508._3
520+                                                let borrowerDeposit = $t01340013508._2
521+                                                let ignore = $t01340013508._1
522522                                                 let penaltizedUsd = fraction(min([userAssetUsd, userDebtUsd]), collapsePenalty, factorsBase)
523523                                                 let transferredAssets = asInt(invoke(reserveAddress, "transferATokensFor", [borrower, liquidator, penaltizedUsd], nil))
524524                                                 if ((transferredAssets == transferredAssets))

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let factorsBase = 1000
55 
66 func fractionCeil (value,numerator,denominator) = {
77     let cand = fraction(value, numerator, denominator)
88     let D = 3037000499
99     let exact = ((((cand % D) * (denominator % D)) % D) == (((value % D) * (numerator % D)) % D))
1010     if (exact)
1111         then cand
1212         else (cand + 1)
1313     }
1414 
1515 
1616 func assetStrToId (assetId) = if ((assetId == "WAVES"))
1717     then unit
1818     else fromBase58String(assetId)
1919 
2020 
2121 func writeConstString (key,value) = if (!(isDefined(getString(this, key))))
2222     then StringEntry(key, value)
2323     else throw(("already initialized: " + key))
2424 
2525 
2626 func asInt (value) = match value {
2727     case int: Int => 
2828         int
2929     case _ => 
3030         throw("wrong type, expected: Int")
3131 }
3232 
3333 
3434 func asInt2 (value) = match value {
3535     case x: (Int, Int) => 
3636         x
3737     case t => 
3838         throw("wrong type, expected: Int2")
3939 }
4040 
4141 
4242 func asInt3 (value) = match value {
4343     case x: (Int, Int, Int) => 
4444         x
4545     case t => 
4646         throw("wrong type, expected: Int3")
4747 }
4848 
4949 
5050 func asInt4 (value) = match value {
5151     case x: (Int, Int, Int, Int) => 
5252         x
5353     case t => 
5454         throw("wrong type, expected: Int4")
5555 }
5656 
5757 
5858 func asInt5 (value) = match value {
5959     case x: (Int, Int, Int, Int, Int) => 
6060         x
6161     case t => 
6262         throw("wrong type, expected: Int5")
6363 }
6464 
6565 
6666 func asUserBalanceData (value) = match value {
6767     case x: (Int, Int, Int, Int, Int, Boolean) => 
6868         x
6969     case t => 
7070         throw("wrong type, expected: Int5&Boolean")
7171 }
7272 
7373 
7474 let configStore = "config"
7575 
7676 let reservesStore = "reserves"
7777 
7878 let aTokenIdStore = "aTokenId"
7979 
8080 let assetIdStore = "assetId"
8181 
8282 let distributorStore = "vires_distributor"
8383 
8484 let configAddress = addressFromStringValue(getStringValue(this, configStore))
8585 
8686 let reservesStr = valueOrErrorMessage(getString(configAddress, "primary_reserves"), "no reserves registered")
8787 
8888 let reserves = split(reservesStr, "|")
8989 
9090 let ebR = addressFromStringValue(valueOrErrorMessage(getString(configAddress, "eb_rewards"), "no eb_rewards contract in config"))
9191 
9292 let viresMinter = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, "vires_minter"), "main: no viresMinter")), "invalid viresMinter")
9393 
9494 let maybevS = getString(configAddress, "vires_staker")
9595 
9696 let vS = addressFromStringValue(valueOrErrorMessage(maybevS, "no vires_staker"))
9797 
9898 let dC = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, "dividends_contract"), "no dividends_contract")), "invalid dividends_contract")
9999 
100100 let mVD = match getString(configAddress, distributorStore) {
101101     case d: String => 
102102         addressFromStringValue(d)
103103     case _ => 
104104         unit
105105 }
106106 
107107 let VD = valueOrErrorMessage(mVD, "no distributor to claim rewards")
108108 
109109 let maybeViresAssetId = getString(viresMinter, "assetId")
110110 
111111 let viresAssetId = valueOrErrorMessage(fromBase58String(valueOrErrorMessage(maybeViresAssetId, "vires assetId not found")), "invalid vires assetId")
112112 
113113 func viresPayment (i) = if ((size(i.payments) == 0))
114114     then 0
115115     else if ((i.payments[0].assetId != viresAssetId))
116116         then throw("not vires")
117117         else i.payments[0].amount
118118 
119119 
120120 func assetIdOfReserve (reserve) = valueOrErrorMessage(getString(reserve, assetIdStore), "no assetId in reserve")
121121 
122122 
123123 func collateralFactor (reserve) = valueOrErrorMessage(getInteger(configAddress, (assetIdOfReserve(reserve) + "_CollateralFactor")), "no CollateralFactor in config")
124124 
125125 
126126 func liquidationThreshold (reserve) = valueOrErrorMessage(getInteger(configAddress, (assetIdOfReserve(reserve) + "_LiquidationThreshold")), "no LiquidationThreshold in config")
127127 
128128 
129129 func liquidationPenalty (assetId) = valueOrErrorMessage(getInteger(configAddress, (assetId + "_LiquidationPenalty")), "no LiquidationPenalty in config")
130130 
131131 
132132 let accountHealthThreshold = valueOrErrorMessage(getInteger(configAddress, "account_health_threshold"), "no account_health_threshold")
133133 
134134 let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, "account_health_overlap"), "no account_health_overlap")
135135 
136136 let collapsePenalty = valueOrErrorMessage(getInteger(configAddress, "collapse_penalty"), "no collapse_penalty")
137137 
138138 let liquidators = valueOrElse(getString(configAddress, "liquidators"), "")
139139 
140140 func findReserveBy (store,value) = {
141141     func fold (a,r) =         match a {
142142         case found: Address => 
143143             found
144144         case _ => 
145145             let reserve = valueOrErrorMessage(addressFromString(r), "reserve bad address")
146146             if ((valueOrErrorMessage(getString(reserve, store), ("reserve has no " + store)) == value))
147147                 then reserve
148148                 else unit
149149     }
150150 
151151     match         let $l = reserves
152152         let $s = size($l)
153153         let $acc0 = unit
154154         func $f0_1 ($a,$i) =         if (($i >= $s))
155155             then $a
156156             else fold($a, $l[$i])
157157 
158158         func $f0_2 ($a,$i) =         if (($i >= $s))
159159             then $a
160160             else throw("List size exceeds 7")
161161 
162162         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7) {
163163         case found: Address => 
164164             found
165165         case _ => 
166166             throw(("unknown " + store))
167167     }
168168     }
169169 
170170 
171171 func validateReserve (r) = if (contains(reservesStr, r))
172172     then valueOrErrorMessage(addressFromString(r), "main: bad reserve")
173173     else throw(("unknown reserve:" + r))
174174 
175175 
176176 func userBalance (reserve,user) = asUserBalanceData(invoke(reserve, "userBalance", [user], nil))
177177 
178178 
179179 let maybeProtectedReserve = match getString(configAddress, "protected_reserve") {
180180     case pds: String => 
181181         valueOrErrorMessage(addressFromString(pds), "bad protected_reserve")
182182     case _ => 
183183         unit
184184 }
185185 
186186 let protectedReserve = valueOrErrorMessage(maybeProtectedReserve, "no protected reserve")
187187 
188188 func ensureNoProtected (user) = {
189189     let has =     match maybeProtectedReserve {
190190         case pa: Address => 
191191             valueOrElse(getBoolean(pa, ("protected_collateral_" + user)), false)
192192         case _ => 
193193             false
194194     }
195195     if (has)
196196         then throw("disallowed: can't have regular when protected exists")
197197         else unit
198198     }
199199 
200200 
201201 func userPower (user) = {
202202     let protectedDeposit =     match maybeProtectedReserve {
203203         case pa: Address => 
204204             asInt(invoke(pa, "borrowPower", [user], nil))
205205         case _ => 
206206             0
207207     }
208208     func fold (totals,r) =     {
209209         let $t058345880 = totals
210210         let totalD = $t058345880._1
211211         let totalB = $t058345880._2
212212         let numberOfBorrows = $t058345880._3
213213         let reserve = valueOrErrorMessage(addressFromString(r), "reserve bad address")
214214         let cf = collateralFactor(reserve)
215215         let lt = liquidationThreshold(reserve)
216216         let $t060506138 = userBalance(reserve, user)
217217         let token = $t060506138._1
218218         let asset = $t060506138._2
219219         let depositUsd = $t060506138._3
220220         let debt = $t060506138._4
221221         let debtUsd = $t060506138._5
222222         let asCollateral = $t060506138._6
223223         let totalBorrows = (numberOfBorrows + (if ((debt > 0))
224224             then 1
225225             else 0))
226226         let effectiveDepositUsd = if (asCollateral)
227227             then depositUsd
228228             else 0
229229         let overlapUsd = min([debtUsd, effectiveDepositUsd])
230230         let overlapCharge = fractionCeil(overlapUsd, accountHealthOverlap, factorsBase)
231231         if ((debtUsd > effectiveDepositUsd))
232232             then $Tuple3(totalD, ((totalB + fraction((debtUsd - effectiveDepositUsd), factorsBase, lt)) + overlapCharge), totalBorrows)
233233             else $Tuple3((totalD + fraction((effectiveDepositUsd - debtUsd), cf, factorsBase)), (totalB + overlapCharge), totalBorrows)
234234         }
235235 
236236     let r = {
237237         let $l = reserves
238238         let $s = size($l)
239239         let $acc0 = $Tuple3(protectedDeposit, 0, 0)
240240         func $f0_1 ($a,$i) =         if (($i >= $s))
241241             then $a
242242             else fold($a, $l[$i])
243243 
244244         func $f0_2 ($a,$i) =         if (($i >= $s))
245245             then $a
246246             else throw("List size exceeds 7")
247247 
248248         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7)
249249         }
250250     if (if ((protectedDeposit > 0))
251251         then (r._3 > 2)
252252         else false)
253253         then throw("can't have more than 2 borrows with protected collateral")
254254         else r
255255     }
256256 
257257 
258258 func getUserHealth (account) = {
259259     let $t069276978 = asInt3(userPower(account))
260260     let bp = $t069276978._1
261261     let bpu = $t069276978._2
262262     let ignore = $t069276978._3
263263     ((("bp:" + toString(bp)) + ", bpu:") + toString(bpu))
264264     }
265265 
266266 
267267 func validateAfter (user,op) = {
268268     let $t070897120 = userPower(user)
269269     let bp = $t070897120._1
270270     let bpu = $t070897120._2
271271     let accHealth = (((bp - bpu) * factorsBase) / bp)
272272     if (if ((bp == 0))
273273         then (bpu == 0)
274274         else false)
275275         then nil
276276         else if (if ((bp == 0))
277277             then (bpu > 0)
278278             else false)
279279             then throw(((op + " too much: breaching liquidation threshold(bp=0, bpu=") + toString(bpu)))
280280             else if ((accountHealthThreshold > accHealth))
281281                 then throw((((((((op + " too much: breaching liquidation threshold(bp=") + toString(bp)) + ", bpu=") + toString(bpu)) + ", health=") + toString(accHealth)) + ")"))
282282                 else nil
283283     }
284284 
285285 
286286 func updateStream (reserve,action,user,userChange,streamChange) = match mVD {
287287     case a: Address => 
288288         invoke(a, "onAction", [reserve, action, user, userChange, streamChange], nil)
289289     case _ => 
290290         unit
291291 }
292292 
293293 
294294 func moveStream (reserve,action,from,string,amount) = match mVD {
295295     case a: Address => 
296296         invoke(a, "move", [reserve, action, from, string, amount], nil)
297297     case _ => 
298298         unit
299299 }
300300 
301301 
302302 func syncRewardsHeight (reserve) = match mVD {
303303     case a: Address => 
304304         invoke(a, "syncHeight", [reserve], nil)
305305     case _ => 
306306         unit
307307 }
308308 
309309 
310310 func lockOrPayout (recipient,amount,lock) = if (!(lock))
311311     then [ScriptTransfer(recipient, amount, viresAssetId)]
312312     else {
313313         let doLock = invoke(dC, "lockFor", [toString(recipient), 1], [AttachedPayment(viresAssetId, amount)])
314314         if ((doLock == doLock))
315315             then nil
316316             else throw("Strict value is not equal to itself.")
317317         }
318318 
319319 
320320 func doDeposit (i,reserve,useAsCollateral) = {
321321     let user = toString(i.caller)
322322     let checks = ensureNoProtected(user)
323323     if ((checks == checks))
324324         then {
325325             let sh = syncRewardsHeight(reserve)
326326             if ((sh == sh))
327327                 then {
328328                     let action = invoke(validateReserve(reserve), "depositFor", [user, useAsCollateral], i.payments)
329329                     if ((action == action))
330330                         then {
331331                             let amt = i.payments[0].amount
332332                             let pRw = updateStream(reserve, "deposit", user, amt, amt)
333333                             if ((pRw == pRw))
334334                                 then if (!(useAsCollateral))
335335                                     then validateAfter(user, "depositing")
336336                                     else nil
337337                                 else throw("Strict value is not equal to itself.")
338338                             }
339339                         else throw("Strict value is not equal to itself.")
340340                     }
341341                 else throw("Strict value is not equal to itself.")
342342             }
343343         else throw("Strict value is not equal to itself.")
344344     }
345345 
346346 
347347 func claimAllRewardsForUser (user) = {
348348     let claimedEb = asInt(invoke(ebR, "claimEbRewardFor", [user, -1], nil))
349349     if ((claimedEb == claimedEb))
350350         then {
351-            let rewardReserves = split(valueOrErrorMessage(getString(VD, "reward_reserves"), "no string"), "|")
351+            let rewardReserves = split(valueOrErrorMessage(getString(configAddress, "rewardable_reserves"), "no string"), "|")
352352             func fold (acc,reserve) =             {
353353                 let claimed = asInt(invoke(VD, "claimRewardFor", [reserve, user, -1], nil))
354354                 if ((claimed == claimed))
355355                     then (acc + claimed)
356356                     else throw("Strict value is not equal to itself.")
357357                 }
358358 
359359             let claimedTotal = {
360360                 let $l = rewardReserves
361361                 let $s = size($l)
362362                 let $acc0 = 0
363363                 func $f0_1 ($a,$i) =                 if (($i >= $s))
364364                     then $a
365365                     else fold($a, $l[$i])
366366 
367367                 func $f0_2 ($a,$i) =                 if (($i >= $s))
368368                     then $a
369369                     else throw("List size exceeds 7")
370370 
371371                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7)
372372                 }
373373             (claimedTotal + claimedEb)
374374             }
375375         else throw("Strict value is not equal to itself.")
376376     }
377377 
378378 
379379 func moveCollateral (addr,assetStr,reserve,reserveStr) = {
380380     let amt = asInt(invoke(protectedReserve, "withdrawToMain", [addr, assetStr], nil))
381381     if ((amt == amt))
382382         then {
383383             let assetId = if ((assetStr == "WAVES"))
384384                 then unit
385385                 else fromBase58String(assetStr)
386386             let dep = invoke(reserve, "depositFor", [addr, true], [AttachedPayment(assetId, amt)])
387387             if ((dep == dep))
388388                 then {
389389                     let prop = updateStream(reserveStr, "deposit", addr, amt, amt)
390390                     if ((prop == prop))
391391                         then unit
392392                         else throw("Strict value is not equal to itself.")
393393                     }
394394                 else throw("Strict value is not equal to itself.")
395395             }
396396         else throw("Strict value is not equal to itself.")
397397     }
398398 
399399 
400400 func transferDebtInternal (liquidator,borrowReserve,collateralReserve,borrower,liquidateDebtAmount,fromProtected) = {
401401     let sh1 = syncRewardsHeight(borrowReserve)
402402     if ((sh1 == sh1))
403403         then {
404404             let sh2 = syncRewardsHeight(collateralReserve)
405405             if ((sh2 == sh2))
406406                 then if ((0 >= liquidateDebtAmount))
407407                     then throw("can't liquidate non-positive amount")
408408                     else if ((collateralReserve == borrowReserve))
409409                         then throw("collateralReserve equals borrowReserve")
410410                         else if ((liquidator == borrower))
411411                             then throw("can't liquidate self")
412412                             else {
413-                                let $t01049710532 = userPower(borrower)
414-                                let bp = $t01049710532._1
415-                                let bpu = $t01049710532._2
413+                                let $t01051210547 = userPower(borrower)
414+                                let bp = $t01051210547._1
415+                                let bpu = $t01051210547._2
416416                                 if ((bp > bpu))
417417                                     then throw(((((("can't liquidate healthy user: u=" + borrower) + ", bp=") + toString(bp)) + ", bpu=") + toString(bpu)))
418418                                     else {
419419                                         let br = validateReserve(borrowReserve)
420420                                         let cr = validateReserve(collateralReserve)
421421                                         let borrowAsset = valueOrErrorMessage(getString(br, "assetId"), ("no assetId field in borrowReserve " + borrowReserve))
422422                                         let collateralAsset = valueOrErrorMessage(getString(cr, "assetId"), ("no assetId field in collateralReserve " + collateralReserve))
423423                                         let isCollateral = valueOrElse(getBoolean(cr, (borrower + "_useAsCollateral")), false)
424424                                         if ((isCollateral == isCollateral))
425425                                             then if (if (!(fromProtected))
426426                                                 then !(isCollateral)
427427                                                 else false)
428428                                                 then throw("can't liquidate deposit not used as collateral")
429429                                                 else {
430-                                                    let $t01119711287 = userBalance(br, borrower)
431-                                                    if (($t01119711287 == $t01119711287))
430+                                                    let $t01121211302 = userBalance(br, borrower)
431+                                                    if (($t01121211302 == $t01121211302))
432432                                                         then {
433-                                                            let userDebtUsd = $t01119711287._5
434-                                                            let userDebt = $t01119711287._4
435-                                                            let userAssetUsd = $t01119711287._3
436-                                                            let userAsset = $t01119711287._2
437-                                                            let ignore = $t01119711287._1
433+                                                            let userDebtUsd = $t01121211302._5
434+                                                            let userDebt = $t01121211302._4
435+                                                            let userAssetUsd = $t01121211302._3
436+                                                            let userAsset = $t01121211302._2
437+                                                            let ignore = $t01121211302._1
438438                                                             if ((userAsset >= userDebt))
439439                                                                 then throw("can't liquidate debt of asset of positive saldo")
440440                                                                 else if ((0 >= liquidateDebtAmount))
441441                                                                     then throw("can't liquidate zero or negative amount")
442442                                                                     else if (((liquidateDebtAmount * 2) > (userDebt - userAsset)))
443443                                                                         then throw(((((("can't liquidate more than half of saldo: debt=" + toString(userDebt)) + ", deposit=") + toString(userAsset)) + ", liquidateDebtAmount = ") + toString(liquidateDebtAmount)))
444444                                                                         else {
445445                                                                             let collateralUsd = fraction(liquidateDebtAmount, userDebtUsd, userDebt)
446446                                                                             let penaltizedUsd = fraction(collateralUsd, (factorsBase + liquidationPenalty(borrowAsset)), factorsBase)
447447                                                                             let mc = if (fromProtected)
448448                                                                                 then moveCollateral(borrower, collateralAsset, cr, collateralReserve)
449449                                                                                 else unit
450450                                                                             if ((mc == mc))
451451                                                                                 then {
452452                                                                                     let transferredCollateral = asInt(invoke(cr, "transferATokensFor", [borrower, liquidator, penaltizedUsd], nil))
453453                                                                                     if ((transferredCollateral == transferredCollateral))
454454                                                                                         then {
455455                                                                                             let pRw1 = moveStream(collateralReserve, "deposit", borrower, liquidator, transferredCollateral)
456456                                                                                             if ((pRw1 == pRw1))
457457                                                                                                 then {
458458                                                                                                     let transferredDebt = asInt(invoke(br, "transferDebtFor", [borrower, liquidator, liquidateDebtAmount], nil))
459459                                                                                                     if ((transferredDebt == transferredDebt))
460460                                                                                                         then {
461461                                                                                                             let pRw2 = moveStream(borrowReserve, "borrow", borrower, liquidator, transferredDebt)
462462                                                                                                             if ((pRw2 == pRw2))
463463                                                                                                                 then {
464464                                                                                                                     let liquidatorHealthCheck = if (contains(liquidators, liquidator))
465465                                                                                                                         then nil
466466                                                                                                                         else validateAfter(liquidator, "transferring debt")
467467                                                                                                                     if ((liquidatorHealthCheck == liquidatorHealthCheck))
468468                                                                                                                         then $Tuple2(liquidatorHealthCheck, transferredCollateral)
469469                                                                                                                         else throw("Strict value is not equal to itself.")
470470                                                                                                                     }
471471                                                                                                                 else throw("Strict value is not equal to itself.")
472472                                                                                                             }
473473                                                                                                         else throw("Strict value is not equal to itself.")
474474                                                                                                     }
475475                                                                                                 else throw("Strict value is not equal to itself.")
476476                                                                                             }
477477                                                                                         else throw("Strict value is not equal to itself.")
478478                                                                                     }
479479                                                                                 else throw("Strict value is not equal to itself.")
480480                                                                             }
481481                                                             }
482482                                                         else throw("Strict value is not equal to itself.")
483483                                                     }
484484                                             else throw("Strict value is not equal to itself.")
485485                                         }
486486                                 }
487487                 else throw("Strict value is not equal to itself.")
488488             }
489489         else throw("Strict value is not equal to itself.")
490490     }
491491 
492492 
493493 func forceCollapseInternal (liquidator,reserve,borrower,fromProtected) = {
494494     let reserveAddress = validateReserve(reserve)
495495     if ((reserveAddress == reserveAddress))
496496         then {
497497             let sh = syncRewardsHeight(reserve)
498498             if ((sh == sh))
499499                 then if ((liquidator == borrower))
500500                     then throw("can't collapse self in this function")
501501                     else {
502-                        let $t01297413009 = userPower(borrower)
503-                        let bp = $t01297413009._1
504-                        let bpu = $t01297413009._2
502+                        let $t01298913024 = userPower(borrower)
503+                        let bp = $t01298913024._1
504+                        let bpu = $t01298913024._2
505505                         if ((bp > bpu))
506506                             then throw(((((("can't force collapse healthy user: u=" + borrower) + ", bp=") + toString(bp)) + ", bpu=") + toString(bpu)))
507507                             else {
508508                                 let asset = valueOrErrorMessage(getString(reserveAddress, "assetId"), ("no assetId field in reserve " + reserve))
509509                                 let mc = if (fromProtected)
510510                                     then moveCollateral(borrower, asset, reserveAddress, reserve)
511511                                     else unit
512512                                 if ((mc == mc))
513513                                     then {
514-                                        let $t01338513493 = userBalance(reserveAddress, borrower)
515-                                        if (($t01338513493 == $t01338513493))
514+                                        let $t01340013508 = userBalance(reserveAddress, borrower)
515+                                        if (($t01340013508 == $t01340013508))
516516                                             then {
517-                                                let userDebtUsd = $t01338513493._5
518-                                                let userDebt = $t01338513493._4
519-                                                let userAssetUsd = $t01338513493._3
520-                                                let borrowerDeposit = $t01338513493._2
521-                                                let ignore = $t01338513493._1
517+                                                let userDebtUsd = $t01340013508._5
518+                                                let userDebt = $t01340013508._4
519+                                                let userAssetUsd = $t01340013508._3
520+                                                let borrowerDeposit = $t01340013508._2
521+                                                let ignore = $t01340013508._1
522522                                                 let penaltizedUsd = fraction(min([userAssetUsd, userDebtUsd]), collapsePenalty, factorsBase)
523523                                                 let transferredAssets = asInt(invoke(reserveAddress, "transferATokensFor", [borrower, liquidator, penaltizedUsd], nil))
524524                                                 if ((transferredAssets == transferredAssets))
525525                                                     then {
526526                                                         let pRw1 = moveStream(reserve, "deposit", borrower, liquidator, transferredAssets)
527527                                                         if ((pRw1 == pRw1))
528528                                                             then {
529529                                                                 let collapsed = asInt(invoke(reserveAddress, "collapseFor", [borrower], nil))
530530                                                                 if ((collapsed == collapsed))
531531                                                                     then {
532532                                                                         let pRw2 = updateStream(reserve, "borrow", borrower, -(collapsed), -(collapsed))
533533                                                                         if ((pRw2 == pRw2))
534534                                                                             then {
535535                                                                                 let pRw3 = updateStream(reserve, "deposit", borrower, -(collapsed), -(collapsed))
536536                                                                                 if ((pRw3 == pRw3))
537537                                                                                     then nil
538538                                                                                     else throw("Strict value is not equal to itself.")
539539                                                                                 }
540540                                                                             else throw("Strict value is not equal to itself.")
541541                                                                         }
542542                                                                     else throw("Strict value is not equal to itself.")
543543                                                                 }
544544                                                             else throw("Strict value is not equal to itself.")
545545                                                         }
546546                                                     else throw("Strict value is not equal to itself.")
547547                                                 }
548548                                             else throw("Strict value is not equal to itself.")
549549                                         }
550550                                     else throw("Strict value is not equal to itself.")
551551                                 }
552552                         }
553553                 else throw("Strict value is not equal to itself.")
554554             }
555555         else throw("Strict value is not equal to itself.")
556556     }
557557 
558558 
559559 func spfr () = invoke(dC, "shareProfitFromReserves", nil, nil)
560560 
561561 
562562 func wdInternal (user,reserve,amount,op) = {
563563     let sh = syncRewardsHeight(toString(reserve))
564564     if ((sh == sh))
565565         then {
566566             let withdrawnAmount = asInt(invoke(reserve, op, [user, amount], nil))
567567             if ((withdrawnAmount == withdrawnAmount))
568568                 then {
569569                     let pRw = updateStream(toString(reserve), "deposit", user, -(withdrawnAmount), -(withdrawnAmount))
570570                     if ((pRw == pRw))
571571                         then withdrawnAmount
572572                         else throw("Strict value is not equal to itself.")
573573                     }
574574                 else throw("Strict value is not equal to itself.")
575575             }
576576         else throw("Strict value is not equal to itself.")
577577     }
578578 
579579 
580580 @Callable(i)
581581 func initialize (ca) = [writeConstString(configStore, ca)]
582582 
583583 
584584 
585585 @Callable(i)
586586 func deposit (reserve,useAsCollateral) = doDeposit(i, reserve, useAsCollateral)
587587 
588588 
589589 
590590 @Callable(i)
591591 func depositRef (reserve,useAsCollateral,ref) = doDeposit(i, reserve, useAsCollateral)
592592 
593593 
594594 
595595 @Callable(i)
596596 func repay (reserve) = {
597597     let user = toString(i.caller)
598598     let sh = syncRewardsHeight(reserve)
599599     if ((sh == sh))
600600         then {
601601             let repaid = asInt(invoke(validateReserve(reserve), "repayFor", [user], i.payments))
602602             if ((repaid == repaid))
603603                 then {
604604                     let pRw = updateStream(reserve, "borrow", user, -(repaid), -(repaid))
605605                     if ((pRw == pRw))
606606                         then nil
607607                         else throw("Strict value is not equal to itself.")
608608                     }
609609                 else throw("Strict value is not equal to itself.")
610610             }
611611         else throw("Strict value is not equal to itself.")
612612     }
613613 
614614 
615615 
616616 @Callable(i)
617617 func mintAtoken (aTokenId,amount) = {
618618     let user = toString(i.caller)
619619     let targetContract = findReserveBy(aTokenIdStore, aTokenId)
620620     let sh = syncRewardsHeight(toString(targetContract))
621621     if ((sh == sh))
622622         then {
623623             let amt = asInt(invoke(targetContract, "mintAtokenFor", [user, amount], nil))
624624             if ((amt == amt))
625625                 then {
626626                     let pRw = updateStream(toString(targetContract), "deposit", user, -(amt), 0)
627627                     if ((pRw == pRw))
628628                         then validateAfter(user, "minting")
629629                         else throw("Strict value is not equal to itself.")
630630                     }
631631                 else throw("Strict value is not equal to itself.")
632632             }
633633         else throw("Strict value is not equal to itself.")
634634     }
635635 
636636 
637637 
638638 @Callable(i)
639639 func replenishWithAtoken () = {
640640     let user = toString(i.caller)
641641     let checks = ensureNoProtected(user)
642642     if ((checks == checks))
643643         then {
644644             let aTokenId = toBase58String(valueOrErrorMessage(i.payments[0].assetId, "bad assetId: waves not allowed"))
645645             let targetContract = findReserveBy(aTokenIdStore, aTokenId)
646646             let sh = syncRewardsHeight(toString(targetContract))
647647             if ((sh == sh))
648648                 then {
649649                     let amt = asInt(invoke(targetContract, "replenishWithAtokenFor", [user], i.payments))
650650                     if ((amt == amt))
651651                         then {
652652                             let pRw = updateStream(toString(targetContract), "deposit", user, amt, 0)
653653                             if ((pRw == pRw))
654654                                 then nil
655655                                 else throw("Strict value is not equal to itself.")
656656                             }
657657                         else throw("Strict value is not equal to itself.")
658658                     }
659659                 else throw("Strict value is not equal to itself.")
660660             }
661661         else throw("Strict value is not equal to itself.")
662662     }
663663 
664664 
665665 
666666 @Callable(i)
667667 func redeemAtokens () = {
668668     let user = toString(i.caller)
669669     let aTokenId = toBase58String(valueOrErrorMessage(i.payments[0].assetId, "bad assetId: waves not allowed"))
670670     let targetContract = findReserveBy(aTokenIdStore, aTokenId)
671671     let sh = syncRewardsHeight(toString(targetContract))
672672     if ((sh == sh))
673673         then {
674674             let amt = asInt(invoke(targetContract, "redeemAtokensFor", [user], i.payments))
675675             if ((amt == amt))
676676                 then {
677677                     let pRw = updateStream(toString(targetContract), "deposit", user, 0, -(amt))
678678                     if ((pRw == pRw))
679679                         then nil
680680                         else throw("Strict value is not equal to itself.")
681681                     }
682682                 else throw("Strict value is not equal to itself.")
683683             }
684684         else throw("Strict value is not equal to itself.")
685685     }
686686 
687687 
688688 
689689 @Callable(i)
690690 func withdraw (assetId,amount) = {
691691     let user = toString(i.caller)
692692     let result = asInt(wdInternal(user, findReserveBy(assetIdStore, assetId), amount, "withdrawFor"))
693693     if ((result == result))
694694         then $Tuple2(validateAfter(user, "withdrawing"), result)
695695         else throw("Strict value is not equal to itself.")
696696     }
697697 
698698 
699699 
700700 @Callable(i)
701701 func withdraw2 (reserve,amount) = {
702702     let user = toString(i.caller)
703703     let sh = syncRewardsHeight(reserve)
704704     if ((sh == sh))
705705         then {
706706             let amt = asInt(invoke(validateReserve(reserve), "withdrawFor", [user, amount], nil))
707707             if ((amt == amt))
708708                 then {
709709                     let pRw = updateStream(reserve, "deposit", user, -(amt), -(amt))
710710                     if ((pRw == pRw))
711711                         then if (contains(liquidators, user))
712712                             then nil
713713                             else validateAfter(user, "withdrawing2")
714714                         else throw("Strict value is not equal to itself.")
715715                     }
716716                 else throw("Strict value is not equal to itself.")
717717             }
718718         else throw("Strict value is not equal to itself.")
719719     }
720720 
721721 
722722 
723723 @Callable(i)
724724 func protectCollateral (reserve) = {
725725     let user = toString(i.caller)
726726     let r = validateReserve(reserve)
727727     let amt = asInt(wdInternal(user, r, -1, "withdrawToMain"))
728728     if ((amt == amt))
729729         then {
730730             let assetId = assetStrToId(getStringValue(r, assetIdStore))
731731             let p = invoke(protectedReserve, "supplyFor", [user], [AttachedPayment(assetId, amt)])
732732             if ((p == p))
733733                 then $Tuple2(validateAfter(user, "protecting"), amt)
734734                 else throw("Strict value is not equal to itself.")
735735             }
736736         else throw("Strict value is not equal to itself.")
737737     }
738738 
739739 
740740 
741741 @Callable(i)
742742 func withdrawProtectedCollateral (assetId,amount) = {
743743     let user = toString(i.caller)
744744     let a = asInt(invoke(valueOrErrorMessage(protectedReserve, "no protectedReserve"), "withdrawFor", [user, assetId, amount], nil))
745745     if ((a == a))
746746         then validateAfter(user, "withdrawing protected collateral")
747747         else throw("Strict value is not equal to itself.")
748748     }
749749 
750750 
751751 
752752 @Callable(i)
753753 func borrow (assetId,amount) = {
754754     let user = toString(i.caller)
755755     let reserve = findReserveBy(assetIdStore, assetId)
756756     let sh = syncRewardsHeight(toString(reserve))
757757     if ((sh == sh))
758758         then {
759759             let a = invoke(reserve, "borrowFor", [user, amount], nil)
760760             if ((a == a))
761761                 then {
762762                     let pRw = updateStream(toString(reserve), "borrow", user, amount, amount)
763763                     if ((pRw == pRw))
764764                         then validateAfter(user, "borrowing")
765765                         else throw("Strict value is not equal to itself.")
766766                     }
767767                 else throw("Strict value is not equal to itself.")
768768             }
769769         else throw("Strict value is not equal to itself.")
770770     }
771771 
772772 
773773 
774774 @Callable(i)
775775 func borrow2 (reserve,amount) = {
776776     let user = toString(i.caller)
777777     let sh = syncRewardsHeight(reserve)
778778     if ((sh == sh))
779779         then {
780780             let a = invoke(validateReserve(reserve), "borrowFor", [user, amount], nil)
781781             if ((a == a))
782782                 then {
783783                     let pRw = updateStream(reserve, "borrow", user, amount, amount)
784784                     if ((pRw == pRw))
785785                         then validateAfter(user, "borrowing")
786786                         else throw("Strict value is not equal to itself.")
787787                     }
788788                 else throw("Strict value is not equal to itself.")
789789             }
790790         else throw("Strict value is not equal to itself.")
791791     }
792792 
793793 
794794 
795795 @Callable(i)
796796 func collapse (reserve,amount) = {
797797     let user = toString(i.caller)
798798     let sh = syncRewardsHeight(reserve)
799799     if ((sh == sh))
800800         then {
801801             let c = asInt(invoke(validateReserve(reserve), "collapseForAmount", [user, amount], nil))
802802             if ((c == c))
803803                 then {
804804                     let pRw = updateStream(reserve, "borrow", user, -(c), -(c))
805805                     if ((pRw == pRw))
806806                         then {
807807                             let pRw2 = updateStream(reserve, "deposit", user, -(c), -(c))
808808                             if ((pRw2 == pRw2))
809809                                 then nil
810810                                 else throw("Strict value is not equal to itself.")
811811                             }
812812                         else throw("Strict value is not equal to itself.")
813813                     }
814814                 else throw("Strict value is not equal to itself.")
815815             }
816816         else throw("Strict value is not equal to itself.")
817817     }
818818 
819819 
820820 
821821 @Callable(i)
822822 func claimEbReward2 (amount,lock) = {
823823     let user = toString(i.caller)
824824     let c = asInt(invoke(ebR, "claimEbRewardFor", [user, amount], nil))
825825     if ((c == c))
826826         then lockOrPayout(i.caller, c, lock)
827827         else throw("Strict value is not equal to itself.")
828828     }
829829 
830830 
831831 
832832 @Callable(i)
833833 func claimReward2 (reserve,amount,lock) = {
834834     let v = validateReserve(reserve)
835835     if ((v == v))
836836         then {
837837             let user = toString(i.caller)
838838             let c = asInt(invoke(VD, "claimRewardFor", [reserve, user, amount], nil))
839839             if ((c == c))
840840                 then lockOrPayout(i.caller, c, lock)
841841                 else throw("Strict value is not equal to itself.")
842842             }
843843         else throw("Strict value is not equal to itself.")
844844     }
845845 
846846 
847847 
848848 @Callable(i)
849849 func claimAllRewardsAndAllEbAvailable2 (lock,unstakeLegacy) = {
850850     let user = toString(i.caller)
851851     let cr = claimAllRewardsForUser(user)
852852     if ((cr == cr))
853853         then {
854854             let lA = if (unstakeLegacy)
855855                 then asInt(invoke(vS, "unstakeAllViresFrom", [user], nil))
856856                 else 0
857857             if ((lA == lA))
858858                 then lockOrPayout(i.caller, (cr + lA), lock)
859859                 else throw("Strict value is not equal to itself.")
860860             }
861861         else throw("Strict value is not equal to itself.")
862862     }
863863 
864864 
865865 
866866 @Callable(i)
867867 func disableUseAsCollateral (reserve) = {
868868     let user = toString(i.caller)
869869     let d = invoke(validateReserve(reserve), "disableUseAsCollateralFor", [user], nil)
870870     if ((d == d))
871871         then validateAfter(user, "changing collateral status")
872872         else throw("Strict value is not equal to itself.")
873873     }
874874 
875875 
876876 
877877 @Callable(i)
878878 func transferDebt (br,cr,b,la) = transferDebtInternal(toString(i.caller), br, cr, b, la, false)
879879 
880880 
881881 
882882 @Callable(i)
883883 func transferDebt2 (br,cr,b,la) = transferDebtInternal(toString(i.caller), br, cr, b, la, true)
884884 
885885 
886886 
887887 @Callable(i)
888888 func forceCollapse (r,b) = forceCollapseInternal(toString(i.caller), r, b, false)
889889 
890890 
891891 
892892 @Callable(i)
893893 func forceCollapse2 (r,b) = forceCollapseInternal(toString(i.caller), r, b, true)
894894 
895895 
896896 
897897 @Callable(i)
898898 func lockVires (factor,migrate) = {
899899     let user = toString(i.caller)
900900     let a = spfr()
901901     if ((a == a))
902902         then {
903903             let migrateAmount = if (migrate)
904904                 then asInt(invoke(vS, "unstakeAllViresFrom", [user], nil))
905905                 else 0
906906             let total = (migrateAmount + viresPayment(i))
907907             let l = invoke(dC, "lockFor", [user, factor], if ((total == 0))
908908                 then nil
909909                 else [AttachedPayment(viresAssetId, total)])
910910             if ((l == l))
911911                 then nil
912912                 else throw("Strict value is not equal to itself.")
913913             }
914914         else throw("Strict value is not equal to itself.")
915915     }
916916 
917917 
918918 
919919 @Callable(i)
920920 func withdrawAllPossibleVires () = {
921921     let user = toString(i.caller)
922922     let a = spfr()
923923     if ((a == a))
924924         then {
925925             let stakerViresAmount = asInt(invoke(vS, "unstakeAllViresFrom", [user], nil))
926926             if ((stakerViresAmount == stakerViresAmount))
927927                 then {
928928                     let u = invoke(dC, "withdrawUnlockedFor", [user], nil)
929929                     if ((u == u))
930930                         then [ScriptTransfer(i.caller, stakerViresAmount, viresAssetId)]
931931                         else throw("Strict value is not equal to itself.")
932932                     }
933933                 else throw("Strict value is not equal to itself.")
934934             }
935935         else throw("Strict value is not equal to itself.")
936936     }
937937 
938938 
939939 
940940 @Callable(i)
941941 func claimProtocolProfitFrom (from,relock) = {
942942     let user = toString(i.caller)
943943     let a = spfr()
944944     if ((a == a))
945945         then {
946946             let u = invoke(dC, "claimProfit", [from, user, relock], nil)
947947             if ((u == u))
948948                 then nil
949949                 else throw("Strict value is not equal to itself.")
950950             }
951951         else throw("Strict value is not equal to itself.")
952952     }
953953 
954954 
955955 
956956 @Callable(i)
957957 func withdrawUnlockedVires () = {
958958     let a = spfr()
959959     if ((a == a))
960960         then {
961961             let u = invoke(dC, "withdrawUnlockedFor", [toString(i.caller)], nil)
962962             if ((u == u))
963963                 then nil
964964                 else throw("Strict value is not equal to itself.")
965965             }
966966         else throw("Strict value is not equal to itself.")
967967     }
968968 
969969 
github/deemru/w8io/786bc32 
112.09 ms ◑