tx · Gd9tEpzj3GAwyDaA1Jm8RhM129BXjRaCHaDNGb2DJbv6

3N3DnVffnUyZtz2MRbk5U7giN112WempMNd:  -0.03100000 Waves

2023.03.30 12:51 [2512521] smart account 3N3DnVffnUyZtz2MRbk5U7giN112WempMNd > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Gd9tEpzj3GAwyDaA1Jm8RhM129BXjRaCHaDNGb2DJbv6",
    "fee": 3100000,
    "feeAssetId": null,
    "timestamp": 1680169901115,
    "version": 2,
    "chainId": 84,
    "sender": "3N3DnVffnUyZtz2MRbk5U7giN112WempMNd",
    "senderPublicKey": "3c1wAgvTRCNXCGMidVnB1j4gTYUqtwHR9tNNu2v4ZUNk",
    "proofs": [
        "5ucEAbPCY8UiWeMB2A2gFWAioc2oS5TKe8VbjNe6NmuDKmfTM8W33exPbKLGJAY27JKGf9HMnmYPiz1r8CkK6rjN"
    ],
    "script": "base64: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",
    "height": 2512521,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3gSjYHB5cDyaA8C2TpVfH5VohtjTrCFNvwYQ89jx4wHh
Next: HwYBcakQpBd7RegB8bZNGsTpr4ySph3dKbhHAGMdiZtw

Diff: 

