tx · 7gBJ4NbVyDq817EoqRHKTLACFBhjd32pwdANdpqgjqML

3MDP3uZpCEuW992eP58Gc7H7AQHFbiSX53K:  -0.06000000 Waves

2026.06.24 00:39 [823359] smart account 3MDP3uZpCEuW992eP58Gc7H7AQHFbiSX53K > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7gBJ4NbVyDq817EoqRHKTLACFBhjd32pwdANdpqgjqML",
    "fee": 6000000,
    "feeAssetId": null,
    "timestamp": 1782250781905,
    "version": 2,
    "chainId": 82,
    "sender": "3MDP3uZpCEuW992eP58Gc7H7AQHFbiSX53K",
    "senderPublicKey": "9AcZKqwg7ZV3cmoaRfDxVyo78Rq1MKeuKqoGeiwLJj5r",
    "proofs": [
        "4xXgdx52mzmc9pMQ2RKZoHz7bexjRhcQb2Vukpygheos6L8uy74uPD4mre3b7Ain8Ck1AwAMuUXVSzxpi6V4ux6M"
    ],
    "script": "base64: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",
    "height": 823359,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let CONTRACT_TYPE = "LEND-LP-MARKET"
5+
6+let VERSION = "PLP-1.2.1"
7+
8+func getAddressFromState (key) = valueOrElse(addressFromString(valueOrElse(getString(this, ("setup_address_" + key)), "3PEwRcYNAUtoFvKpBhKoiwajnZfdoDR6h4h")), Address(base58'3PEwRcYNAUtoFvKpBhKoiwajnZfdoDR6h4h'))
9+
10+
11+func getAddressesFromState (key) = {
12+    func f (accum,next) =     (accum ++ [valueOrElse(addressFromString(next), Address(base58'3PEwRcYNAUtoFvKpBhKoiwajnZfdoDR6h4h'))])
13+
14+    let $l = split_4C(valueOrElse(getString(this, ("setup_address_" + key)), "3PEwRcYNAUtoFvKpBhKoiwajnZfdoDR6h4h"), ",")
15+    let $s = size($l)
16+    let $acc0 = nil
17+    func $f0_1 ($a,$i) =     if (($i >= $s))
18+        then $a
19+        else f($a, $l[$i])
20+
21+    func $f0_2 ($a,$i) =     if (($i >= $s))
22+        then $a
23+        else throw("List size exceeds 15")
24+
25+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
26+    }
27+
28+
29+let reserveFundAddress = getAddressFromState("reserveFund")
30+
31+let oracleAddress = getAddressFromState("oracle")
32+
33+let aggregatorAddress = getAddressFromState("aggregator")
34+
35+let adminAddress = getAddressFromState("admin")
36+
37+let stableFundAddress = getAddressFromState("stableFund")
38+
39+let feeCollectorAddress = getAddressFromState("feeCollector")
40+
41+let shutdownWhitelist = getAddressesFromState("shutdownCallers")
42+
43+let liquidatorsWhitelist = getAddressesFromState("liquidators")
44+
45+func verifyLiquidatorRights (address) = (indexOf(liquidatorsWhitelist, address) != unit)
46+
47+
48+let reserveFund = valueOrElse(getInteger(this, "setup_reserveFundFee"), 20)
49+
50+let stablesIdStr = split(valueOrElse(getString(this, "setup_stablesIds"), "9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi,HGgabTqUS8WtVFUJzfmrTDMgEccJuZLBPhFgQFxvnsoW"), ",")
51+
52+func getRateCurve (assetIdStr) = {
53+    let curveRateStrLi = split(valueOrElse(getString(this, ("setup_rateCurve_" + assetIdStr)), "20000000,100000000,60000000,400000000"), ",")
54+    $Tuple4(parseIntValue(curveRateStrLi[0]), parseIntValue(curveRateStrLi[1]), parseIntValue(curveRateStrLi[2]), parseIntValue(curveRateStrLi[3]))
55+    }
56+
57+
58+func getRewardsSplitting (assetIdStr) = {
59+    let rewardsSplittingStrLi = split(valueOrElse(getString(this, ("setup_rewardsSplitting_" + assetIdStr)), "30,50,20"), ",")
60+    $Tuple3(parseIntValue(rewardsSplittingStrLi[0]), parseIntValue(rewardsSplittingStrLi[1]), parseIntValue(rewardsSplittingStrLi[2]))
61+    }
62+
63+
64+let sentinels = [Address(base58'3PMcMiMEs6w56NRGacksXtFG5zS7doE9fpL'), Address(base58'3PQdNxynJy5mche2kxMVc5shXWzK8Gstq3o'), Address(base58'3P8auNWJkxxByyJtwErFXaxiXcGM45qQ1hA'), Address(base58'3P8qVX189qpoTJZQQQdKS9endHK5sxWsvrd')]
65+
66+let Scale8 = 100000000
67+
68+let Scale10 = 10000000000
69+
70+let Scale16 = (Scale8 * Scale8)
71+
72+let dayBlocks = 1440
73+
74+let withdrawalLimitBlocks = valueOrElse(getInteger(this, "setup_withdrawalLimitBlocks"), 100)
75+
76+func liIntToStr (li) = {
77+    func f (accum,next) =     ((accum + toString(next)) + ",")
78+
79+    let $l = li
80+    let $s = size($l)
81+    let $acc0 = ""
82+    func $f0_1 ($a,$i) =     if (($i >= $s))
83+        then $a
84+        else f($a, $l[$i])
85+
86+    func $f0_2 ($a,$i) =     if (($i >= $s))
87+        then $a
88+        else throw("List size exceeds 12")
89+
90+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
91+    }
92+
93+
94+func tryGetInteger (key) = match getInteger(this, key) {
95+    case b: Int => 
96+        b
97+    case _ => 
98+        0
99+}
100+
101+
102+func tryGetBoolean (key) = match getBoolean(this, key) {
103+    case b: Boolean => 
104+        b
105+    case _ => 
106+        false
107+}
108+
109+
110+func tryGetString (key) = match getString(this, key) {
111+    case b: String => 
112+        b
113+    case _ => 
114+        ""
115+}
116+
117+
118+func tryGetBinary (key) = match getBinary(this, key) {
119+    case b: ByteVector => 
120+        b
121+    case _ => 
122+        base58''
123+}
124+
125+
126+func getAssetString (assetId) = match assetId {
127+    case b: ByteVector => 
128+        toBase58String(b)
129+    case _ => 
130+        "WAVES"
131+}
132+
133+
134+func getAssetBytes (assetIdStr) = if ((assetIdStr == "WAVES"))
135+    then unit
136+    else fromBase58String(assetIdStr)
137+
138+
139+func getBalance (assetIdStr) = if ((assetIdStr == "WAVES"))
140+    then wavesBalance(this).available
141+    else assetBalance(this, fromBase58String(assetIdStr))
142+
143+
144+func getMarketAssets () = split(tryGetString("setup_tokens"), ",")
145+
146+
147+func getOutdatedUr (assetIdStr) = {
148+    let down = fraction(tryGetInteger(("total_supplied_" + assetIdStr)), tryGetInteger((assetIdStr + "_sRate")), Scale16)
149+    if ((down == 0))
150+        then 0
151+        else fraction(Scale8, fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), tryGetInteger((assetIdStr + "_bRate")), Scale16), down)
152+    }
153+
154+
155+func getInterest (assetIdStr) = {
156+    let ur = getOutdatedUr(assetIdStr)
157+    let curve = getRateCurve(assetIdStr)
158+    let rate = (curve._1 + (if ((curve._3 >= ur))
159+        then fraction(ur, curve._2, curve._3)
160+        else (curve._2 + fraction((ur - curve._3), curve._4, (100000000 - curve._3)))))
161+    max([fraction(rate, Scale8, (dayBlocks * 365)), 1])
162+    }
163+
164+
165+func tokenRatesRecalc (assetIdStr) = {
166+    let interest = getInterest(assetIdStr)
167+    let ur = getOutdatedUr(assetIdStr)
168+    let lastRecalcHeight = tryGetInteger("lastRateHeight")
169+    let lastBRate = max([tryGetInteger((assetIdStr + "_bRate")), Scale16])
170+    let newBRate = (lastBRate + ((height - lastRecalcHeight) * interest))
171+    let lastSRate = max([tryGetInteger((assetIdStr + "_sRate")), Scale16])
172+    let newSRate = (lastSRate + ((((height - lastRecalcHeight) * fraction(interest, ur, Scale8)) * (100 - reserveFund)) / 100))
173+[IntegerEntry((assetIdStr + "_sRate"), newSRate), IntegerEntry((assetIdStr + "_bRate"), newBRate), IntegerEntry("lastRateHeight", height)]
174+    }
175+
176+
177+func getActualRate (assetIdStr,rateType) = {
178+    func f (accum,token) =     {
179+        let recalc = tokenRatesRecalc(token)
180+        $Tuple2(if ((token != assetIdStr))
181+            then accum._1
182+            else if ((rateType == "sRate"))
183+                then recalc[0].value
184+                else recalc[1].value, (accum._2 ++ recalc))
185+        }
186+
187+    let $l = getMarketAssets()
188+    let $s = size($l)
189+    let $acc0 = $Tuple2(0, nil)
190+    func $f0_1 ($a,$i) =     if (($i >= $s))
191+        then $a
192+        else f($a, $l[$i])
193+
194+    func $f0_2 ($a,$i) =     if (($i >= $s))
195+        then $a
196+        else throw("List size exceeds 12")
197+
198+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
199+    }
200+
201+
202+func getUr (assetIdStr) = {
203+    let rates = tokenRatesRecalc(assetIdStr)
204+    let down = fraction(tryGetInteger(("total_supplied_" + assetIdStr)), rates[0].value, Scale16)
205+    fraction(Scale8, fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), rates[1].value, Scale16), down)
206+    }
207+
208+
209+func ratesRecalc () = {
210+    func f (accum,token) =     (accum ++ tokenRatesRecalc(token))
211+
212+    let $l = getMarketAssets()
213+    let $s = size($l)
214+    let $acc0 = nil
215+    func $f0_1 ($a,$i) =     if (($i >= $s))
216+        then $a
217+        else f($a, $l[$i])
218+
219+    func $f0_2 ($a,$i) =     if (($i >= $s))
220+        then $a
221+        else throw("List size exceeds 12")
222+
223+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
224+    }
225+
226+
227+func getTokenPriceWithRisk (assetIdStr,riskAversity) = if ((indexOf(stablesIdStr, assetIdStr) != unit))
228+    then $Tuple2(1000000, 1000000)
229+    else {
230+        let price = getIntegerValue(oracleAddress, (assetIdStr + "_twap5B"))
231+        let riskLevel = getIntegerValue(oracleAddress, (assetIdStr + "_riskLevel"))
232+        if ((riskAversity >= riskLevel))
233+            then $Tuple2(price, price)
234+            else throw((("oracle prices don't match: " + toString(price)) + " is the price, but risk is too high"))
235+        }
236+
237+
238+func getTokenPrice (assetIdStr) = getTokenPriceWithRisk(assetIdStr, 3)
239+
240+
241+func getTokenPriceCapped (assetIdStr) = {
242+    let $t079878050 = getTokenPriceWithRisk(assetIdStr, 3)
243+    let minPrice = $t079878050._1
244+    let maxPrice = $t079878050._2
245+    let maxAllowedPrice = valueOrElse(getInteger(this, ("setup_maxPrice_" + assetIdStr)), -1)
246+    let minAllowedPrice = valueOrElse(getInteger(this, ("setup_minPrice_" + assetIdStr)), -1)
247+    if (if ((maxAllowedPrice != -1))
248+        then (maxPrice > maxAllowedPrice)
249+        else false)
250+        then $Tuple2(maxAllowedPrice, maxAllowedPrice)
251+        else if (if ((minAllowedPrice != -1))
252+            then (minAllowedPrice > minPrice)
253+            else false)
254+            then $Tuple2(minAllowedPrice, minAllowedPrice)
255+            else $Tuple2(minPrice, maxPrice)
256+    }
257+
258+
259+func calcAssetScale (assetIdStr) = {
260+    let decimals = if ((assetIdStr == "WAVES"))
261+        then 8
262+        else value(assetInfo(fromBase58String(assetIdStr))).decimals
263+    pow(10, 0, decimals, 0, 0, DOWN)
264+    }
265+
266+
267+func calcUserCollateral (address) = {
268+    let userCollateralInvoke = invoke(this, "getUserCollateral", [false, address, true, ""], nil)
269+    if ((userCollateralInvoke == userCollateralInvoke))
270+        then {
271+            let userCollateralValue =             match userCollateralInvoke {
272+                case x: Int => 
273+                    x
274+                case _ => 
275+                    throw("issue while doing in-dapp invocation")
276+            }
277+            if ((userCollateralValue == userCollateralValue))
278+                then userCollateralValue
279+                else throw("Strict value is not equal to itself.")
280+            }
281+        else throw("Strict value is not equal to itself.")
282+    }
283+
284+
285+func checkWithdrawalLimit (address,assetIdStr,amountInternal,sRate) = {
286+    let withdrawalLimit = valueOrElse(getInteger(this, (("setup_" + assetIdStr) + "_maxWithdrawPer100B")), -1)
287+    if ((withdrawalLimit == -1))
288+        then nil
289+        else {
290+            let totalSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
291+            let limitCap = fraction(totalSupplied, withdrawalLimit, 100)
292+            let lastH = tryGetInteger(((address + "_withdrawLimitHeight_") + assetIdStr))
293+            let elapsed = (height - lastH)
294+            let windowExpired = (elapsed > withdrawalLimitBlocks)
295+            let currentUsed = if (windowExpired)
296+                then 0
297+                else tryGetInteger(((address + "_withdrawLimitUsed_") + assetIdStr))
298+            let blocksToReset = if (windowExpired)
299+                then withdrawalLimitBlocks
300+                else (withdrawalLimitBlocks - elapsed)
301+            let available = (limitCap - currentUsed)
302+            let availableScaled = fraction(available, sRate, Scale16, CEILING)
303+            if ((amountInternal > available))
304+                then throw(((((("withdrawal limit exceeded for " + assetIdStr) + ", available: ") + toString(availableScaled)) + ", blocks to reset: ") + toString(blocksToReset)))
305+                else ((if (windowExpired)
306+                    then [IntegerEntry(((address + "_withdrawLimitHeight_") + assetIdStr), height)]
307+                    else nil) ++ [IntegerEntry(((address + "_withdrawLimitUsed_") + assetIdStr), (currentUsed + amountInternal))])
308+            }
309+    }
310+
311+
312+func checkBorrowLimit (address,assetIdStr,amountInternal,bRate,sRate) = {
313+    let borrowLimit = valueOrElse(getInteger(this, (("setup_" + assetIdStr) + "_maxBorrowPer100B")), -1)
314+    if ((borrowLimit == -1))
315+        then nil
316+        else {
317+            let totalSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
318+            let limitCapSupply = fraction(totalSupplied, borrowLimit, 100)
319+            let limitCap = fraction(fraction(limitCapSupply, sRate, Scale16), Scale16, bRate)
320+            let lastH = tryGetInteger(((address + "_borrowLimitHeight_") + assetIdStr))
321+            let elapsed = (height - lastH)
322+            let windowExpired = (elapsed > withdrawalLimitBlocks)
323+            let currentUsed = if (windowExpired)
324+                then 0
325+                else tryGetInteger(((address + "_borrowLimitUsed_") + assetIdStr))
326+            let blocksToReset = if (windowExpired)
327+                then withdrawalLimitBlocks
328+                else (withdrawalLimitBlocks - elapsed)
329+            let available = (limitCap - currentUsed)
330+            let availableScaled = fraction(available, bRate, Scale16, CEILING)
331+            if ((amountInternal > available))
332+                then throw(((((("borrow limit exceeded for " + assetIdStr) + ", available: ") + toString(availableScaled)) + ", blocks to reset: ") + toString(blocksToReset)))
333+                else ((if (windowExpired)
334+                    then [IntegerEntry(((address + "_borrowLimitHeight_") + assetIdStr), height)]
335+                    else nil) ++ [IntegerEntry(((address + "_borrowLimitUsed_") + assetIdStr), (currentUsed + amountInternal))])
336+            }
337+    }
338+
339+
340+@Callable(i)
341+func supply () = if (!(tryGetBoolean("setup_active")))
342+    then throw("market is stopped")
343+    else if (if ((size(i.payments) != 1))
344+        then true
345+        else (i.payments[0].amount == 0))
346+        then throw("1 payment has to be attached")
347+        else {
348+            let assetIdStr = getAssetString(i.payments[0].assetId)
349+            let assetAmount = i.payments[0].amount
350+            let $t01205812125 = getActualRate(assetIdStr, "sRate")
351+            let sRate = $t01205812125._1
352+            let ratesRecalcResult = $t01205812125._2
353+            let amount = fraction(assetAmount, Scale16, sRate, DOWN)
354+            let address = toString(i.caller)
355+            let maxSupply =             match getString(("setup_maxSupply_" + assetIdStr)) {
356+                case x: String => 
357+                    parseIntValue(x)
358+                case _ => 
359+                    tryGetInteger(("setup_maxSupply_" + assetIdStr))
360+            }
361+            let assetPrice = getTokenPriceCapped(assetIdStr)
362+            let newAddressSupplied = (tryGetInteger(((address + "_supplied_") + assetIdStr)) + amount)
363+            let newTotalSupplied = (tryGetInteger(("total_supplied_" + assetIdStr)) + amount)
364+            let rate = getActualRate(assetIdStr, "sRate")._1
365+            let assetScale = calcAssetScale(assetIdStr)
366+            let newTotalSuppliedUsd = fraction(fraction(newTotalSupplied, rate, Scale16), assetPrice._1, assetScale)
367+            if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
368+                then throw("this asset is not supported by the market")
369+                else if (if ((maxSupply != 0))
370+                    then (newTotalSuppliedUsd > maxSupply)
371+                    else false)
372+                    then throw("max total supply for this token reached in the pool")
373+                    else if ((tryGetInteger(("setup_paused_" + assetIdStr)) > 0))
374+                        then throw("this asset can't be supplied or borrowed")
375+                        else {
376+                            let inv = if ((tryGetString(("setup_autostake_" + assetIdStr)) != ""))
377+                                then invoke(this, "stakeToken", [assetIdStr, assetAmount], nil)
378+                                else unit
379+                            if ((inv == inv))
380+                                then ([IntegerEntry(((address + "_supplied_") + assetIdStr), newAddressSupplied), IntegerEntry(("total_supplied_" + assetIdStr), newTotalSupplied)] ++ ratesRecalcResult)
381+                                else throw("Strict value is not equal to itself.")
382+                            }
383+            }
384+
385+
386+
387+@Callable(i)
388+func withdraw (assetIdStr,assetAmount) = {
389+    let $t01369213759 = getActualRate(assetIdStr, "sRate")
390+    let sRate = $t01369213759._1
391+    let ratesRecalcResult = $t01369213759._2
392+    let amount = fraction(assetAmount, Scale16, sRate, CEILING)
393+    let address = toString(i.caller)
394+    let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
395+    let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
396+    let userAssetSupplied = tryGetInteger(((address + "_supplied_") + assetIdStr))
397+    let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
398+    let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",supplied,") + toString(-(amount)))], nil)
399+    if ((collateralValueInv == collateralValueInv))
400+        then {
401+            let collateralValue =             match collateralValueInv {
402+                case x: Int => 
403+                    x
404+                case _ => 
405+                    throw("can't get user collateral value")
406+            }
407+            if (!(tryGetBoolean("setup_active")))
408+                then throw("market is stopped")
409+                else if ((0 > collateralValue))
410+                    then throw("you dont have enough collateral for this operation")
411+                    else if ((amount > (assetSupplied - assetBorrowed)))
412+                        then throw("this amount is not available on the market")
413+                        else if ((amount > (userAssetSupplied - userAssetBorrowed)))
414+                            then throw("this amount is not available for this user")
415+                            else {
416+                                let inv = if ((tryGetString(("setup_autostake_" + assetIdStr)) != ""))
417+                                    then invoke(this, "unstakeToken", [assetIdStr, assetAmount], nil)
418+                                    else unit
419+                                if ((inv == inv))
420+                                    then {
421+                                        let limitCheckActions = checkWithdrawalLimit(address, assetIdStr, amount, sRate)
422+                                        if ((limitCheckActions == limitCheckActions))
423+                                            then (([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) ++ limitCheckActions)
424+                                            else throw("Strict value is not equal to itself.")
425+                                        }
426+                                    else throw("Strict value is not equal to itself.")
427+                                }
428+            }
429+        else throw("Strict value is not equal to itself.")
430+    }
431+
432+
433+
434+@Callable(i)
435+func borrow (assetIdStr,assetAmount) = {
436+    let address = toString(i.caller)
437+    let $t01552315590 = getActualRate(assetIdStr, "bRate")
438+    let bRate = $t01552315590._1
439+    let ratesRecalcResult = $t01552315590._2
440+    let amount = fraction(assetAmount, Scale16, bRate, CEILING)
441+    let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",borrowed,") + toString(amount))], nil)
442+    if ((collateralValueInv == collateralValueInv))
443+        then {
444+            let collateralValue =             match collateralValueInv {
445+                case x: Int => 
446+                    x
447+                case _ => 
448+                    throw("can't get user collateral value")
449+            }
450+            if (!(tryGetBoolean("setup_active")))
451+                then throw("market is stopped")
452+                else if ((0 > collateralValue))
453+                    then throw("you have to supply more to borrow")
454+                    else if ((tryGetInteger(("setup_borrowEnabled_" + assetIdStr)) == 0))
455+                        then throw("this asset can't be borrowed")
456+                        else if ((tryGetInteger(("setup_paused_" + assetIdStr)) > 0))
457+                            then throw("this asset can't be supplied or borrowed")
458+                            else {
459+                                let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
460+                                let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
461+                                let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
462+                                if ((amount > (assetSupplied - assetBorrowed)))
463+                                    then throw("this amount is not available")
464+                                    else {
465+                                        let inv = if ((tryGetString(("setup_autostake_" + assetIdStr)) != ""))
466+                                            then invoke(this, "unstakeToken", [assetIdStr, assetAmount], nil)
467+                                            else unit
468+                                        if ((inv == inv))
469+                                            then {
470+                                                let sRate = ratesRecalcResult[(value(indexOf(getMarketAssets(), assetIdStr)) * 3)].value
471+                                                let limitCheckActions = checkBorrowLimit(address, assetIdStr, amount, bRate, sRate)
472+                                                if ((limitCheckActions == limitCheckActions))
473+                                                    then (([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed + amount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed + amount)), ScriptTransfer(i.caller, assetAmount, getAssetBytes(assetIdStr))] ++ ratesRecalcResult) ++ limitCheckActions)
474+                                                    else throw("Strict value is not equal to itself.")
475+                                                }
476+                                            else throw("Strict value is not equal to itself.")
477+                                        }
478+                                }
479+            }
480+        else throw("Strict value is not equal to itself.")
481+    }
482+
483+
484+
485+@Callable(i)
486+func repay () = if (!(tryGetBoolean("setup_active")))
487+    then throw("market is stopped")
488+    else if (if ((size(i.payments) != 1))
489+        then true
490+        else (i.payments[0].amount == 0))
491+        then throw("1 payment has to be attached")
492+        else {
493+            let assetIdStr = getAssetString(i.payments[0].assetId)
494+            let assetAmount = i.payments[0].amount
495+            let $t01768417751 = getActualRate(assetIdStr, "bRate")
496+            let bRate = $t01768417751._1
497+            let ratesRecalcResult = $t01768417751._2
498+            let amount = fraction(assetAmount, Scale16, bRate, CEILING)
499+            let address = toString(i.caller)
500+            let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
501+            let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
502+            let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
503+            let amountLeft = (userAssetBorrowed - amount)
504+            let repayAmount = if ((amountLeft >= 0))
505+                then amount
506+                else userAssetBorrowed
507+            if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
508+                then throw("this asset is not supported by the market")
509+                else {
510+                    let inv = if ((tryGetString(("setup_autostake_" + assetIdStr)) != ""))
511+                        then invoke(this, "stakeToken", [assetIdStr, assetAmount], nil)
512+                        else unit
513+                    if ((inv == inv))
514+                        then {
515+                            let excessTokens = (assetAmount - fraction(repayAmount, bRate, Scale16))
516+                            (([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed - repayAmount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed - repayAmount))] ++ ratesRecalcResult) ++ (if ((amountLeft >= 0))
517+                                then nil
518+                                else [ScriptTransfer(i.caller, excessTokens, i.payments[0].assetId)]))
519+                            }
520+                        else throw("Strict value is not equal to itself.")
521+                    }
522+            }
523+
524+
525+
526+@Callable(i)
527+func repayFor (address) = if (!(tryGetBoolean("setup_active")))
528+    then throw("market is stopped")
529+    else if ((i.caller != reserveFundAddress))
530+        then throw("available only for reserve fund address")
531+        else if ((address == "global"))
532+            then throw("you can't repay for everyone :_)")
533+            else if (if ((size(i.payments) != 1))
534+                then true
535+                else (i.payments[0].amount == 0))
536+                then throw("1 payment has to be attached")
537+                else {
538+                    let assetIdStr = getAssetString(i.payments[0].assetId)
539+                    let assetAmount = i.payments[0].amount
540+                    let $t01942719494 = getActualRate(assetIdStr, "bRate")
541+                    let bRate = $t01942719494._1
542+                    let ratesRecalcResult = $t01942719494._2
543+                    let amount = fraction(assetAmount, Scale16, bRate, CEILING)
544+                    let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
545+                    let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
546+                    let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
547+                    let amountLeft = (userAssetBorrowed - amount)
548+                    let repayAmount = if ((amountLeft >= 0))
549+                        then amount
550+                        else userAssetBorrowed
551+                    if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
552+                        then throw("this asset is not supported by the market")
553+                        else {
554+                            let inv = if ((tryGetString(("setup_autostake_" + assetIdStr)) != ""))
555+                                then invoke(this, "stakeToken", [assetIdStr, assetAmount], nil)
556+                                else unit
557+                            if ((inv == inv))
558+                                then {
559+                                    let excessTokens = (assetAmount - fraction(repayAmount, bRate, Scale16))
560+                                    (([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed - repayAmount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed - repayAmount))] ++ ratesRecalcResult) ++ (if ((amountLeft >= 0))
561+                                        then nil
562+                                        else [ScriptTransfer(i.caller, excessTokens, i.payments[0].assetId)]))
563+                                    }
564+                                else throw("Strict value is not equal to itself.")
565+                            }
566+                    }
567+
568+
569+
570+@Callable(i)
571+func stakeToken (assetIdStr,amount) = {
572+    let autostakeAddress = valueOrElse(addressFromString(tryGetString(("setup_autostake_" + assetIdStr))), Address(base58'3PDDRRS5gKyDQRpJskzWTdxREHGu1FNpdwg'))
573+    let stakerSupportedAssets = getStringValue(autostakeAddress, "setup_supportedAssets")
574+    if ((i.caller != this))
575+        then throw("only for internal smart contract invocations")
576+        else if ((indexOf(stakerSupportedAssets, assetIdStr) == unit))
577+            then nil
578+            else {
579+                let amountStaked = tryGetInteger(("autostake_amount_" + assetIdStr))
580+                let stakeInv = reentrantInvoke(autostakeAddress, "stakeLP", nil, [AttachedPayment(getAssetBytes(assetIdStr), amount)])
581+                if ((stakeInv == stakeInv))
582+                    then [IntegerEntry(("autostake_amount_" + assetIdStr), (amountStaked + amount))]
583+                    else throw("Strict value is not equal to itself.")
584+                }
585+    }
586+
587+
588+
589+@Callable(i)
590+func stakeTokenAll (assetIdStr) = if ((i.caller != this))
591+    then throw("only for internal smart contract invocations")
592+    else {
593+        let amount = getBalance(assetIdStr)
594+        let inv = reentrantInvoke(this, "stakeToken", [assetIdStr, amount], nil)
595+        if ((inv == inv))
596+            then nil
597+            else throw("Strict value is not equal to itself.")
598+        }
599+
600+
601+
602+@Callable(i)
603+func unstakeToken (assetIdStr,amount) = {
604+    let autostakeAddress = valueOrElse(addressFromString(tryGetString(("setup_autostake_" + assetIdStr))), Address(base58'3PDDRRS5gKyDQRpJskzWTdxREHGu1FNpdwg'))
605+    let stakerSupportedAssets = getStringValue(autostakeAddress, "setup_supportedAssets")
606+    if ((i.caller != this))
607+        then throw("only for internal smart contract invocations")
608+        else if ((indexOf(stakerSupportedAssets, assetIdStr) == unit))
609+            then nil
610+            else {
611+                let amountStaked = tryGetInteger(("autostake_amount_" + assetIdStr))
612+                let stakeInv = reentrantInvoke(autostakeAddress, "unstakeLP", [assetIdStr, amount], nil)
613+                if ((stakeInv == stakeInv))
614+                    then [IntegerEntry(("autostake_amount_" + assetIdStr), (amountStaked - amount))]
615+                    else throw("Strict value is not equal to itself.")
616+                }
617+    }
618+
619+
620+
621+@Callable(i)
622+func addInterest (assetIdStr,amount) = if ((i.caller != this))
623+    then throw("only for self invocation")
624+    else {
625+        let earned = tryGetInteger(("autostake_lastEarned_" + assetIdStr))
626+        let lastHeight = tryGetInteger(("autostake_lastBlock_" + assetIdStr))
627+        let cleanAmount = fraction(amount, 80, 100)
628+        let stakingFee = (amount - cleanAmount)
629+        let stateChanges = if (if ((lastHeight == height))
630+            then true
631+            else (amount == 0))
632+            then nil
633+            else [IntegerEntry(("autostake_preLastEarned_" + assetIdStr), earned), IntegerEntry(("autostake_preLastBlock_" + assetIdStr), lastHeight), IntegerEntry(("autostake_lastEarned_" + assetIdStr), (earned + cleanAmount)), IntegerEntry(("autostake_lastBlock_" + assetIdStr), height)]
634+        (stateChanges ++ [IntegerEntry((assetIdStr + "_sRate"), (tryGetInteger((assetIdStr + "_sRate")) + fraction(Scale16, cleanAmount, tryGetInteger(("total_supplied_" + assetIdStr))))), IntegerEntry((("fee_" + assetIdStr) + "_staking"), (tryGetInteger((("fee_" + assetIdStr) + "_staking")) + stakingFee))])
635+        }
636+
637+
638+
639+@Callable(i)
640+func addInterestEXTERNAL () = {
641+    let assetId = i.payments[0].assetId
642+    let assetIdStr = getAssetString(assetId)
643+    let splitting = getRewardsSplitting(assetIdStr)
644+    let amount = fraction(i.payments[0].amount, splitting._2, 100)
645+    let earned = tryGetInteger(("autostake_lastEarned_" + assetIdStr))
646+    let lastHeight = tryGetInteger(("autostake_lastBlock_" + assetIdStr))
647+    let stateChanges = if (if ((lastHeight == height))
648+        then true
649+        else (amount == 0))
650+        then nil
651+        else [IntegerEntry(("autostake_preLastEarned_" + assetIdStr), earned), IntegerEntry(("autostake_preLastBlock_" + assetIdStr), lastHeight), IntegerEntry(("autostake_lastEarned_" + assetIdStr), (earned + amount)), IntegerEntry(("autostake_lastBlock_" + assetIdStr), height)]
652+    (stateChanges ++ [IntegerEntry((assetIdStr + "_sRate"), (tryGetInteger((assetIdStr + "_sRate")) + fraction(Scale16, amount, tryGetInteger(("total_supplied_" + assetIdStr))))), ScriptTransfer(stableFundAddress, fraction(i.payments[0].amount, splitting._1, 100), assetId), IntegerEntry((("fee_" + assetIdStr) + "_staking"), (tryGetInteger((("fee_" + assetIdStr) + "_staking")) + fraction(i.payments[0].amount, splitting._3, 100)))])
653+    }
654+
655+
656+
657+@Callable(i)
658+func preInit (tokens,ltvs,lts,penalties) = {
659+    func f (accum,token) =     (accum ++ [IntegerEntry((token + "_bRate"), Scale16), IntegerEntry((token + "_sRate"), Scale16)])
660+
661+    if ((i.caller != this))
662+        then throw("admin only")
663+        else {
664+            let rates = {
665+                let $l = split(tokens, ",")
666+                let $s = size($l)
667+                let $acc0 = nil
668+                func $f0_1 ($a,$i) =                 if (($i >= $s))
669+                    then $a
670+                    else f($a, $l[$i])
671+
672+                func $f0_2 ($a,$i) =                 if (($i >= $s))
673+                    then $a
674+                    else throw("List size exceeds 12")
675+
676+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
677+                }
678+            ([StringEntry("setup_tokens", tokens), StringEntry("setup_ltvs", ltvs), StringEntry("setup_lts", lts), StringEntry("setup_penalties", penalties), BooleanEntry("setup_active", true)] ++ rates)
679+            }
680+    }
681+
682+
683+
684+@Callable(i)
685+func initNewToken (token,ltv,lt,penalty) = if ((i.caller != this))
686+    then throw("admin only")
687+    else [StringEntry("setup_tokens", ((tryGetString("setup_tokens") + ",") + token)), StringEntry("setup_ltvs", ((tryGetString("setup_ltvs") + ",") + ltv)), StringEntry("setup_lts", ((tryGetString("setup_lts") + ",") + lt)), StringEntry("setup_penalties", ((tryGetString("setup_penalties") + ",") + penalty)), IntegerEntry((token + "_bRate"), Scale16), IntegerEntry((token + "_sRate"), Scale16)]
688+
689+
690+
691+@Callable(i)
692+func updateParameter (key,val) = if (if ((i.caller != this))
693+    then (i.caller != adminAddress)
694+    else false)
695+    then throw("admin only")
696+    else [IntegerEntry(key, parseIntValue(val))]
697+
698+
699+
700+@Callable(i)
701+func updateString (key,val) = if (if ((i.caller != this))
702+    then (i.caller != adminAddress)
703+    else false)
704+    then throw("admin only")
705+    else [StringEntry(key, val)]
706+
707+
708+
709+@Callable(i)
710+func claimToReserveFund (debug) = {
711+    let _allowed = if ((getString(this, "setup_address_feeCollector") != unit))
712+        then throw("fee collector is configured, use claimFees()/claimFeesAll() instead")
713+        else unit
714+    if ((_allowed == _allowed))
715+        then {
716+            let assets = getMarketAssets()
717+            let rates = getActualRate(assets[0], "sRate")._2
718+            let li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
719+            func f (accum,n) =             if ((n >= size(assets)))
720+                then accum
721+                else {
722+                    let assetIdStr = assets[n]
723+                    let amount = (((getBalance(assetIdStr) + tryGetInteger(("autostake_amount_" + assetIdStr))) + fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), rates[((n * 3) + 1)].value, Scale16)) - fraction(tryGetInteger(("total_supplied_" + assetIdStr)), rates[(n * 3)].value, Scale16))
724+                    let inv = if ((tryGetString(("setup_autostake_" + assetIdStr)) != ""))
725+                        then invoke(this, "unstakeToken", [assetIdStr, amount], nil)
726+                        else unit
727+                    if ((inv == inv))
728+                        then (accum ++ [amount])
729+                        else throw("Strict value is not equal to itself.")
730+                    }
731+
732+            let parameter = {
733+                let $l = li
734+                let $s = size($l)
735+                let $acc0 = nil
736+                func $f0_1 ($a,$i) =                 if (($i >= $s))
737+                    then $a
738+                    else f($a, $l[$i])
739+
740+                func $f0_2 ($a,$i) =                 if (($i >= $s))
741+                    then $a
742+                    else throw("List size exceeds 12")
743+
744+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
745+                }
746+            func f2 (accum,n) =             if ((n >= size(assets)))
747+                then accum
748+                else {
749+                    let assetIdStr = assets[n]
750+                    (accum ++ [ScriptTransfer(reserveFundAddress, max([parameter[n], 0]), getAssetBytes(assetIdStr))])
751+                    }
752+
753+            if (debug)
754+                then throw(liIntToStr(parameter))
755+                else $Tuple2({
756+                    let $l = li
757+                    let $s = size($l)
758+                    let $acc0 = nil
759+                    func $f1_1 ($a,$i) =                     if (($i >= $s))
760+                        then $a
761+                        else f2($a, $l[$i])
762+
763+                    func $f1_2 ($a,$i) =                     if (($i >= $s))
764+                        then $a
765+                        else throw("List size exceeds 12")
766+
767+                    $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
768+                    }, parameter)
769+            }
770+        else throw("Strict value is not equal to itself.")
771+    }
772+
773+
774+
775+@Callable(i)
776+func claimFees (assetIdStr) = if ((getString(this, "setup_address_feeCollector") == unit))
777+    then throw("fee collector not configured")
778+    else if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
779+        then throw("this asset is not supported by the market")
780+        else {
781+            let isStaked = (tryGetString(("setup_autostake_" + assetIdStr)) != "")
782+            let rates = tokenRatesRecalc(assetIdStr)
783+            let sRate = rates[0].value
784+            let bRate = rates[1].value
785+            let bal = getBalance(assetIdStr)
786+            let liq = tryGetInteger((("fee_" + assetIdStr) + "_liquidation"))
787+            let stk = tryGetInteger((("fee_" + assetIdStr) + "_staking"))
788+            let interest = if (isStaked)
789+                then 0
790+                else max([((((bal + fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), bRate, Scale16)) - fraction(tryGetInteger(("total_supplied_" + assetIdStr)), sRate, Scale16)) - liq) - stk), 0])
791+            let pay = min([((interest + stk) + liq), bal])
792+            if ((0 >= pay))
793+                then nil
794+                else {
795+                    let liqP = min([liq, pay])
796+                    let stkP = min([stk, (pay - liqP)])
797+                    let interestP = ((pay - liqP) - stkP)
798+                    let recordInv = invoke(feeCollectorAddress, "processFees", [assetIdStr, interestP, stkP, liqP], [AttachedPayment(getAssetBytes(assetIdStr), pay)])
799+                    if ((recordInv == recordInv))
800+                        then [IntegerEntry((("fee_" + assetIdStr) + "_liquidation"), (liq - liqP)), IntegerEntry((("fee_" + assetIdStr) + "_staking"), (stk - stkP))]
801+                        else throw("Strict value is not equal to itself.")
802+                    }
803+            }
804+
805+
806+
807+@Callable(i)
808+func claimFeesAll (tokensList) = {
809+    let tokens = if ((tokensList == ""))
810+        then getMarketAssets()
811+        else split(tokensList, ",")
812+    func f (accum,token) =     {
813+        let inv = invoke(this, "claimFees", [token], nil)
814+        if ((inv == inv))
815+            then accum
816+            else throw("Strict value is not equal to itself.")
817+        }
818+
819+    let done = {
820+        let $l = tokens
821+        let $s = size($l)
822+        let $acc0 = unit
823+        func $f0_1 ($a,$i) =         if (($i >= $s))
824+            then $a
825+            else f($a, $l[$i])
826+
827+        func $f0_2 ($a,$i) =         if (($i >= $s))
828+            then $a
829+            else throw("List size exceeds 12")
830+
831+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
832+        }
833+    if ((done == done))
834+        then nil
835+        else throw("Strict value is not equal to itself.")
836+    }
837+
838+
839+
840+@Callable(i)
841+func reSetup (assetIdStr) = {
842+    let lastResetup = tryGetInteger("resetup_lastUpdate")
843+    if ((dayBlocks > (height - lastResetup)))
844+        then throw("can be updated only once per day")
845+        else {
846+            let lts = split(tryGetString("setup_lts"), ",")
847+            let assets = getMarketAssets()
848+            let ur = getUr(assetIdStr)
849+            let tempLT = tryGetInteger((("setup_" + assetIdStr) + "_tempLT"))
850+            let lt = parseIntValue(assets[value(indexOf(assets, assetIdStr))])
851+            if ((ur > 90000000))
852+                then [IntegerEntry((("setup_" + assetIdStr) + "_tempLT"), fraction(tempLT, 9975, 10000))]
853+                else if (if ((lt > tempLT))
854+                    then (90000000 > ur)
855+                    else false)
856+                    then [IntegerEntry((("setup_" + assetIdStr) + "_tempLT"), fraction(tempLT, 10025, 10000))]
857+                    else nil
858+            }
859+    }
860+
861+
862+
863+@Callable(i)
864+func shutdown (shutdown) = if ((indexOf(shutdownWhitelist, i.caller) == unit))
865+    then throw("user not in a whitelist")
866+    else [BooleanEntry("setup_active", !(shutdown))]
867+
868+
869+
870+@Callable(i)
871+func liquidate (debug,address,assetAmount,sAssetIdStr,bAssetIdStr,routeStr) = if (!(verifyLiquidatorRights(i.caller)))
872+    then throw("temporarily available for whitelist only")
873+    else if (!(tryGetBoolean("setup_active")))
874+        then throw("market is stopped")
875+        else {
876+            let userCollateral = calcUserCollateral(address)
877+            if ((userCollateral == userCollateral))
878+                then {
879+                    let $t03546735529 = getActualRate(sAssetIdStr, "sRate")
880+                    let sRate = $t03546735529._1
881+                    let ratesResult = $t03546735529._2
882+                    let $t03553435603 = getActualRate(bAssetIdStr, "bRate")
883+                    let bRate = $t03553435603._1
884+                    let ratesRecalcResult2 = $t03553435603._2
885+                    let sAssetAmount = fraction(assetAmount, Scale16, sRate)
886+                    let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
887+                    let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
888+                    let currentBPosition = if ((currentBPositionVal > 0))
889+                        then currentBPositionVal
890+                        else throw("user has no borrow in this token")
891+                    if ((userCollateral > 0))
892+                        then throw("user can't be liquidated")
893+                        else if ((sAssetAmount > currentSPosition))
894+                            then throw("position to liquidate is bigger than user's supply")
895+                            else {
896+                                let inv = if ((tryGetString(("setup_autostake_" + sAssetIdStr)) != ""))
897+                                    then invoke(this, "unstakeToken", [sAssetIdStr, sAssetAmount], nil)
898+                                    else unit
899+                                if ((inv == inv))
900+                                    then {
901+                                        let balance0Before = getBalance(sAssetIdStr)
902+                                        if ((balance0Before == balance0Before))
903+                                            then {
904+                                                let balance1Before = getBalance(bAssetIdStr)
905+                                                if ((balance1Before == balance1Before))
906+                                                    then {
907+                                                        let exchangeInvoke = invoke(aggregatorAddress, "swap", [routeStr, 0], [AttachedPayment(getAssetBytes(sAssetIdStr), assetAmount)])
908+                                                        if ((exchangeInvoke == exchangeInvoke))
909+                                                            then {
910+                                                                let asset0Sold = (balance0Before - getBalance(sAssetIdStr))
911+                                                                if ((asset0Sold == asset0Sold))
912+                                                                    then {
913+                                                                        let asset1Bought = (getBalance(bAssetIdStr) - balance1Before)
914+                                                                        if ((asset1Bought == asset1Bought))
915+                                                                            then {
916+                                                                                let asset0Price = getTokenPriceCapped(sAssetIdStr)._1
917+                                                                                let asset0Scale = calcAssetScale(sAssetIdStr)
918+                                                                                let asset0Usd = fraction(asset0Sold, asset0Price, asset0Scale)
919+                                                                                let asset1Price = getTokenPriceCapped(bAssetIdStr)._2
920+                                                                                let asset1Scale = calcAssetScale(bAssetIdStr)
921+                                                                                let asset1Usd = fraction(asset1Bought, asset1Price, asset1Scale)
922+                                                                                let penalty = parseIntValue(split(tryGetString("setup_penalties"), ",")[value(indexOf(getMarketAssets(), bAssetIdStr))])
923+                                                                                let liquidationProfit = (asset1Usd - fraction(asset0Usd, (Scale8 - penalty), Scale8))
924+                                                                                let sAssetChange = fraction(asset0Sold, Scale16, sRate)
925+                                                                                let bAssetChange = fraction(fraction(asset1Bought, Scale16, bRate), (Scale8 - fraction(liquidationProfit, Scale8, asset1Usd)), Scale8)
926+                                                                                if ((asset0Sold > assetAmount))
927+                                                                                    then throw("more assets exchanged than expected")
928+                                                                                    else if ((0 > liquidationProfit))
929+                                                                                        then throw("price impact is bigger than liquidation penalty")
930+                                                                                        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)), IntegerEntry((("fee_" + bAssetIdStr) + "_liquidation"), (tryGetInteger((("fee_" + bAssetIdStr) + "_liquidation")) + (asset1Bought - fraction(bAssetChange, bRate, Scale16))))]
931+                                                                                }
932+                                                                            else throw("Strict value is not equal to itself.")
933+                                                                        }
934+                                                                    else throw("Strict value is not equal to itself.")
935+                                                                }
936+                                                            else throw("Strict value is not equal to itself.")
937+                                                        }
938+                                                    else throw("Strict value is not equal to itself.")
939+                                                }
940+                                            else throw("Strict value is not equal to itself.")
941+                                        }
942+                                    else throw("Strict value is not equal to itself.")
943+                                }
944+                    }
945+                else throw("Strict value is not equal to itself.")
946+            }
947+
948+
949+
950+@Callable(i)
951+func liquidateV2 (debug,address,sAssetIdStr) = if (!(verifyLiquidatorRights(i.caller)))
952+    then throw("temporarily available for whitelist only")
953+    else if (!(tryGetBoolean("setup_active")))
954+        then throw("market is stopped")
955+        else {
956+            let bAssetId = i.payments[0].assetId
957+            let bAssetIdStr = getAssetString(bAssetId)
958+            let bAssetAmount = i.payments[0].amount
959+            let userCollateral = calcUserCollateral(address)
960+            if ((userCollateral == userCollateral))
961+                then if ((userCollateral > 0))
962+                    then throw("user can't be liquidated")
963+                    else {
964+                        let marketAssets = getMarketAssets()
965+                        let asset1Num = value(indexOf(marketAssets, bAssetIdStr))
966+                        let asset0Num = value(indexOf(marketAssets, sAssetIdStr))
967+                        let $t03922439286 = getActualRate(bAssetIdStr, "bRate")
968+                        let bRate = $t03922439286._1
969+                        let ratesResult = $t03922439286._2
970+                        let asset1Price = getTokenPriceCapped(bAssetIdStr)._2
971+                        let asset1Scale = calcAssetScale(bAssetIdStr)
972+                        let bAmountUsd = fraction(bAssetAmount, asset1Price, asset1Scale)
973+                        let penalty = parseIntValue(value(split(tryGetString("setup_penalties"), ",")[asset1Num]))
974+                        let asset0Price = getTokenPriceCapped(sAssetIdStr)._1
975+                        let asset0Scale = calcAssetScale(sAssetIdStr)
976+                        let sAmountUsd = fraction(bAmountUsd, (Scale8 + penalty), Scale8)
977+                        let sAssetAmount = fraction(sAmountUsd, asset0Scale, asset0Price)
978+                        let bAmount = fraction(bAssetAmount, Scale16, bRate)
979+                        let sAmount = fraction(sAssetAmount, Scale16, ratesResult[(asset0Num * 3)].value)
980+                        let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
981+                        let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
982+                        let currentBPosition = if ((currentBPositionVal > 0))
983+                            then currentBPositionVal
984+                            else throw("user has no borrow in this token")
985+                        if ((sAmount > currentSPosition))
986+                            then throw("position to liquidate is bigger than user's supply")
987+                            else {
988+                                let inv = if ((tryGetString(("setup_autostake_" + sAssetIdStr)) != ""))
989+                                    then invoke(this, "unstakeToken", [sAssetIdStr, sAssetAmount], nil)
990+                                    else unit
991+                                if ((inv == inv))
992+                                    then if (debug)
993+                                        then throw("liquidation will pass")
994+                                        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)
995+                                    else throw("Strict value is not equal to itself.")
996+                                }
997+                        }
998+                else throw("Strict value is not equal to itself.")
999+            }
1000+
1001+
1002+
1003+@Callable(i)
1004+func getUserCollateral (debug,address,minusBorrowed,afterChange) = {
1005+    let assets = getMarketAssets()
1006+    let ltvs = split(tryGetString("setup_ltvs"), ",")
1007+    let lts = split(tryGetString("setup_lts"), ",")
1008+    let rates = getActualRate(assets[0], "sRate")._2
1009+    let changeHandler = split(afterChange, ",")
1010+    func f (accum,next) =     if ((next >= size(assets)))
1011+        then accum
1012+        else {
1013+            let userSupplied = tryGetInteger(((address + "_supplied_") + assets[next]))
1014+            let userBorrowed = tryGetInteger(((address + "_borrowed_") + assets[next]))
1015+            let needTokenAccounting = if ((afterChange == ""))
1016+                then if (if ((userBorrowed != 0))
1017+                    then true
1018+                    else (userSupplied != 0))
1019+                    then true
1020+                    else false
1021+                else true
1022+            if (needTokenAccounting)
1023+                then {
1024+                    let assetScale = calcAssetScale(assets[next])
1025+                    let assetPrice = getTokenPriceCapped(assets[next])
1026+                    ((accum + fraction(fraction(fraction((userSupplied + (if (if (if ((afterChange != ""))
1027+                        then (changeHandler[0] == assets[next])
1028+                        else false)
1029+                        then (changeHandler[1] == "supplied")
1030+                        else false)
1031+                        then parseIntValue(changeHandler[2])
1032+                        else 0)), rates[(next * 3)].value, Scale16), parseIntValue(ltvs[next]), Scale8), assetPrice._1, assetScale)) - (if (minusBorrowed)
1033+                        then fraction(fraction(fraction((userBorrowed + (if (if (if ((afterChange != ""))
1034+                            then (changeHandler[0] == assets[next])
1035+                            else false)
1036+                            then (changeHandler[1] == "borrowed")
1037+                            else false)
1038+                            then parseIntValue(changeHandler[2])
1039+                            else 0)), rates[((next * 3) + 1)].value, Scale16), Scale8, parseIntValue(lts[next])), assetPrice._2, assetScale)
1040+                        else 0))
1041+                    }
1042+                else accum
1043+            }
1044+
1045+    let result = {
1046+        let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
1047+        let $s = size($l)
1048+        let $acc0 = 0
1049+        func $f0_1 ($a,$i) =         if (($i >= $s))
1050+            then $a
1051+            else f($a, $l[$i])
1052+
1053+        func $f0_2 ($a,$i) =         if (($i >= $s))
1054+            then $a
1055+            else throw("List size exceeds 12")
1056+
1057+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
1058+        }
1059+    if (debug)
1060+        then throw(toString(result))
1061+        else $Tuple2(rates, result)
1062+    }
1063+
1064+
1065+
1066+@Callable(i)
1067+func getPrices (debug) = {
1068+    let assets = getMarketAssets()
1069+    func f (accum,next) =     if ((next >= size(assets)))
1070+        then accum
1071+        else {
1072+            let assetPrice = getTokenPriceWithRisk(assets[next], 3)
1073+            ((((accum + toString(assetPrice._1)) + ",") + toString(assetPrice._2)) + "|")
1074+            }
1075+
1076+    let result = {
1077+        let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
1078+        let $s = size($l)
1079+        let $acc0 = ""
1080+        func $f0_1 ($a,$i) =         if (($i >= $s))
1081+            then $a
1082+            else f($a, $l[$i])
1083+
1084+        func $f0_2 ($a,$i) =         if (($i >= $s))
1085+            then $a
1086+            else throw("List size exceeds 12")
1087+
1088+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
1089+        }
1090+    if (debug)
1091+        then throw(result)
1092+        else $Tuple2(nil, result)
1093+    }
1094+
1095+
1096+
1097+@Callable(i)
1098+func calculateUtilizationRatio (assetIdStr,debug) = if (debug)
1099+    then throw(toString(getUr(assetIdStr)))
1100+    else $Tuple2(nil, getUr(assetIdStr))
1101+
1102+
1103+
1104+@Callable(i)
1105+func calculateOutdatedUR (assetIdStr,debug) = if (debug)
1106+    then throw(toString(getOutdatedUr(assetIdStr)))
1107+    else $Tuple2(nil, getOutdatedUr(assetIdStr))
1108+
1109+
1110+
1111+@Callable(i)
1112+func calculateTokenRates (debug) = {
1113+    func f (accum,assetIdStr) =     {
1114+        let rates = tokenRatesRecalc(assetIdStr)
1115+        $Tuple2(((((accum._1 + toString(rates[1].value)) + "|") + toString(rates[0].value)) + ","), (accum._2 ++ rates))
1116+        }
1117+
1118+    let parameter = {
1119+        let $l = getMarketAssets()
1120+        let $s = size($l)
1121+        let $acc0 = $Tuple2("", nil)
1122+        func $f0_1 ($a,$i) =         if (($i >= $s))
1123+            then $a
1124+            else f($a, $l[$i])
1125+
1126+        func $f0_2 ($a,$i) =         if (($i >= $s))
1127+            then $a
1128+            else throw("List size exceeds 12")
1129+
1130+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
1131+        }
1132+    if (debug)
1133+        then throw(parameter._1)
1134+        else $Tuple2(parameter._2, parameter._1)
1135+    }
1136+
1137+
1138+
1139+@Callable(i)
1140+func calculateTokensInterest (debug) = {
1141+    func f (accum,assetIdStr) =     {
1142+        let rate = fraction(getInterest(assetIdStr), dayBlocks, Scale8)
1143+        ((accum + toString(rate)) + ",")
1144+        }
1145+
1146+    let parameter = {
1147+        let $l = getMarketAssets()
1148+        let $s = size($l)
1149+        let $acc0 = ""
1150+        func $f0_1 ($a,$i) =         if (($i >= $s))
1151+            then $a
1152+            else f($a, $l[$i])
1153+
1154+        func $f0_2 ($a,$i) =         if (($i >= $s))
1155+            then $a
1156+            else throw("List size exceeds 12")
1157+
1158+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12)
1159+        }
1160+    if (debug)
1161+        then throw(parameter)
1162+        else $Tuple2(nil, parameter)
1163+    }
1164+
1165+
1166+
1167+@Callable(i)
1168+func setApproverAddress (approverAddress) = {
1169+    let isSelf = if ((i.caller == this))
1170+        then true
1171+        else throw("Only self invoke")
1172+    if ((isSelf == isSelf))
1173+        then {
1174+            let _approverAddress = addressFromString(approverAddress)
1175+            let approverOk =             match _approverAddress {
1176+                case t: Address => 
1177+                    true
1178+                case _ => 
1179+                    false
1180+            }
1181+            let canSetApprover = if (if (approverOk)
1182+                then true
1183+                else (approverAddress == ""))
1184+                then true
1185+                else throw("Wrong approver address")
1186+            if ((canSetApprover == canSetApprover))
1187+                then {
1188+                    let isInited = valueOrElse(getBoolean(value(_approverAddress), "INITED"), false)
1189+                    let hasAdmins = (valueOrElse(getString(value(_approverAddress), "ADMINS_PBKS"), "") != "")
1190+                    let isApproverContract = if (if ((approverAddress == ""))
1191+                        then true
1192+                        else if (isInited)
1193+                            then hasAdmins
1194+                            else false)
1195+                        then true
1196+                        else throw("Address is not approver contract")
1197+                    if ((isApproverContract == isApproverContract))
1198+                        then [StringEntry("APPROVER_ADDRESS", approverAddress)]
1199+                        else throw("Strict value is not equal to itself.")
1200+                    }
1201+                else throw("Strict value is not equal to itself.")
1202+            }
1203+        else throw("Strict value is not equal to itself.")
1204+    }
1205+
1206+
1207+
1208+@Callable(i)
1209+func initNewMaster (master) = {
1210+    let addressOK =     match addressFromString(master) {
1211+        case a: Address => 
1212+            true
1213+        case _ => 
1214+            false
1215+    }
1216+    if (!(addressOK))
1217+        then throw(("incorrect address " + master))
1218+        else if ((i.caller != this))
1219+            then throw("available for self call only")
1220+            else [StringEntry("verifier_master", master)]
1221+    }
1222+
1223+
1224+
1225+@Callable(i)
1226+func requestNewMaster (newMaster) = {
1227+    let addressOK =     match addressFromString(newMaster) {
1228+        case a: Address => 
1229+            true
1230+        case _ => 
1231+            false
1232+    }
1233+    if (!(addressOK))
1234+        then throw(("incorrect address " + newMaster))
1235+        else if ((indexOf(sentinels, i.caller) == unit))
1236+            then throw("whitelist only")
1237+            else [StringEntry("verifier_newMaster", newMaster), IntegerEntry("verifier_newMasterEligibleAfter", (height + 10000))]
1238+    }
1239+
1240+
1241+
1242+@Callable(i)
1243+func activateNewMaster () = {
1244+    let eligibleHeight = getIntegerValue(this, "verifier_newMasterEligibleAfter")
1245+    let newMaster = getStringValue(this, "verifier_newMaster")
1246+    if ((indexOf(sentinels, i.caller) == unit))
1247+        then throw("whitelist only")
1248+        else if ((eligibleHeight > height))
1249+            then throw("new master cannot be activated yet")
1250+            else [DeleteEntry("verifier_newMaster"), DeleteEntry("verifier_newMasterEligibleAfter"), StringEntry("verifier_master", newMaster)]
1251+    }
1252+
1253+
1254+@Verifier(tx)
1255+func verify () = {
1256+    let multisigStr = valueOrElse(getString("APPROVER_ADDRESS"), "")
1257+    let multisigAddress = addressFromString(multisigStr)
1258+    let multisigOk =     match multisigAddress {
1259+        case t: Address => 
1260+            true
1261+        case _ => 
1262+            false
1263+    }
1264+    let isInited = if (multisigOk)
1265+        then valueOrElse(getBoolean(value(multisigAddress), "INITED"), false)
1266+        else false
1267+    let hasAdmins = if (multisigOk)
1268+        then (valueOrElse(getString(value(multisigAddress), "ADMINS_PBKS"), "") != "")
1269+        else false
1270+    if (if (if (multisigOk)
1271+        then isInited
1272+        else false)
1273+        then hasAdmins
1274+        else false)
1275+        then         match tx {
1276+            case ttx: SetScriptTransaction => 
1277+                match ttx.script {
1278+                    case script: ByteVector => 
1279+                        let scriptHasha = toBase58String(blake2b256(script))
1280+                        let validFrom = valueOrErrorMessage(getInteger(value(multisigAddress), (((("script%%" + CONTRACT_TYPE) + "%%") + scriptHasha) + "%%validFrom")), "validFrom not set")
1281+                        let validTo = valueOrErrorMessage(getInteger(value(multisigAddress), (((("script%%" + CONTRACT_TYPE) + "%%") + scriptHasha) + "%%validTo")), "validTo not set")
1282+                        if ((height >= validFrom))
1283+                            then (validTo >= height)
1284+                            else false
1285+                    case _ => 
1286+                        false
1287+                }
1288+            case otx => 
1289+                let taskId = ((("tx_" + toString(this)) + "_") + toBase58String(otx.id))
1290+                let isApproved = valueOrElse(getBoolean(value(multisigAddress), (((toString(this) + "_") + toBase58String(otx.id)) + "__approved")), false)
1291+                let approvedFrom = valueOrElse(getInteger(value(multisigAddress), (taskId + "__approvedFrom")), 0)
1292+                if (isApproved)
1293+                    then (height >= approvedFrom)
1294+                    else false
1295+        }
1296+        else {
1297+            let masterAddress = getString("verifier_master")
1298+            let approvedByMaster =             match masterAddress {
1299+                case x: String => 
1300+                    match getInteger(addressFromStringValue(x), ("approvedTx_" + toBase58String(tx.id))) {
1301+                        case y: Int => 
1302+                            y
1303+                        case _ => 
1304+                            0
1305+                    }
1306+                case _ => 
1307+                    1
1308+            }
1309+            if (sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey))
1310+                then (approvedByMaster > 0)
1311+                else false
1312+            }
1313+    }
1314+
github/deemru/w8io
50.23 ms ◑