OldNewDifferences
242242 func supplyInternal (assetIdStr,assetAmount,address) = if (!(tryGetBoolean("setup_active")))
243243     then throw("market is stopped")
244244     else {
245-        let $t058685935 = getActualRate(assetIdStr, "sRate")
246-        let sRate = $t058685935._1
247-        let ratesRecalcResult = $t058685935._2
245+        let $t058705937 = getActualRate(assetIdStr, "sRate")
246+        let sRate = $t058705937._1
247+        let ratesRecalcResult = $t058705937._2
248248         let amount = fraction(assetAmount, Scale16, sRate, DOWN)
249249         let maxSupply =         match getString(("setup_maxSupply_" + assetIdStr)) {
250250             case x: String => 
268268 
269269 
270270 func borrowInternal (assetIdStr,assetAmount,address) = {
271-    let $t072147281 = getActualRate(assetIdStr, "bRate")
272-    let bRate = $t072147281._1
273-    let ratesRecalcResult = $t072147281._2
271+    let $t072167283 = getActualRate(assetIdStr, "bRate")
272+    let bRate = $t072167283._1
273+    let ratesRecalcResult = $t072167283._2
274274     let amount = fraction(assetAmount, Scale16, bRate, CEILING)
275275     let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",borrowed,") + toString(amount))], nil)
276276     if ((collateralValueInv == collateralValueInv))
302302 func flashPosition (user,sAssetIdStr,bAssetIdStr,bAmount,callbackAddress,callbackFunction,callbackArgs) = {
303303     let borrowRes = borrowInternal(bAssetIdStr, bAmount, user)
304304     let bAssetId = getAssetBytes(bAssetIdStr)
305-    let callback = invoke(addressFromStringValue(callbackAddress), callbackFunction, split(callbackArgs, ","), [AttachedPayment(bAssetId, bAmount)])
305+    let callback = reentrantInvoke(addressFromStringValue(callbackAddress), callbackFunction, split(callbackArgs, ","), [AttachedPayment(bAssetId, bAmount)])
306306     if ((callback == callback))
307307         then {
308308             let sAmount = {
358358 
359359 @Callable(i)
360360 func withdraw (assetIdStr,assetAmount) = {
361-    let $t01081510882 = getActualRate(assetIdStr, "sRate")
362-    let sRate = $t01081510882._1
363-    let ratesRecalcResult = $t01081510882._2
361+    let $t01082610893 = getActualRate(assetIdStr, "sRate")
362+    let sRate = $t01082610893._1
363+    let ratesRecalcResult = $t01082610893._2
364364     let amount = fraction(assetAmount, Scale16, sRate, CEILING)
365365     let address = toString(i.caller)
366366     let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
411411         else {
412412             let assetIdStr = getAssetString(i.payments[0].assetId)
413413             let assetAmount = i.payments[0].amount
414-            let $t01294913016 = getActualRate(assetIdStr, "bRate")
415-            let bRate = $t01294913016._1
416-            let ratesRecalcResult = $t01294913016._2
414+            let $t01296013027 = getActualRate(assetIdStr, "bRate")
415+            let bRate = $t01296013027._1
416+            let ratesRecalcResult = $t01296013027._2
417417             let amount = fraction(assetAmount, Scale16, bRate, CEILING)
418418             let address = toString(i.caller)
419419             let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
751751             let userCollateral = calcUserCollateral(address)
752752             if ((userCollateral == userCollateral))
753753                 then {
754-                    let $t02593625998 = getActualRate(sAssetIdStr, "sRate")
755-                    let sRate = $t02593625998._1
756-                    let ratesResult = $t02593625998._2
757-                    let $t02600326072 = getActualRate(bAssetIdStr, "bRate")
758-                    let bRate = $t02600326072._1
759-                    let ratesRecalcResult2 = $t02600326072._2
754+                    let $t02594726009 = getActualRate(sAssetIdStr, "sRate")
755+                    let sRate = $t02594726009._1
756+                    let ratesResult = $t02594726009._2
757+                    let $t02601426083 = getActualRate(bAssetIdStr, "bRate")
758+                    let bRate = $t02601426083._1
759+                    let ratesRecalcResult2 = $t02601426083._2
760760                     let sAssetAmount = fraction(assetAmount, Scale16, sRate)
761761                     let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
762762                     let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
832832                         let marketAssets = getMarketAssets()
833833                         let asset1Num = value(indexOf(marketAssets, bAssetIdStr))
834834                         let asset0Num = value(indexOf(marketAssets, sAssetIdStr))
835-                        let $t02922729289 = getActualRate(bAssetIdStr, "bRate")
836-                        let bRate = $t02922729289._1
837-                        let ratesResult = $t02922729289._2
835+                        let $t02923829300 = getActualRate(bAssetIdStr, "bRate")
836+                        let bRate = $t02923829300._1
837+                        let ratesResult = $t02923829300._2
838838                         let asset1Price = getTokenPrice(bAssetIdStr)._2
839839                         let asset1Scale = calcAssetScale(bAssetIdStr)
840840                         let bAmountUsd = fraction(bAssetAmount, asset1Price, asset1Scale)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let reserveFundAddress = Address(base58'3Mzzt65puEs2W9M1m9iFBvMEdfM5bASE1hJ')
55 
66 let reserveFund = 20
77 
88 let flashLoanFee = 1000000
99 
1010 let aggregatorAddress = Address(base58'3Mzzt65puEs2W9M1m9iFBvMEdfM5bASE1hJ')
1111 
1212 let oracleStr = "3N4KbMnJH8FaM94jqxNFe2oyZ8GB7Z8yVBP"
1313 
1414 let shutdownWhitelist = [base58'3PMcMiMEs6w56NRGacksXtFG5zS7doE9fpL', base58'3PAxdDSmN758L5SHSGRC5apEtQE2aApZotG', base58'3PJKmXoHJvVeQXjSJdhtkUcFDtdiQqMbUTD', base58'3PQdNxynJy5mche2kxMVc5shXWzK8Gstq3o', base58'3PHbdpaKzz8EiAngGHaFu2hVuNCdsC67qh3', base58'3P6Ksahs71SiKQgQ4qaZuFAVhqncdi2nvJQ']
1515 
1616 func verifyLiquidatorRights (address) = !((address != Address(base58'3Mzzt65puEs2W9M1m9iFBvMEdfM5bASE1hJ')))
1717 
1818 
1919 func getRateCurve (assetIdStr) = match assetIdStr {
2020     case _ => 
2121         if (("8DtMtpVwVq62sdcVFVzh6nuprgzG7LSjpLdHnQnrAFgY" == $match0))
2222             then $Tuple4(2000000, 25000000, 80000000, 100000000)
2323             else if (("25FEqEjRkqK6yCkiT7Lz6SAYz7gUFCtxfCChnrVFD5AT" == $match0))
2424                 then $Tuple4(2000000, 25000000, 80000000, 100000000)
2525                 else if (("WAVES" == $match0))
2626                     then $Tuple4(2000000, 30000000, 80000000, 50000000)
2727                     else $Tuple4(0, 20000000, 80000000, 80000000)
2828 }
2929 
3030 
3131 let Scale8 = 100000000
3232 
3333 let Scale10 = 10000000000
3434 
3535 let Scale16 = (Scale8 * Scale8)
3636 
3737 let dayBlocks = 1440
3838 
3939 func liIntToStr (li) = {
4040     func f (accum,next) =     ((accum + toString(next)) + ",")
4141 
4242     let $l = li
4343     let $s = size($l)
4444     let $acc0 = ""
4545     func $f0_1 ($a,$i) =     if (($i >= $s))
4646         then $a
4747         else f($a, $l[$i])
4848 
4949     func $f0_2 ($a,$i) =     if (($i >= $s))
5050         then $a
5151         else throw("List size exceeds 6")
5252 
5353     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
5454     }
5555 
5656 
5757 func tryGetInteger (key) = match getInteger(this, key) {
5858     case b: Int => 
5959         b
6060     case _ => 
6161         0
6262 }
6363 
6464 
6565 func tryGetBoolean (key) = match getBoolean(this, key) {
6666     case b: Boolean => 
6767         b
6868     case _ => 
6969         false
7070 }
7171 
7272 
7373 func tryGetString (key) = match getString(this, key) {
7474     case b: String => 
7575         b
7676     case _ => 
7777         ""
7878 }
7979 
8080 
8181 func tryGetBinary (key) = match getBinary(this, key) {
8282     case b: ByteVector => 
8383         b
8484     case _ => 
8585         base58''
8686 }
8787 
8888 
8989 func getAssetString (assetId) = match assetId {
9090     case b: ByteVector => 
9191         toBase58String(b)
9292     case _ => 
9393         "WAVES"
9494 }
9595 
9696 
9797 func getAssetBytes (assetIdStr) = if ((assetIdStr == "WAVES"))
9898     then unit
9999     else fromBase58String(assetIdStr)
100100 
101101 
102102 func getBalance (assetIdStr) = if ((assetIdStr == "WAVES"))
103103     then wavesBalance(this).available
104104     else assetBalance(this, fromBase58String(assetIdStr))
105105 
106106 
107107 func getMarketAssets () = split(tryGetString("setup_tokens"), ",")
108108 
109109 
110110 func getAssetsMaxSupply () = {
111111     let s = tryGetString("setup_maxsupply")
112112     if ((s == ""))
113113         then [-1, -1, -1, -1, -1, -1, -1]
114114         else split(s, ",")
115115     }
116116 
117117 
118118 func getOutdatedUr (assetIdStr) = {
119119     let down = fraction(tryGetInteger(("total_supplied_" + assetIdStr)), tryGetInteger((assetIdStr + "_sRate")), Scale16)
120120     if ((down == 0))
121121         then 0
122122         else fraction(Scale8, fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), tryGetInteger((assetIdStr + "_bRate")), Scale16), down)
123123     }
124124 
125125 
126126 func getInterest (assetIdStr) = {
127127     let ur = getOutdatedUr(assetIdStr)
128128     let curve = getRateCurve(assetIdStr)
129129     let rate = (curve._1 + (if ((curve._3 >= ur))
130130         then fraction(ur, curve._2, curve._3)
131131         else (curve._2 + fraction((ur - curve._3), curve._4, (100000000 - curve._3)))))
132132     max([fraction(rate, Scale8, (dayBlocks * 365)), 1])
133133     }
134134 
135135 
136136 func tokenRatesRecalc (assetIdStr) = {
137137     let interest = getInterest(assetIdStr)
138138     let ur = getOutdatedUr(assetIdStr)
139139     let lastRecalcHeight = tryGetInteger("lastRateHeight")
140140     let lastBRate = max([tryGetInteger((assetIdStr + "_bRate")), Scale16])
141141     let newBRate = (lastBRate + ((height - lastRecalcHeight) * interest))
142142     let lastSRate = max([tryGetInteger((assetIdStr + "_sRate")), Scale16])
143143     let newSRate = (lastSRate + ((((height - lastRecalcHeight) * fraction(interest, ur, Scale8)) * (100 - reserveFund)) / 100))
144144 [IntegerEntry((assetIdStr + "_sRate"), newSRate), IntegerEntry((assetIdStr + "_bRate"), newBRate), IntegerEntry("lastRateHeight", height)]
145145     }
146146 
147147 
148148 func getActualRate (assetIdStr,rateType) = {
149149     func f (accum,token) =     {
150150         let recalc = tokenRatesRecalc(token)
151151         $Tuple2(if ((token != assetIdStr))
152152             then accum._1
153153             else if ((rateType == "sRate"))
154154                 then recalc[0].value
155155                 else recalc[1].value, (accum._2 ++ recalc))
156156         }
157157 
158158     let $l = getMarketAssets()
159159     let $s = size($l)
160160     let $acc0 = $Tuple2(0, nil)
161161     func $f0_1 ($a,$i) =     if (($i >= $s))
162162         then $a
163163         else f($a, $l[$i])
164164 
165165     func $f0_2 ($a,$i) =     if (($i >= $s))
166166         then $a
167167         else throw("List size exceeds 6")
168168 
169169     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
170170     }
171171 
172172 
173173 func getUr (assetIdStr) = {
174174     let rates = tokenRatesRecalc(assetIdStr)
175175     let down = fraction(tryGetInteger(("total_supplied_" + assetIdStr)), rates[0].value, Scale16)
176176     fraction(Scale8, fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), rates[1].value, Scale16), down)
177177     }
178178 
179179 
180180 func ratesRecalc () = {
181181     func f (accum,token) =     (accum ++ tokenRatesRecalc(token))
182182 
183183     let $l = getMarketAssets()
184184     let $s = size($l)
185185     let $acc0 = nil
186186     func $f0_1 ($a,$i) =     if (($i >= $s))
187187         then $a
188188         else f($a, $l[$i])
189189 
190190     func $f0_2 ($a,$i) =     if (($i >= $s))
191191         then $a
192192         else throw("List size exceeds 6")
193193 
194194     $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
195195     }
196196 
197197 
198198 func getTokenPrice (assetIdStr) = {
199199     let inv3 = invoke(addressFromStringValue(oracleStr), "getTWAP60", [assetIdStr, false], nil)
200200     if ((inv3 == inv3))
201201         then {
202202             let data3 =             match inv3 {
203203                 case x: (Int, Int) => 
204204                     x
205205                 case _ => 
206206                     throw("error of price oracle")
207207             }
208208             if ((data3 == data3))
209209                 then data3
210210                 else throw("Strict value is not equal to itself.")
211211             }
212212         else throw("Strict value is not equal to itself.")
213213     }
214214 
215215 
216216 func calcAssetScale (assetIdStr) = {
217217     let decimals = if ((assetIdStr == "WAVES"))
218218         then 8
219219         else value(assetInfo(fromBase58String(assetIdStr))).decimals
220220     pow(10, 0, decimals, 0, 0, DOWN)
221221     }
222222 
223223 
224224 func calcUserCollateral (address) = {
225225     let userCollateralInvoke = invoke(this, "getUserCollateral", [false, address, true, ""], nil)
226226     if ((userCollateralInvoke == userCollateralInvoke))
227227         then {
228228             let userCollateralValue =             match userCollateralInvoke {
229229                 case x: Int => 
230230                     x
231231                 case _ => 
232232                     throw("issue while doing in-dapp invocation")
233233             }
234234             if ((userCollateralValue == userCollateralValue))
235235                 then userCollateralValue
236236                 else throw("Strict value is not equal to itself.")
237237             }
238238         else throw("Strict value is not equal to itself.")
239239     }
240240 
241241 
242242 func supplyInternal (assetIdStr,assetAmount,address) = if (!(tryGetBoolean("setup_active")))
243243     then throw("market is stopped")
244244     else {
245-        let $t058685935 = getActualRate(assetIdStr, "sRate")
246-        let sRate = $t058685935._1
247-        let ratesRecalcResult = $t058685935._2
245+        let $t058705937 = getActualRate(assetIdStr, "sRate")
246+        let sRate = $t058705937._1
247+        let ratesRecalcResult = $t058705937._2
248248         let amount = fraction(assetAmount, Scale16, sRate, DOWN)
249249         let maxSupply =         match getString(("setup_maxSupply_" + assetIdStr)) {
250250             case x: String => 
251251                 parseIntValue(x)
252252             case _ => 
253253                 0
254254         }
255255         let assetPrice = getTokenPrice(assetIdStr)
256256         let newTotalSupplied = (tryGetInteger(((address + "_supplied_") + assetIdStr)) + amount)
257257         let rate = getActualRate(assetIdStr, "sRate")._1
258258         let assetScale = calcAssetScale(assetIdStr)
259259         let newTotalSuppliedUsd = fraction(fraction(newTotalSupplied, rate, Scale16), assetPrice._1, assetScale)
260260         if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
261261             then throw("this asset is not supported by the market")
262262             else if (if ((maxSupply != 0))
263263                 then (newTotalSuppliedUsd > maxSupply)
264264                 else false)
265265                 then throw("max total supply for this token reached in the pool")
266266                 else $Tuple2(([IntegerEntry(((address + "_supplied_") + assetIdStr), newTotalSupplied), IntegerEntry(("total_supplied_" + assetIdStr), (tryGetInteger(("total_supplied_" + assetIdStr)) + amount))] ++ ratesRecalcResult), assetAmount)
267267         }
268268 
269269 
270270 func borrowInternal (assetIdStr,assetAmount,address) = {
271-    let $t072147281 = getActualRate(assetIdStr, "bRate")
272-    let bRate = $t072147281._1
273-    let ratesRecalcResult = $t072147281._2
271+    let $t072167283 = getActualRate(assetIdStr, "bRate")
272+    let bRate = $t072167283._1
273+    let ratesRecalcResult = $t072167283._2
274274     let amount = fraction(assetAmount, Scale16, bRate, CEILING)
275275     let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",borrowed,") + toString(amount))], nil)
276276     if ((collateralValueInv == collateralValueInv))
277277         then {
278278             let collateralValue =             match collateralValueInv {
279279                 case x: Int => 
280280                     x
281281                 case _ => 
282282                     throw("can't get user collateral value")
283283             }
284284             if (!(tryGetBoolean("setup_active")))
285285                 then throw("market is stopped")
286286                 else if ((0 > collateralValue))
287287                     then throw("you have to supply more to borrow")
288288                     else {
289289                         let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
290290                         let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
291291                         let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
292292                         if ((amount > (assetSupplied - assetBorrowed)))
293293                             then throw("this amount is not available")
294294                             else $Tuple2(([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed + amount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed + amount))] ++ ratesRecalcResult), assetAmount)
295295                         }
296296             }
297297         else throw("Strict value is not equal to itself.")
298298     }
299299 
300300 
301301 @Callable(i)
302302 func flashPosition (user,sAssetIdStr,bAssetIdStr,bAmount,callbackAddress,callbackFunction,callbackArgs) = {
303303     let borrowRes = borrowInternal(bAssetIdStr, bAmount, user)
304304     let bAssetId = getAssetBytes(bAssetIdStr)
305-    let callback = invoke(addressFromStringValue(callbackAddress), callbackFunction, split(callbackArgs, ","), [AttachedPayment(bAssetId, bAmount)])
305+    let callback = reentrantInvoke(addressFromStringValue(callbackAddress), callbackFunction, split(callbackArgs, ","), [AttachedPayment(bAssetId, bAmount)])
306306     if ((callback == callback))
307307         then {
308308             let sAmount = {
309309                 let @ = callback
310310                 if ($isInstanceOf(@, "Int"))
311311                     then @
312312                     else throw(($getType(@) + " couldn't be cast to Int"))
313313                 }
314314             if ((sAmount == sAmount))
315315                 then {
316316                     let supplyRes = supplyInternal(sAssetIdStr, sAmount, user)
317317                     let collateralValue = {
318318                         let @ = invoke(this, "getUserCollateral", [false, user, true, ((sAssetIdStr + ",supplied,") + toString(sAmount))], nil)
319319                         if ($isInstanceOf(@, "Int"))
320320                             then @
321321                             else throw(($getType(@) + " couldn't be cast to Int"))
322322                         }
323323                     if ((collateralValue == collateralValue))
324324                         then {
325325                             let borrowValue = {
326326                                 let @ = invoke(this, "getUserCollateral", [false, user, true, ((bAssetIdStr + ",borrowed,") + toString(bAmount))], nil)
327327                                 if ($isInstanceOf(@, "Int"))
328328                                     then @
329329                                     else throw(($getType(@) + " couldn't be cast to Int"))
330330                                 }
331331                             if ((borrowValue == borrowValue))
332332                                 then if ((borrowValue > collateralValue))
333333                                     then throw("not enough collateral provided")
334334                                     else (borrowRes._1 ++ supplyRes._1)
335335                                 else throw("Strict value is not equal to itself.")
336336                             }
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 
344344 
345345 
346346 @Callable(i)
347347 func supply () = if (if ((size(i.payments) != 1))
348348     then true
349349     else (i.payments[0].amount == 0))
350350     then throw("1 payment has to be attached")
351351     else {
352352         let assetIdStr = getAssetString(i.payments[0].assetId)
353353         let assetAmount = i.payments[0].amount
354354         supplyInternal(assetIdStr, assetAmount, toString(i.caller))
355355         }
356356 
357357 
358358 
359359 @Callable(i)
360360 func withdraw (assetIdStr,assetAmount) = {
361-    let $t01081510882 = getActualRate(assetIdStr, "sRate")
362-    let sRate = $t01081510882._1
363-    let ratesRecalcResult = $t01081510882._2
361+    let $t01082610893 = getActualRate(assetIdStr, "sRate")
362+    let sRate = $t01082610893._1
363+    let ratesRecalcResult = $t01082610893._2
364364     let amount = fraction(assetAmount, Scale16, sRate, CEILING)
365365     let address = toString(i.caller)
366366     let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
367367     let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
368368     let userAssetSupplied = tryGetInteger(((address + "_supplied_") + assetIdStr))
369369     let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
370370     let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",supplied,") + toString(-(amount)))], nil)
371371     if ((collateralValueInv == collateralValueInv))
372372         then {
373373             let collateralValue =             match collateralValueInv {
374374                 case x: Int => 
375375                     x
376376                 case _ => 
377377                     throw("can't get user collateral value")
378378             }
379379             if (!(tryGetBoolean("setup_active")))
380380                 then throw("market is stopped")
381381                 else if ((0 > collateralValue))
382382                     then throw("you dont have enough collateral for this operation")
383383                     else if ((amount > (assetSupplied - assetBorrowed)))
384384                         then throw("this amount is not available on the market")
385385                         else if ((amount > (userAssetSupplied - userAssetBorrowed)))
386386                             then throw("this amount is not available for this user")
387387                             else ([IntegerEntry(((address + "_supplied_") + assetIdStr), (tryGetInteger(((address + "_supplied_") + assetIdStr)) - amount)), IntegerEntry(("total_supplied_" + assetIdStr), (tryGetInteger(("total_supplied_" + assetIdStr)) - amount)), ScriptTransfer(i.caller, assetAmount, getAssetBytes(assetIdStr))] ++ ratesRecalcResult)
388388             }
389389         else throw("Strict value is not equal to itself.")
390390     }
391391 
392392 
393393 
394394 @Callable(i)
395395 func borrow (assetIdStr,assetAmount) = {
396396     let address = toString(i.caller)
397397     let res = borrowInternal(assetIdStr, assetAmount, address)
398398     let amount = res._2
399399     (res._1 ++ [ScriptTransfer(i.caller, amount, getAssetBytes(assetIdStr))])
400400     }
401401 
402402 
403403 
404404 @Callable(i)
405405 func repay () = if (!(tryGetBoolean("setup_active")))
406406     then throw("market is stopped")
407407     else if (if ((size(i.payments) != 1))
408408         then true
409409         else (i.payments[0].amount == 0))
410410         then throw("1 payment has to be attached")
411411         else {
412412             let assetIdStr = getAssetString(i.payments[0].assetId)
413413             let assetAmount = i.payments[0].amount
414-            let $t01294913016 = getActualRate(assetIdStr, "bRate")
415-            let bRate = $t01294913016._1
416-            let ratesRecalcResult = $t01294913016._2
414+            let $t01296013027 = getActualRate(assetIdStr, "bRate")
415+            let bRate = $t01296013027._1
416+            let ratesRecalcResult = $t01296013027._2
417417             let amount = fraction(assetAmount, Scale16, bRate, CEILING)
418418             let address = toString(i.caller)
419419             let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
420420             let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
421421             let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
422422             let amountLeft = (userAssetBorrowed - amount)
423423             let repayAmount = if ((amountLeft >= 0))
424424                 then amount
425425                 else userAssetBorrowed
426426             if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
427427                 then throw("this asset is not supported by the market")
428428                 else (([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed - repayAmount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed - repayAmount))] ++ ratesRecalcResult) ++ (if ((amountLeft >= 0))
429429                     then nil
430430                     else [ScriptTransfer(i.caller, -(amountLeft), i.payments[0].assetId)]))
431431             }
432432 
433433 
434434 
435435 @Callable(i)
436436 func stakeTokenAll (assetIdStr) = if ((i.caller != this))
437437     then throw("only for internal smart contract invocations")
438438     else {
439439         let amount = getBalance(assetIdStr)
440440         let inv = invoke(this, "stakeToken", [assetIdStr, amount], nil)
441441         if ((inv == inv))
442442             then nil
443443             else throw("Strict value is not equal to itself.")
444444         }
445445 
446446 
447447 
448448 @Callable(i)
449449 func stakeToken (assetIdStr,amount) = if ((i.caller != this))
450450     then throw("only for internal smart contract invocations")
451451     else if ((assetIdStr == "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"))
452452         then {
453453             let amountStaked = tryGetInteger("autostake_amount_DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
454454             let inv = invoke(Address(base58'3PNikM6yp4NqcSU8guxQtmR5onr2D4e8yTJ'), "stake", nil, [AttachedPayment(base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p', amount)])
455455             if ((inv == inv))
456456                 then [IntegerEntry("autostake_amount_DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p", (amountStaked + amount))]
457457                 else throw("Strict value is not equal to itself.")
458458             }
459459         else if ((assetIdStr == "8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91"))
460460             then {
461461                 let amountStaked = tryGetInteger("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91")
462462                 let inv = invoke(Address(base58'3PQTM38wDmAY9vWonK6ha7QL3PAycLz5oPP'), "stake", nil, [AttachedPayment(base58'8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91', amount)])
463463                 if ((inv == inv))
464464                     then [IntegerEntry("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91", (amountStaked + amount))]
465465                     else throw("Strict value is not equal to itself.")
466466                 }
467467             else if ((assetIdStr == "At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL"))
468468                 then {
469469                     let amountStaked = tryGetInteger("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL")
470470                     let inv = invoke(Address(base58'3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C'), "stake", nil, [AttachedPayment(base58'At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL', amount)])
471471                     if ((inv == inv))
472472                         then [IntegerEntry("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", (amountStaked + amount))]
473473                         else throw("Strict value is not equal to itself.")
474474                     }
475475                 else nil
476476 
477477 
478478 
479479 @Callable(i)
480480 func unstakeToken (assetIdStr,amount) = if ((i.caller != this))
481481     then throw("only for internal smart contract invocations")
482482     else if ((assetIdStr == "8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91"))
483483         then {
484484             let amountStaked = tryGetInteger("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91")
485485             let inv = invoke(Address(base58'3PQTM38wDmAY9vWonK6ha7QL3PAycLz5oPP'), "unStake", [amount], nil)
486486             if ((inv == inv))
487487                 then [IntegerEntry("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91", (amountStaked - amount))]
488488                 else throw("Strict value is not equal to itself.")
489489             }
490490         else if ((assetIdStr == "At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL"))
491491             then {
492492                 let amountStaked = tryGetInteger("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL")
493493                 let inv = invoke(Address(base58'3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C'), "unstake", [amount], nil)
494494                 if ((inv == inv))
495495                     then {
496496                         let bal0 = getBalance("At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL")
497497                         if ((bal0 == bal0))
498498                             then {
499499                                 let inv2 = invoke(Address(base58'3PQrVbTVpqXHqpVKftkNdjy3zZAh4dsRzN6'), "gnsbtRewardsSYSREADONLY", [toString(this)], nil)
500500                                 if ((inv2 == inv2))
501501                                     then {
502502                                         let topupRewards =                                         match inv2 {
503503                                             case x: List[Any] => 
504504                                                 let secondEl = x[1]
505505                                                 match secondEl {
506506                                                     case secondEl: String => 
507507                                                         let usdnValue = parseIntValue(split(split(secondEl, "_")[1], ":")[1])
508508                                                         let wavesValue = parseIntValue(split(split(secondEl, "_")[0], ":")[1])
509509                                                         if (if ((usdnValue != 0))
510510                                                             then true
511511                                                             else (wavesValue != 0))
512512                                                             then {
513513                                                                 let usdnBal0 = getBalance("DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
514514                                                                 if ((usdnBal0 == usdnBal0))
515515                                                                     then {
516516                                                                         let wavesBal0 = getBalance("WAVES")
517517                                                                         if ((wavesBal0 == wavesBal0))
518518                                                                             then {
519519                                                                                 let inv3 = invoke(Address(base58'3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C'), "claimRewards", nil, nil)
520520                                                                                 if ((inv3 == inv3))
521521                                                                                     then {
522522                                                                                         let wavesBal1 = getBalance("WAVES")
523523                                                                                         if ((wavesBal1 == wavesBal1))
524524                                                                                             then {
525525                                                                                                 let inv4 = invoke(Address(base58'3PLiXyywNThdvf3vVEUxwc7TJTucjZvuegh'), "swap", ["DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p", 0], [AttachedPayment(unit, (wavesBal1 - wavesBal0))])
526526                                                                                                 if ((inv4 == inv4))
527527                                                                                                     then {
528528                                                                                                         let usdnBal1 = getBalance("DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
529529                                                                                                         if ((usdnBal1 == usdnBal1))
530530                                                                                                             then {
531531                                                                                                                 let inv5 = invoke(Address(base58'3P7r93vXHuusageNJVGwzqaz3WMotAu49Yz'), "swap", ["At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", 0], [AttachedPayment(base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p', (usdnBal1 - usdnBal0))])
532532                                                                                                                 if ((inv5 == inv5))
533533                                                                                                                     then {
534534                                                                                                                         let inv6 = invoke(this, "addInterest", ["At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", (getBalance("At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL") - bal0)], nil)
535535                                                                                                                         if ((inv6 == inv6))
536536                                                                                                                             then 2
537537                                                                                                                             else throw("Strict value is not equal to itself.")
538538                                                                                                                         }
539539                                                                                                                     else throw("Strict value is not equal to itself.")
540540                                                                                                                 }
541541                                                                                                             else throw("Strict value is not equal to itself.")
542542                                                                                                         }
543543                                                                                                     else throw("Strict value is not equal to itself.")
544544                                                                                                 }
545545                                                                                             else throw("Strict value is not equal to itself.")
546546                                                                                         }
547547                                                                                     else throw("Strict value is not equal to itself.")
548548                                                                                 }
549549                                                                             else throw("Strict value is not equal to itself.")
550550                                                                         }
551551                                                                     else throw("Strict value is not equal to itself.")
552552                                                                 }
553553                                                             else 1
554554                                                     case _ => 
555555                                                         1
556556                                                 }
557557                                             case _ => 
558558                                                 0
559559                                         }
560560                                         if ((topupRewards == topupRewards))
561561                                             then [IntegerEntry("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", (amountStaked - amount))]
562562                                             else throw("Strict value is not equal to itself.")
563563                                         }
564564                                     else throw("Strict value is not equal to itself.")
565565                                 }
566566                             else throw("Strict value is not equal to itself.")
567567                         }
568568                     else throw("Strict value is not equal to itself.")
569569                 }
570570             else nil
571571 
572572 
573573 
574574 @Callable(i)
575575 func addInterest (assetIdStr,amount) = if ((i.caller != this))
576576     then throw("only for self invocation")
577577     else {
578578         let earned = tryGetInteger(("autostake_lastEarned_" + assetIdStr))
579579         let lastHeight = tryGetInteger(("autostake_lastBlock_" + assetIdStr))
580580         let cleanAmount = fraction(amount, 80, 100)
581581         let stateChanges = if (if ((lastHeight == height))
582582             then true
583583             else (amount == 0))
584584             then nil
585585             else [IntegerEntry(("autostake_preLastEarned_" + assetIdStr), earned), IntegerEntry(("autostake_preLastBlock_" + assetIdStr), lastHeight), IntegerEntry(("autostake_lastEarned_" + assetIdStr), (earned + cleanAmount)), IntegerEntry(("autostake_lastBlock_" + assetIdStr), height)]
586586         (stateChanges ++ [IntegerEntry((assetIdStr + "_sRate"), (tryGetInteger((assetIdStr + "_sRate")) + fraction(Scale16, cleanAmount, tryGetInteger(("total_supplied_" + assetIdStr)))))])
587587         }
588588 
589589 
590590 
591591 @Callable(i)
592592 func addInterestEXTERNAL () = {
593593     let amount = fraction(i.payments[0].amount, 80, 100)
594594     let assetId = i.payments[0].assetId
595595     let assetIdStr = getAssetString(assetId)
596596     let earned = tryGetInteger(("autostake_lastEarned_" + assetIdStr))
597597     let lastHeight = tryGetInteger(("autostake_lastBlock_" + assetIdStr))
598598     let stateChanges = if (if ((lastHeight == height))
599599         then true
600600         else (amount == 0))
601601         then nil
602602         else [IntegerEntry(("autostake_preLastEarned_" + assetIdStr), earned), IntegerEntry(("autostake_preLastBlock_" + assetIdStr), lastHeight), IntegerEntry(("autostake_lastEarned_" + assetIdStr), (earned + amount)), IntegerEntry(("autostake_lastBlock_" + assetIdStr), height)]
603603     (stateChanges ++ [IntegerEntry((assetIdStr + "_sRate"), (tryGetInteger((assetIdStr + "_sRate")) + fraction(Scale16, amount, tryGetInteger(("total_supplied_" + assetIdStr)))))])
604604     }
605605 
606606 
607607 
608608 @Callable(i)
609609 func preInit (tokens,ltvs,lts,penalties) = {
610610     func f (accum,token) =     (accum ++ [IntegerEntry((token + "_bRate"), Scale16), IntegerEntry((token + "_sRate"), Scale16)])
611611 
612612     if ((i.caller != this))
613613         then throw("admin only")
614614         else {
615615             let rates = {
616616                 let $l = split(tokens, ",")
617617                 let $s = size($l)
618618                 let $acc0 = nil
619619                 func $f0_1 ($a,$i) =                 if (($i >= $s))
620620                     then $a
621621                     else f($a, $l[$i])
622622 
623623                 func $f0_2 ($a,$i) =                 if (($i >= $s))
624624                     then $a
625625                     else throw("List size exceeds 6")
626626 
627627                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
628628                 }
629629             ([StringEntry("setup_tokens", tokens), StringEntry("setup_ltvs", ltvs), StringEntry("setup_lts", lts), StringEntry("setup_penalties", penalties), BooleanEntry("setup_active", true)] ++ rates)
630630             }
631631     }
632632 
633633 
634634 
635635 @Callable(i)
636636 func updateParameter (key,val) = if (if ((i.caller != this))
637637     then (i.caller != Address(base58'3P3o9cLTV2u9N4nYNKRYL6gy6cUEU9DwXW8'))
638638     else false)
639639     then throw("admin only")
640640     else [IntegerEntry(key, parseIntValue(val))]
641641 
642642 
643643 
644644 @Callable(i)
645645 func updateString (key,val) = if (if ((i.caller != this))
646646     then (i.caller != Address(base58'3P3o9cLTV2u9N4nYNKRYL6gy6cUEU9DwXW8'))
647647     else false)
648648     then throw("admin only")
649649     else [StringEntry(key, val)]
650650 
651651 
652652 
653653 @Callable(i)
654654 func claimToReserveFund (debug) = {
655655     let assets = getMarketAssets()
656656     let rates = getActualRate(assets[0], "sRate")._2
657657     let li = [0, 1, 2, 3, 4, 5]
658658     func f (accum,n) =     if ((n >= size(assets)))
659659         then accum
660660         else {
661661             let assetIdStr = assets[n]
662662             let autostakeAmount = tryGetString(("autostake_amount_" + assetIdStr))
663663             let amount = ((((getBalance(assetIdStr) + tryGetInteger(("autostake_amount_" + assetIdStr))) + (if ((autostakeAmount != ""))
664664                 then parseIntValue(autostakeAmount)
665665                 else 0)) + fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), rates[((n * 3) + 1)].value, Scale16)) - fraction(tryGetInteger(("total_supplied_" + assetIdStr)), rates[(n * 3)].value, Scale16))
666666             let inv = if ((tryGetInteger(("autostake_amount_" + assetIdStr)) > 0))
667667                 then invoke(this, "unstakeToken", [assetIdStr, max([amount, 0])], nil)
668668                 else 0
669669             if ((inv == inv))
670670                 then (accum ++ [amount])
671671                 else throw("Strict value is not equal to itself.")
672672             }
673673 
674674     let parameter = {
675675         let $l = li
676676         let $s = size($l)
677677         let $acc0 = nil
678678         func $f0_1 ($a,$i) =         if (($i >= $s))
679679             then $a
680680             else f($a, $l[$i])
681681 
682682         func $f0_2 ($a,$i) =         if (($i >= $s))
683683             then $a
684684             else throw("List size exceeds 6")
685685 
686686         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
687687         }
688688     func f2 (accum,n) =     if ((n >= size(assets)))
689689         then accum
690690         else {
691691             let assetIdStr = assets[n]
692692             (accum ++ [ScriptTransfer(reserveFundAddress, max([parameter[n], 0]), getAssetBytes(assetIdStr))])
693693             }
694694 
695695     if (debug)
696696         then throw(liIntToStr(parameter))
697697         else $Tuple2({
698698             let $l = li
699699             let $s = size($l)
700700             let $acc0 = nil
701701             func $f1_1 ($a,$i) =             if (($i >= $s))
702702                 then $a
703703                 else f2($a, $l[$i])
704704 
705705             func $f1_2 ($a,$i) =             if (($i >= $s))
706706                 then $a
707707                 else throw("List size exceeds 6")
708708 
709709             $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6)
710710             }, parameter)
711711     }
712712 
713713 
714714 
715715 @Callable(i)
716716 func reSetup (assetIdStr) = {
717717     let lastResetup = tryGetInteger("resetup_lastUpdate")
718718     if ((dayBlocks > (height - lastResetup)))
719719         then throw("can be updated only once per day")
720720         else {
721721             let lts = split(tryGetString("setup_lts"), ",")
722722             let assets = getMarketAssets()
723723             let ur = getUr(assetIdStr)
724724             let tempLT = tryGetInteger((("setup_" + assetIdStr) + "_tempLT"))
725725             let lt = parseIntValue(assets[value(indexOf(assets, assetIdStr))])
726726             if ((ur > 90000000))
727727                 then [IntegerEntry((("setup_" + assetIdStr) + "_tempLT"), fraction(tempLT, 9975, 10000))]
728728                 else if (if ((lt > tempLT))
729729                     then (90000000 > ur)
730730                     else false)
731731                     then [IntegerEntry((("setup_" + assetIdStr) + "_tempLT"), fraction(tempLT, 10025, 10000))]
732732                     else nil
733733             }
734734     }
735735 
736736 
737737 
738738 @Callable(i)
739739 func shutdown (shutdown) = if ((indexOf(shutdownWhitelist, i.caller.bytes) == unit))
740740     then throw("user not in a whitelist")
741741     else [BooleanEntry("setup_active", !(shutdown))]
742742 
743743 
744744 
745745 @Callable(i)
746746 func liquidate (debug,address,assetAmount,sAssetIdStr,bAssetIdStr,routeStr) = if (!(verifyLiquidatorRights(i.caller)))
747747     then throw("temporarily available for whitelist only")
748748     else if (!(tryGetBoolean("setup_active")))
749749         then throw("market is stopped")
750750         else {
751751             let userCollateral = calcUserCollateral(address)
752752             if ((userCollateral == userCollateral))
753753                 then {
754-                    let $t02593625998 = getActualRate(sAssetIdStr, "sRate")
755-                    let sRate = $t02593625998._1
756-                    let ratesResult = $t02593625998._2
757-                    let $t02600326072 = getActualRate(bAssetIdStr, "bRate")
758-                    let bRate = $t02600326072._1
759-                    let ratesRecalcResult2 = $t02600326072._2
754+                    let $t02594726009 = getActualRate(sAssetIdStr, "sRate")
755+                    let sRate = $t02594726009._1
756+                    let ratesResult = $t02594726009._2
757+                    let $t02601426083 = getActualRate(bAssetIdStr, "bRate")
758+                    let bRate = $t02601426083._1
759+                    let ratesRecalcResult2 = $t02601426083._2
760760                     let sAssetAmount = fraction(assetAmount, Scale16, sRate)
761761                     let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
762762                     let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
763763                     let currentBPosition = if ((currentBPositionVal > 0))
764764                         then currentBPositionVal
765765                         else throw("user has no borrow in this token")
766766                     if ((userCollateral > 0))
767767                         then throw("user can't be liquidated")
768768                         else if ((sAssetAmount > currentSPosition))
769769                             then throw("position to liquidate is bigger than user's supply")
770770                             else {
771771                                 let balance0Before = getBalance(sAssetIdStr)
772772                                 if ((balance0Before == balance0Before))
773773                                     then {
774774                                         let balance1Before = getBalance(bAssetIdStr)
775775                                         if ((balance1Before == balance1Before))
776776                                             then {
777777                                                 let exchangeInvoke = invoke(aggregatorAddress, "swap", [routeStr, 0], [AttachedPayment(getAssetBytes(sAssetIdStr), assetAmount)])
778778                                                 if ((exchangeInvoke == exchangeInvoke))
779779                                                     then {
780780                                                         let asset0Sold = (balance0Before - getBalance(sAssetIdStr))
781781                                                         if ((asset0Sold == asset0Sold))
782782                                                             then {
783783                                                                 let asset1Bought = (getBalance(bAssetIdStr) - balance1Before)
784784                                                                 if ((asset1Bought == asset1Bought))
785785                                                                     then {
786786                                                                         let asset0Price = getTokenPrice(sAssetIdStr)._1
787787                                                                         let asset0Scale = calcAssetScale(sAssetIdStr)
788788                                                                         let asset0Usd = fraction(asset0Sold, asset0Price, asset0Scale)
789789                                                                         let asset1Price = getTokenPrice(bAssetIdStr)._2
790790                                                                         let asset1Scale = calcAssetScale(bAssetIdStr)
791791                                                                         let asset1Usd = fraction(asset1Bought, asset1Price, asset1Scale)
792792                                                                         let penalty = parseIntValue(split(tryGetString("setup_penalties"), ",")[value(indexOf(getMarketAssets(), bAssetIdStr))])
793793                                                                         let liquidationProfit = (asset1Usd - fraction(asset0Usd, (Scale8 - penalty), Scale8))
794794                                                                         let sAssetChange = fraction(asset0Sold, Scale16, sRate)
795795                                                                         let bAssetChange = fraction(fraction(asset1Bought, Scale16, bRate), (Scale8 - fraction(liquidationProfit, Scale8, asset1Usd)), Scale8)
796796                                                                         if ((asset0Sold > assetAmount))
797797                                                                             then throw("more assets exchanged than expected")
798798                                                                             else if ((0 > liquidationProfit))
799799                                                                                 then throw("price impact is bigger than liquidation penalty")
800800                                                                                 else [IntegerEntry(((address + "_supplied_") + sAssetIdStr), (currentSPosition - sAssetChange)), IntegerEntry(((address + "_borrowed_") + bAssetIdStr), (currentBPosition - bAssetChange)), IntegerEntry(("total_supplied_" + sAssetIdStr), (tryGetInteger(("total_supplied_" + sAssetIdStr)) - sAssetChange)), IntegerEntry(("total_borrowed_" + bAssetIdStr), (tryGetInteger(("total_borrowed_" + bAssetIdStr)) - bAssetChange))]
801801                                                                         }
802802                                                                     else throw("Strict value is not equal to itself.")
803803                                                                 }
804804                                                             else throw("Strict value is not equal to itself.")
805805                                                         }
806806                                                     else throw("Strict value is not equal to itself.")
807807                                                 }
808808                                             else throw("Strict value is not equal to itself.")
809809                                         }
810810                                     else throw("Strict value is not equal to itself.")
811811                                 }
812812                     }
813813                 else throw("Strict value is not equal to itself.")
814814             }
815815 
816816 
817817 
818818 @Callable(i)
819819 func liquidateV2 (debug,address,sAssetIdStr) = if (!(verifyLiquidatorRights(i.caller)))
820820     then throw("temporarily available for whitelist only")
821821     else if (!(tryGetBoolean("setup_active")))
822822         then throw("market is stopped")
823823         else {
824824             let bAssetId = i.payments[0].assetId
825825             let bAssetIdStr = getAssetString(bAssetId)
826826             let bAssetAmount = i.payments[0].amount
827827             let userCollateral = calcUserCollateral(address)
828828             if ((userCollateral == userCollateral))
829829                 then if ((userCollateral > 0))
830830                     then throw("user can't be liquidated")
831831                     else {
832832                         let marketAssets = getMarketAssets()
833833                         let asset1Num = value(indexOf(marketAssets, bAssetIdStr))
834834                         let asset0Num = value(indexOf(marketAssets, sAssetIdStr))
835-                        let $t02922729289 = getActualRate(bAssetIdStr, "bRate")
836-                        let bRate = $t02922729289._1
837-                        let ratesResult = $t02922729289._2
835+                        let $t02923829300 = getActualRate(bAssetIdStr, "bRate")
836+                        let bRate = $t02923829300._1
837+                        let ratesResult = $t02923829300._2
838838                         let asset1Price = getTokenPrice(bAssetIdStr)._2
839839                         let asset1Scale = calcAssetScale(bAssetIdStr)
840840                         let bAmountUsd = fraction(bAssetAmount, asset1Price, asset1Scale)
841841                         let penalty = parseIntValue(value(split(tryGetString("setup_penalties"), ",")[asset1Num]))
842842                         let asset0Price = getTokenPrice(sAssetIdStr)._1
843843                         let asset0Scale = calcAssetScale(sAssetIdStr)
844844                         let sAmountUsd = fraction(bAmountUsd, (Scale8 + penalty), Scale8)
845845                         let sAssetAmount = fraction(sAmountUsd, asset0Scale, asset0Price)
846846                         let bAmount = fraction(bAssetAmount, Scale16, bRate)
847847                         let sAmount = fraction(sAssetAmount, Scale16, ratesResult[((asset0Num * 3) + 1)].value)
848848                         let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
849849                         let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
850850                         let currentBPosition = if ((currentBPositionVal > 0))
851851                             then currentBPositionVal
852852                             else throw("user has no borrow in this token")
853853                         if ((sAmount > currentSPosition))
854854                             then throw("position to liquidate is bigger than user's supply")
855855                             else if (debug)
856856                                 then throw("liquidation will pass")
857857                                 else ([ScriptTransfer(i.caller, sAssetAmount, getAssetBytes(sAssetIdStr)), IntegerEntry(((address + "_supplied_") + sAssetIdStr), (currentSPosition - sAmount)), IntegerEntry(((address + "_borrowed_") + bAssetIdStr), (currentBPosition - bAmount)), IntegerEntry(("total_supplied_" + sAssetIdStr), (tryGetInteger(("total_supplied_" + sAssetIdStr)) - sAmount)), IntegerEntry(("total_borrowed_" + bAssetIdStr), (tryGetInteger(("total_borrowed_" + bAssetIdStr)) - bAmount))] ++ ratesResult)
858858                         }
859859                 else throw("Strict value is not equal to itself.")
860860             }
861861 
862862 
863863 
864864 @Callable(i)
865865 func getUserCollateral (debug,address,minusBorrowed,afterChange) = {
866866     let assets = getMarketAssets()
867867     let ltvs = split(tryGetString("setup_ltvs"), ",")
868868     let lts = split(tryGetString("setup_lts"), ",")
869869     let rates = getActualRate(assets[0], "sRate")._2
870870     let changeHandler = split(afterChange, ",")
871871     func f (accum,next) =     if ((next >= size(assets)))
872872         then accum
873873         else {
874874             let userSupplied = tryGetInteger(((address + "_supplied_") + assets[next]))
875875             let userBorrowed = tryGetInteger(((address + "_borrowed_") + assets[next]))
876876             let needTokenAccounting = if ((afterChange == ""))
877877                 then if (if ((userBorrowed != 0))
878878                     then true
879879                     else (userSupplied != 0))
880880                     then true
881881                     else false
882882                 else true
883883             if (needTokenAccounting)
884884                 then {
885885                     let assetScale = calcAssetScale(assets[next])
886886                     let assetPrice = getTokenPrice(assets[next])
887887                     ((accum + fraction(fraction(fraction((userSupplied + (if (if (if ((afterChange != ""))
888888                         then (changeHandler[0] == assets[next])
889889                         else false)
890890                         then (changeHandler[1] == "supplied")
891891                         else false)
892892                         then parseIntValue(changeHandler[2])
893893                         else 0)), rates[(next * 3)].value, Scale16), parseIntValue(ltvs[next]), Scale8), assetPrice._1, assetScale)) - (if (minusBorrowed)
894894                         then fraction(fraction(fraction((userBorrowed + (if (if (if ((afterChange != ""))
895895                             then (changeHandler[0] == assets[next])
896896                             else false)
897897                             then (changeHandler[1] == "borrowed")
898898                             else false)
899899                             then parseIntValue(changeHandler[2])
900900                             else 0)), rates[((next * 3) + 1)].value, Scale16), Scale8, parseIntValue(lts[next])), assetPrice._2, assetScale)
901901                         else 0))
902902                     }
903903                 else accum
904904             }
905905 
906906     let result = {
907907         let $l = [0, 1, 2, 3, 4, 5]
908908         let $s = size($l)
909909         let $acc0 = 0
910910         func $f0_1 ($a,$i) =         if (($i >= $s))
911911             then $a
912912             else f($a, $l[$i])
913913 
914914         func $f0_2 ($a,$i) =         if (($i >= $s))
915915             then $a
916916             else throw("List size exceeds 6")
917917 
918918         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
919919         }
920920     if (debug)
921921         then throw(toString(result))
922922         else $Tuple2(rates, result)
923923     }
924924 
925925 
926926 
927927 @Callable(i)
928928 func getAssetDebt (debug,address,assetIdStr) = {
929929     let userBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
930930     let assetScale = calcAssetScale(assetIdStr)
931931     let rate = getActualRate(assetIdStr, "bRate")._1
932932     let result = fraction(userBorrowed, rate, Scale16)
933933     if (debug)
934934         then throw(toString(result))
935935         else $Tuple2(nil, result)
936936     }
937937 
938938 
939939 
940940 @Callable(i)
941941 func getPrices (debug) = {
942942     let assets = getMarketAssets()
943943     func f (accum,next) =     if ((next >= size(assets)))
944944         then accum
945945         else {
946946             let assetPrice = getTokenPrice(assets[next])
947947             ((((accum + toString(assetPrice._1)) + ",") + toString(assetPrice._2)) + "|")
948948             }
949949 
950950     let result = {
951951         let $l = [0, 1, 2, 3, 4, 5]
952952         let $s = size($l)
953953         let $acc0 = ""
954954         func $f0_1 ($a,$i) =         if (($i >= $s))
955955             then $a
956956             else f($a, $l[$i])
957957 
958958         func $f0_2 ($a,$i) =         if (($i >= $s))
959959             then $a
960960             else throw("List size exceeds 6")
961961 
962962         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
963963         }
964964     if (debug)
965965         then throw(result)
966966         else $Tuple2(nil, result)
967967     }
968968 
969969 
970970 
971971 @Callable(i)
972972 func calculateUtilizationRatio (assetIdStr,debug) = if (debug)
973973     then throw(toString(getUr(assetIdStr)))
974974     else $Tuple2(nil, getUr(assetIdStr))
975975 
976976 
977977 
978978 @Callable(i)
979979 func calculateOutdatedUR (assetIdStr,debug) = if (debug)
980980     then throw(toString(getOutdatedUr(assetIdStr)))
981981     else $Tuple2(nil, getOutdatedUr(assetIdStr))
982982 
983983 
984984 
985985 @Callable(i)
986986 func calculateTokenRates (debug) = {
987987     func f (accum,assetIdStr) =     {
988988         let rates = tokenRatesRecalc(assetIdStr)
989989         $Tuple2(((((accum._1 + toString(rates[1].value)) + "|") + toString(rates[0].value)) + ","), (accum._2 ++ rates))
990990         }
991991 
992992     let parameter = {
993993         let $l = getMarketAssets()
994994         let $s = size($l)
995995         let $acc0 = $Tuple2("", nil)
996996         func $f0_1 ($a,$i) =         if (($i >= $s))
997997             then $a
998998             else f($a, $l[$i])
999999 
10001000         func $f0_2 ($a,$i) =         if (($i >= $s))
10011001             then $a
10021002             else throw("List size exceeds 6")
10031003 
10041004         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
10051005         }
10061006     if (debug)
10071007         then throw(parameter._1)
10081008         else $Tuple2(parameter._2, parameter._1)
10091009     }
10101010 
10111011 
10121012 
10131013 @Callable(i)
10141014 func calculateTokensInterest (debug) = {
10151015     func f (accum,assetIdStr) =     {
10161016         let rate = fraction(getInterest(assetIdStr), dayBlocks, Scale8)
10171017         ((accum + toString(rate)) + ",")
10181018         }
10191019 
10201020     let parameter = {
10211021         let $l = getMarketAssets()
10221022         let $s = size($l)
10231023         let $acc0 = ""
10241024         func $f0_1 ($a,$i) =         if (($i >= $s))
10251025             then $a
10261026             else f($a, $l[$i])
10271027 
10281028         func $f0_2 ($a,$i) =         if (($i >= $s))
10291029             then $a
10301030             else throw("List size exceeds 6")
10311031 
10321032         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6)
10331033         }
10341034     if (debug)
10351035         then throw(parameter)
10361036         else $Tuple2(nil, parameter)
10371037     }
10381038 
10391039 
10401040 @Verifier(tx)
10411041 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
10421042 
github/deemru/w8io/873ac7e 
132.53 ms ◑