tx · EDGgwmeiUTLyMeeEGdknoejyuRPnKv9GP3qQLfWp7Eak

3N3DnVffnUyZtz2MRbk5U7giN112WempMNd:  -0.04000000 Waves

2023.08.17 13:19 [2714469] smart account 3N3DnVffnUyZtz2MRbk5U7giN112WempMNd > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EDGgwmeiUTLyMeeEGdknoejyuRPnKv9GP3qQLfWp7Eak",
    "fee": 4000000,
    "feeAssetId": null,
    "timestamp": 1692267545535,
    "version": 2,
    "chainId": 84,
    "sender": "3N3DnVffnUyZtz2MRbk5U7giN112WempMNd",
    "senderPublicKey": "3c1wAgvTRCNXCGMidVnB1j4gTYUqtwHR9tNNu2v4ZUNk",
    "proofs": [
        "2DGGCX7MNGHi4Kbmgmxfo9vyRAgob9txZpFNGVhVkbf24BR2rqgjGiaDWbUqXsKZ7nKo9KmaZcgVARCwLNHA281J"
    ],
    "script": "base64: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",
    "height": 2714469,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EE9b1Xk5Ur9XqkbzszGLoiak6ySJy9KFEy6pkgEo5Dd8
Next: none

Diff: 

OldNewDifferences
88 let flashLoanFee = 1000000
99 
1010 let axlyAddress = Address(base58'3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS')
11+
12+let axlyFarmingAddress = Address(base58'3N2M4PztorHwrfENp7D6LhYGgGodjiD1fjn')
1113 
1214 let axlyLPs = ["8DtMtpVwVq62sdcVFVzh6nuprgzG7LSjpLdHnQnrAFgY", "FLdC14nUVRyiSYjVrMo3X4g8rXQjLbNRaGAyQAm8V68V"]
1315 
248250 func supplyInternal (assetIdStr,assetAmount,address) = if (!(tryGetBoolean("setup_active")))
249251     then throw("market is stopped")
250252     else {
251-        let $t062356302 = getActualRate(assetIdStr, "sRate")
252-        let sRate = $t062356302._1
253-        let ratesRecalcResult = $t062356302._2
253+        let $t063136380 = getActualRate(assetIdStr, "sRate")
254+        let sRate = $t063136380._1
255+        let ratesRecalcResult = $t063136380._2
254256         let amount = fraction(assetAmount, Scale16, sRate, DOWN)
255257         let maxSupply =         match getString(("setup_maxSupply_" + assetIdStr)) {
256258             case x: String => 
274276 
275277 
276278 func borrowInternal (assetIdStr,assetAmount,address) = {
277-    let $t075817648 = getActualRate(assetIdStr, "bRate")
278-    let bRate = $t075817648._1
279-    let ratesRecalcResult = $t075817648._2
279+    let $t076597726 = getActualRate(assetIdStr, "bRate")
280+    let bRate = $t076597726._1
281+    let ratesRecalcResult = $t076597726._2
280282     let amount = fraction(assetAmount, Scale16, bRate, CEILING)
281283     let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",borrowed,") + toString(amount))], nil)
282284     if ((collateralValueInv == collateralValueInv))
355357     else {
356358         let assetIdStr = getAssetString(i.payments[0].assetId)
357359         let assetAmount = i.payments[0].amount
358-        supplyInternal(assetIdStr, assetAmount, toString(i.caller))
360+        let axlyNotify = invoke(axlyFarmingAddress, "lendAction", [toString(i.caller), assetIdStr], nil)
361+        if ((axlyNotify == axlyNotify))
362+            then supplyInternal(assetIdStr, assetAmount, toString(i.caller))
363+            else throw("Strict value is not equal to itself.")
359364         }
360365 
361366 
362367 
363368 @Callable(i)
364369 func withdraw (assetIdStr,assetAmount) = {
365-    let $t01119311260 = getActualRate(assetIdStr, "sRate")
366-    let sRate = $t01119311260._1
367-    let ratesRecalcResult = $t01119311260._2
370+    let $t01138411451 = getActualRate(assetIdStr, "sRate")
371+    let sRate = $t01138411451._1
372+    let ratesRecalcResult = $t01138411451._2
368373     let amount = fraction(assetAmount, Scale16, sRate, CEILING)
369374     let address = toString(i.caller)
370375     let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
371376     let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
372377     let userAssetSupplied = tryGetInteger(((address + "_supplied_") + assetIdStr))
373378     let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
374-    let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",supplied,") + toString(-(amount)))], nil)
375-    if ((collateralValueInv == collateralValueInv))
379+    let axlyNotify = invoke(axlyFarmingAddress, "lendAction", [toString(i.caller), assetIdStr], nil)
380+    if ((axlyNotify == axlyNotify))
376381         then {
377-            let collateralValue =             match collateralValueInv {
378-                case x: Int => 
379-                    x
380-                case _ => 
381-                    throw("can't get user collateral value")
382-            }
383-            if (!(tryGetBoolean("setup_active")))
384-                then throw("market is stopped")
385-                else if ((0 > collateralValue))
386-                    then throw("you dont have enough collateral for this operation")
387-                    else if ((amount > (assetSupplied - assetBorrowed)))
388-                        then throw("this amount is not available on the market")
389-                        else if ((amount > (userAssetSupplied - userAssetBorrowed)))
390-                            then throw("this amount is not available for this user")
391-                            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)
382+            let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",supplied,") + toString(-(amount)))], nil)
383+            if ((collateralValueInv == collateralValueInv))
384+                then {
385+                    let collateralValue =                     match collateralValueInv {
386+                        case x: Int => 
387+                            x
388+                        case _ => 
389+                            throw("can't get user collateral value")
390+                    }
391+                    if (!(tryGetBoolean("setup_active")))
392+                        then throw("market is stopped")
393+                        else if ((0 > collateralValue))
394+                            then throw("you dont have enough collateral for this operation")
395+                            else if ((amount > (assetSupplied - assetBorrowed)))
396+                                then throw("this amount is not available on the market")
397+                                else if ((amount > (userAssetSupplied - userAssetBorrowed)))
398+                                    then throw("this amount is not available for this user")
399+                                    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)
400+                    }
401+                else throw("Strict value is not equal to itself.")
392402             }
393403         else throw("Strict value is not equal to itself.")
394404     }
415425         else {
416426             let assetIdStr = getAssetString(i.payments[0].assetId)
417427             let assetAmount = i.payments[0].amount
418-            let $t01332713394 = getActualRate(assetIdStr, "bRate")
419-            let bRate = $t01332713394._1
420-            let ratesRecalcResult = $t01332713394._2
428+            let $t01362313690 = getActualRate(assetIdStr, "bRate")
429+            let bRate = $t01362313690._1
430+            let ratesRecalcResult = $t01362313690._2
421431             let amount = fraction(assetAmount, Scale16, bRate, CEILING)
422432             let address = toString(i.caller)
423433             let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
446456         else {
447457             let assetIdStr = getAssetString(i.payments[0].assetId)
448458             let assetAmount = i.payments[0].amount
449-            let $t01481214879 = getActualRate(assetIdStr, "bRate")
450-            let bRate = $t01481214879._1
451-            let ratesRecalcResult = $t01481214879._2
459+            let $t01510815175 = getActualRate(assetIdStr, "bRate")
460+            let bRate = $t01510815175._1
461+            let ratesRecalcResult = $t01510815175._2
452462             let amount = fraction(assetAmount, Scale16, bRate, CEILING)
453463             let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
454464             let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
796806             let userCollateral = calcUserCollateral(address)
797807             if ((userCollateral == userCollateral))
798808                 then {
799-                    let $t02845128513 = getActualRate(sAssetIdStr, "sRate")
800-                    let sRate = $t02845128513._1
801-                    let ratesResult = $t02845128513._2
802-                    let $t02851828587 = getActualRate(bAssetIdStr, "bRate")
803-                    let bRate = $t02851828587._1
804-                    let ratesRecalcResult2 = $t02851828587._2
809+                    let $t02874728809 = getActualRate(sAssetIdStr, "sRate")
810+                    let sRate = $t02874728809._1
811+                    let ratesResult = $t02874728809._2
812+                    let $t02881428883 = getActualRate(bAssetIdStr, "bRate")
813+                    let bRate = $t02881428883._1
814+                    let ratesRecalcResult2 = $t02881428883._2
805815                     let sAssetAmount = fraction(assetAmount, Scale16, sRate)
806816                     let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
807817                     let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
877887                         let marketAssets = getMarketAssets()
878888                         let asset1Num = value(indexOf(marketAssets, bAssetIdStr))
879889                         let asset0Num = value(indexOf(marketAssets, sAssetIdStr))
880-                        let $t03174231804 = getActualRate(bAssetIdStr, "bRate")
881-                        let bRate = $t03174231804._1
882-                        let ratesResult = $t03174231804._2
890+                        let $t03203832100 = getActualRate(bAssetIdStr, "bRate")
891+                        let bRate = $t03203832100._1
892+                        let ratesResult = $t03203832100._2
883893                         let asset1Price = getTokenPrice(bAssetIdStr)._2
884894                         let asset1Scale = calcAssetScale(bAssetIdStr)
885895                         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 axlyAddress = Address(base58'3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS')
11+
12+let axlyFarmingAddress = Address(base58'3N2M4PztorHwrfENp7D6LhYGgGodjiD1fjn')
1113 
1214 let axlyLPs = ["8DtMtpVwVq62sdcVFVzh6nuprgzG7LSjpLdHnQnrAFgY", "FLdC14nUVRyiSYjVrMo3X4g8rXQjLbNRaGAyQAm8V68V"]
1315 
1416 let aggregatorAddress = Address(base58'3Mzzt65puEs2W9M1m9iFBvMEdfM5bASE1hJ')
1517 
1618 let oracleStr = "3N4KbMnJH8FaM94jqxNFe2oyZ8GB7Z8yVBP"
1719 
1820 let shutdownWhitelist = [base58'3Mzzt65puEs2W9M1m9iFBvMEdfM5bASE1hJ']
1921 
2022 func verifyLiquidatorRights (address) = !((address != Address(base58'3Mzzt65puEs2W9M1m9iFBvMEdfM5bASE1hJ')))
2123 
2224 
2325 func getRateCurve (assetIdStr) = match assetIdStr {
2426     case _ => 
2527         if (("8DtMtpVwVq62sdcVFVzh6nuprgzG7LSjpLdHnQnrAFgY" == $match0))
2628             then $Tuple4(2000000, 25000000, 80000000, 100000000)
2729             else if (("FLdC14nUVRyiSYjVrMo3X4g8rXQjLbNRaGAyQAm8V68V" == $match0))
2830                 then $Tuple4(2000000, 25000000, 80000000, 100000000)
2931                 else if (("25FEqEjRkqK6yCkiT7Lz6SAYz7gUFCtxfCChnrVFD5AT" == $match0))
3032                     then $Tuple4(2000000, 25000000, 80000000, 100000000)
3133                     else if (("WAVES" == $match0))
3234                         then $Tuple4(2000000, 30000000, 80000000, 50000000)
3335                         else $Tuple4(0, 20000000, 80000000, 80000000)
3436 }
3537 
3638 
3739 let Scale8 = 100000000
3840 
3941 let Scale10 = 10000000000
4042 
4143 let Scale16 = (Scale8 * Scale8)
4244 
4345 let dayBlocks = 1440
4446 
4547 func liIntToStr (li) = {
4648     func f (accum,next) =     ((accum + toString(next)) + ",")
4749 
4850     let $l = li
4951     let $s = size($l)
5052     let $acc0 = ""
5153     func $f0_1 ($a,$i) =     if (($i >= $s))
5254         then $a
5355         else f($a, $l[$i])
5456 
5557     func $f0_2 ($a,$i) =     if (($i >= $s))
5658         then $a
5759         else throw("List size exceeds 8")
5860 
5961     $f0_2($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)
6062     }
6163 
6264 
6365 func tryGetInteger (key) = match getInteger(this, key) {
6466     case b: Int => 
6567         b
6668     case _ => 
6769         0
6870 }
6971 
7072 
7173 func tryGetBoolean (key) = match getBoolean(this, key) {
7274     case b: Boolean => 
7375         b
7476     case _ => 
7577         false
7678 }
7779 
7880 
7981 func tryGetString (key) = match getString(this, key) {
8082     case b: String => 
8183         b
8284     case _ => 
8385         ""
8486 }
8587 
8688 
8789 func tryGetBinary (key) = match getBinary(this, key) {
8890     case b: ByteVector => 
8991         b
9092     case _ => 
9193         base58''
9294 }
9395 
9496 
9597 func getAssetString (assetId) = match assetId {
9698     case b: ByteVector => 
9799         toBase58String(b)
98100     case _ => 
99101         "WAVES"
100102 }
101103 
102104 
103105 func getAssetBytes (assetIdStr) = if ((assetIdStr == "WAVES"))
104106     then unit
105107     else fromBase58String(assetIdStr)
106108 
107109 
108110 func getBalance (assetIdStr) = if ((assetIdStr == "WAVES"))
109111     then wavesBalance(this).available
110112     else assetBalance(this, fromBase58String(assetIdStr))
111113 
112114 
113115 func getMarketAssets () = split(tryGetString("setup_tokens"), ",")
114116 
115117 
116118 func getAssetsMaxSupply () = {
117119     let s = tryGetString("setup_maxsupply")
118120     if ((s == ""))
119121         then [-1, -1, -1, -1, -1, -1, -1]
120122         else split(s, ",")
121123     }
122124 
123125 
124126 func getOutdatedUr (assetIdStr) = {
125127     let down = fraction(tryGetInteger(("total_supplied_" + assetIdStr)), tryGetInteger((assetIdStr + "_sRate")), Scale16)
126128     if ((down == 0))
127129         then 0
128130         else fraction(Scale8, fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), tryGetInteger((assetIdStr + "_bRate")), Scale16), down)
129131     }
130132 
131133 
132134 func getInterest (assetIdStr) = {
133135     let ur = getOutdatedUr(assetIdStr)
134136     let curve = getRateCurve(assetIdStr)
135137     let rate = (curve._1 + (if ((curve._3 >= ur))
136138         then fraction(ur, curve._2, curve._3)
137139         else (curve._2 + fraction((ur - curve._3), curve._4, (100000000 - curve._3)))))
138140     max([fraction(rate, Scale8, (dayBlocks * 365)), 1])
139141     }
140142 
141143 
142144 func tokenRatesRecalc (assetIdStr) = {
143145     let interest = getInterest(assetIdStr)
144146     let ur = getOutdatedUr(assetIdStr)
145147     let lastRecalcHeight = tryGetInteger("lastRateHeight")
146148     let lastBRate = max([tryGetInteger((assetIdStr + "_bRate")), Scale16])
147149     let newBRate = (lastBRate + ((height - lastRecalcHeight) * interest))
148150     let lastSRate = max([tryGetInteger((assetIdStr + "_sRate")), Scale16])
149151     let newSRate = (lastSRate + ((((height - lastRecalcHeight) * fraction(interest, ur, Scale8)) * (100 - reserveFund)) / 100))
150152 [IntegerEntry((assetIdStr + "_sRate"), newSRate), IntegerEntry((assetIdStr + "_bRate"), newBRate), IntegerEntry("lastRateHeight", height)]
151153     }
152154 
153155 
154156 func getActualRate (assetIdStr,rateType) = {
155157     func f (accum,token) =     {
156158         let recalc = tokenRatesRecalc(token)
157159         $Tuple2(if ((token != assetIdStr))
158160             then accum._1
159161             else if ((rateType == "sRate"))
160162                 then recalc[0].value
161163                 else recalc[1].value, (accum._2 ++ recalc))
162164         }
163165 
164166     let $l = getMarketAssets()
165167     let $s = size($l)
166168     let $acc0 = $Tuple2(0, nil)
167169     func $f0_1 ($a,$i) =     if (($i >= $s))
168170         then $a
169171         else f($a, $l[$i])
170172 
171173     func $f0_2 ($a,$i) =     if (($i >= $s))
172174         then $a
173175         else throw("List size exceeds 8")
174176 
175177     $f0_2($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)
176178     }
177179 
178180 
179181 func getUr (assetIdStr) = {
180182     let rates = tokenRatesRecalc(assetIdStr)
181183     let down = fraction(tryGetInteger(("total_supplied_" + assetIdStr)), rates[0].value, Scale16)
182184     fraction(Scale8, fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), rates[1].value, Scale16), down)
183185     }
184186 
185187 
186188 func ratesRecalc () = {
187189     func f (accum,token) =     (accum ++ tokenRatesRecalc(token))
188190 
189191     let $l = getMarketAssets()
190192     let $s = size($l)
191193     let $acc0 = nil
192194     func $f0_1 ($a,$i) =     if (($i >= $s))
193195         then $a
194196         else f($a, $l[$i])
195197 
196198     func $f0_2 ($a,$i) =     if (($i >= $s))
197199         then $a
198200         else throw("List size exceeds 8")
199201 
200202     $f0_2($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)
201203     }
202204 
203205 
204206 func getTokenPrice (assetIdStr) = {
205207     let inv3 = invoke(addressFromStringValue(oracleStr), "getTWAP60", [assetIdStr, false], nil)
206208     if ((inv3 == inv3))
207209         then {
208210             let data3 =             match inv3 {
209211                 case x: (Int, Int) => 
210212                     x
211213                 case _ => 
212214                     throw("error of price oracle")
213215             }
214216             if ((data3 == data3))
215217                 then data3
216218                 else throw("Strict value is not equal to itself.")
217219             }
218220         else throw("Strict value is not equal to itself.")
219221     }
220222 
221223 
222224 func calcAssetScale (assetIdStr) = {
223225     let decimals = if ((assetIdStr == "WAVES"))
224226         then 8
225227         else value(assetInfo(fromBase58String(assetIdStr))).decimals
226228     pow(10, 0, decimals, 0, 0, DOWN)
227229     }
228230 
229231 
230232 func calcUserCollateral (address) = {
231233     let userCollateralInvoke = invoke(this, "getUserCollateral", [false, address, true, ""], nil)
232234     if ((userCollateralInvoke == userCollateralInvoke))
233235         then {
234236             let userCollateralValue =             match userCollateralInvoke {
235237                 case x: Int => 
236238                     x
237239                 case _ => 
238240                     throw("issue while doing in-dapp invocation")
239241             }
240242             if ((userCollateralValue == userCollateralValue))
241243                 then userCollateralValue
242244                 else throw("Strict value is not equal to itself.")
243245             }
244246         else throw("Strict value is not equal to itself.")
245247     }
246248 
247249 
248250 func supplyInternal (assetIdStr,assetAmount,address) = if (!(tryGetBoolean("setup_active")))
249251     then throw("market is stopped")
250252     else {
251-        let $t062356302 = getActualRate(assetIdStr, "sRate")
252-        let sRate = $t062356302._1
253-        let ratesRecalcResult = $t062356302._2
253+        let $t063136380 = getActualRate(assetIdStr, "sRate")
254+        let sRate = $t063136380._1
255+        let ratesRecalcResult = $t063136380._2
254256         let amount = fraction(assetAmount, Scale16, sRate, DOWN)
255257         let maxSupply =         match getString(("setup_maxSupply_" + assetIdStr)) {
256258             case x: String => 
257259                 parseIntValue(x)
258260             case _ => 
259261                 0
260262         }
261263         let assetPrice = getTokenPrice(assetIdStr)
262264         let newTotalSupplied = (tryGetInteger(((address + "_supplied_") + assetIdStr)) + amount)
263265         let rate = getActualRate(assetIdStr, "sRate")._1
264266         let assetScale = calcAssetScale(assetIdStr)
265267         let newTotalSuppliedUsd = fraction(fraction(newTotalSupplied, rate, Scale16), assetPrice._1, assetScale)
266268         if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
267269             then throw("this asset is not supported by the market")
268270             else if (if ((maxSupply != 0))
269271                 then (newTotalSuppliedUsd > maxSupply)
270272                 else false)
271273                 then throw("max total supply for this token reached in the pool")
272274                 else $Tuple2(([IntegerEntry(((address + "_supplied_") + assetIdStr), newTotalSupplied), IntegerEntry(("total_supplied_" + assetIdStr), (tryGetInteger(("total_supplied_" + assetIdStr)) + amount))] ++ ratesRecalcResult), assetAmount)
273275         }
274276 
275277 
276278 func borrowInternal (assetIdStr,assetAmount,address) = {
277-    let $t075817648 = getActualRate(assetIdStr, "bRate")
278-    let bRate = $t075817648._1
279-    let ratesRecalcResult = $t075817648._2
279+    let $t076597726 = getActualRate(assetIdStr, "bRate")
280+    let bRate = $t076597726._1
281+    let ratesRecalcResult = $t076597726._2
280282     let amount = fraction(assetAmount, Scale16, bRate, CEILING)
281283     let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",borrowed,") + toString(amount))], nil)
282284     if ((collateralValueInv == collateralValueInv))
283285         then {
284286             let collateralValue =             match collateralValueInv {
285287                 case x: Int => 
286288                     x
287289                 case _ => 
288290                     throw("can't get user collateral value")
289291             }
290292             if (!(tryGetBoolean("setup_active")))
291293                 then throw("market is stopped")
292294                 else {
293295                     let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
294296                     let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
295297                     let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
296298                     if ((amount > (assetSupplied - assetBorrowed)))
297299                         then throw("this amount is not available")
298300                         else $Tuple2(([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed + amount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed + amount))] ++ ratesRecalcResult), assetAmount)
299301                     }
300302             }
301303         else throw("Strict value is not equal to itself.")
302304     }
303305 
304306 
305307 @Callable(i)
306308 func flashPosition (user,sAssetIdStr,bAssetIdStr,bAmount,callbackAddress,callbackFunction,callbackArgs) = {
307309     let borrowRes = borrowInternal(bAssetIdStr, bAmount, user)
308310     let bAssetId = getAssetBytes(bAssetIdStr)
309311     let callback = reentrantInvoke(addressFromStringValue(callbackAddress), callbackFunction, split(callbackArgs, ","), [AttachedPayment(bAssetId, bAmount)])
310312     if ((callback == callback))
311313         then {
312314             let sAmount = {
313315                 let @ = callback
314316                 if ($isInstanceOf(@, "Int"))
315317                     then @
316318                     else throw(($getType(@) + " couldn't be cast to Int"))
317319                 }
318320             if ((sAmount == sAmount))
319321                 then {
320322                     let supplyRes = supplyInternal(sAssetIdStr, sAmount, user)
321323                     let collateralValue = {
322324                         let @ = invoke(this, "getUserCollateral", [false, user, true, ((sAssetIdStr + ",supplied,") + toString(sAmount))], nil)
323325                         if ($isInstanceOf(@, "Int"))
324326                             then @
325327                             else throw(($getType(@) + " couldn't be cast to Int"))
326328                         }
327329                     if ((collateralValue == collateralValue))
328330                         then {
329331                             let borrowValue = {
330332                                 let @ = invoke(this, "getUserCollateral", [false, user, true, ((bAssetIdStr + ",borrowed,") + toString(bAmount))], nil)
331333                                 if ($isInstanceOf(@, "Int"))
332334                                     then @
333335                                     else throw(($getType(@) + " couldn't be cast to Int"))
334336                                 }
335337                             if ((borrowValue == borrowValue))
336338                                 then if ((borrowValue > collateralValue))
337339                                     then throw("not enough collateral provided")
338340                                     else (borrowRes._1 ++ supplyRes._1)
339341                                 else throw("Strict value is not equal to itself.")
340342                             }
341343                         else throw("Strict value is not equal to itself.")
342344                     }
343345                 else throw("Strict value is not equal to itself.")
344346             }
345347         else throw("Strict value is not equal to itself.")
346348     }
347349 
348350 
349351 
350352 @Callable(i)
351353 func supply () = if (if ((size(i.payments) != 1))
352354     then true
353355     else (i.payments[0].amount == 0))
354356     then throw("1 payment has to be attached")
355357     else {
356358         let assetIdStr = getAssetString(i.payments[0].assetId)
357359         let assetAmount = i.payments[0].amount
358-        supplyInternal(assetIdStr, assetAmount, toString(i.caller))
360+        let axlyNotify = invoke(axlyFarmingAddress, "lendAction", [toString(i.caller), assetIdStr], nil)
361+        if ((axlyNotify == axlyNotify))
362+            then supplyInternal(assetIdStr, assetAmount, toString(i.caller))
363+            else throw("Strict value is not equal to itself.")
359364         }
360365 
361366 
362367 
363368 @Callable(i)
364369 func withdraw (assetIdStr,assetAmount) = {
365-    let $t01119311260 = getActualRate(assetIdStr, "sRate")
366-    let sRate = $t01119311260._1
367-    let ratesRecalcResult = $t01119311260._2
370+    let $t01138411451 = getActualRate(assetIdStr, "sRate")
371+    let sRate = $t01138411451._1
372+    let ratesRecalcResult = $t01138411451._2
368373     let amount = fraction(assetAmount, Scale16, sRate, CEILING)
369374     let address = toString(i.caller)
370375     let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
371376     let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
372377     let userAssetSupplied = tryGetInteger(((address + "_supplied_") + assetIdStr))
373378     let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
374-    let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",supplied,") + toString(-(amount)))], nil)
375-    if ((collateralValueInv == collateralValueInv))
379+    let axlyNotify = invoke(axlyFarmingAddress, "lendAction", [toString(i.caller), assetIdStr], nil)
380+    if ((axlyNotify == axlyNotify))
376381         then {
377-            let collateralValue =             match collateralValueInv {
378-                case x: Int => 
379-                    x
380-                case _ => 
381-                    throw("can't get user collateral value")
382-            }
383-            if (!(tryGetBoolean("setup_active")))
384-                then throw("market is stopped")
385-                else if ((0 > collateralValue))
386-                    then throw("you dont have enough collateral for this operation")
387-                    else if ((amount > (assetSupplied - assetBorrowed)))
388-                        then throw("this amount is not available on the market")
389-                        else if ((amount > (userAssetSupplied - userAssetBorrowed)))
390-                            then throw("this amount is not available for this user")
391-                            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)
382+            let collateralValueInv = invoke(this, "getUserCollateral", [false, address, true, ((assetIdStr + ",supplied,") + toString(-(amount)))], nil)
383+            if ((collateralValueInv == collateralValueInv))
384+                then {
385+                    let collateralValue =                     match collateralValueInv {
386+                        case x: Int => 
387+                            x
388+                        case _ => 
389+                            throw("can't get user collateral value")
390+                    }
391+                    if (!(tryGetBoolean("setup_active")))
392+                        then throw("market is stopped")
393+                        else if ((0 > collateralValue))
394+                            then throw("you dont have enough collateral for this operation")
395+                            else if ((amount > (assetSupplied - assetBorrowed)))
396+                                then throw("this amount is not available on the market")
397+                                else if ((amount > (userAssetSupplied - userAssetBorrowed)))
398+                                    then throw("this amount is not available for this user")
399+                                    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)
400+                    }
401+                else throw("Strict value is not equal to itself.")
392402             }
393403         else throw("Strict value is not equal to itself.")
394404     }
395405 
396406 
397407 
398408 @Callable(i)
399409 func borrow (assetIdStr,assetAmount) = {
400410     let address = toString(i.caller)
401411     let res = borrowInternal(assetIdStr, assetAmount, address)
402412     let amount = res._2
403413     (res._1 ++ [ScriptTransfer(i.caller, amount, getAssetBytes(assetIdStr))])
404414     }
405415 
406416 
407417 
408418 @Callable(i)
409419 func repay () = if (!(tryGetBoolean("setup_active")))
410420     then throw("market is stopped")
411421     else if (if ((size(i.payments) != 1))
412422         then true
413423         else (i.payments[0].amount == 0))
414424         then throw("1 payment has to be attached")
415425         else {
416426             let assetIdStr = getAssetString(i.payments[0].assetId)
417427             let assetAmount = i.payments[0].amount
418-            let $t01332713394 = getActualRate(assetIdStr, "bRate")
419-            let bRate = $t01332713394._1
420-            let ratesRecalcResult = $t01332713394._2
428+            let $t01362313690 = getActualRate(assetIdStr, "bRate")
429+            let bRate = $t01362313690._1
430+            let ratesRecalcResult = $t01362313690._2
421431             let amount = fraction(assetAmount, Scale16, bRate, CEILING)
422432             let address = toString(i.caller)
423433             let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
424434             let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
425435             let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
426436             let amountLeft = (userAssetBorrowed - amount)
427437             let repayAmount = if ((amountLeft >= 0))
428438                 then amount
429439                 else userAssetBorrowed
430440             if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
431441                 then throw("this asset is not supported by the market")
432442                 else (([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed - repayAmount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed - repayAmount))] ++ ratesRecalcResult) ++ (if ((amountLeft >= 0))
433443                     then nil
434444                     else [ScriptTransfer(i.caller, -(amountLeft), i.payments[0].assetId)]))
435445             }
436446 
437447 
438448 
439449 @Callable(i)
440450 func repayFor (address) = if (!(tryGetBoolean("setup_active")))
441451     then throw("market is stopped")
442452     else if (if ((size(i.payments) != 1))
443453         then true
444454         else (i.payments[0].amount == 0))
445455         then throw("1 payment has to be attached")
446456         else {
447457             let assetIdStr = getAssetString(i.payments[0].assetId)
448458             let assetAmount = i.payments[0].amount
449-            let $t01481214879 = getActualRate(assetIdStr, "bRate")
450-            let bRate = $t01481214879._1
451-            let ratesRecalcResult = $t01481214879._2
459+            let $t01510815175 = getActualRate(assetIdStr, "bRate")
460+            let bRate = $t01510815175._1
461+            let ratesRecalcResult = $t01510815175._2
452462             let amount = fraction(assetAmount, Scale16, bRate, CEILING)
453463             let assetSupplied = tryGetInteger(("total_supplied_" + assetIdStr))
454464             let assetBorrowed = tryGetInteger(("total_borrowed_" + assetIdStr))
455465             let userAssetBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
456466             let amountLeft = (userAssetBorrowed - amount)
457467             let repayAmount = if ((amountLeft >= 0))
458468                 then amount
459469                 else userAssetBorrowed
460470             if ((indexOf(tryGetString("setup_tokens"), assetIdStr) == unit))
461471                 then throw("this asset is not supported by the market")
462472                 else (([IntegerEntry(((address + "_borrowed_") + assetIdStr), (userAssetBorrowed - repayAmount)), IntegerEntry(("total_borrowed_" + assetIdStr), (assetBorrowed - repayAmount))] ++ ratesRecalcResult) ++ (if ((amountLeft >= 0))
463473                     then nil
464474                     else [ScriptTransfer(i.caller, -(amountLeft), i.payments[0].assetId)]))
465475             }
466476 
467477 
468478 
469479 @Callable(i)
470480 func stakeTokenAll (assetIdStr) = if ((i.caller != this))
471481     then throw("only for internal smart contract invocations")
472482     else {
473483         let amount = getBalance(assetIdStr)
474484         let inv = invoke(this, "stakeToken", [assetIdStr, amount], nil)
475485         if ((inv == inv))
476486             then nil
477487             else throw("Strict value is not equal to itself.")
478488         }
479489 
480490 
481491 
482492 @Callable(i)
483493 func stakeToken (assetIdStr,amount) = if ((i.caller != this))
484494     then throw("only for internal smart contract invocations")
485495     else if ((assetIdStr == "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"))
486496         then {
487497             let amountStaked = tryGetInteger("autostake_amount_DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
488498             let inv = invoke(Address(base58'3PNikM6yp4NqcSU8guxQtmR5onr2D4e8yTJ'), "stake", nil, [AttachedPayment(base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p', amount)])
489499             if ((inv == inv))
490500                 then [IntegerEntry("autostake_amount_DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p", (amountStaked + amount))]
491501                 else throw("Strict value is not equal to itself.")
492502             }
493503         else if ((assetIdStr == "8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91"))
494504             then {
495505                 let amountStaked = tryGetInteger("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91")
496506                 let inv = invoke(Address(base58'3PQTM38wDmAY9vWonK6ha7QL3PAycLz5oPP'), "stake", nil, [AttachedPayment(base58'8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91', amount)])
497507                 if ((inv == inv))
498508                     then [IntegerEntry("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91", (amountStaked + amount))]
499509                     else throw("Strict value is not equal to itself.")
500510                 }
501511             else if ((assetIdStr == "At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL"))
502512                 then {
503513                     let amountStaked = tryGetInteger("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL")
504514                     let inv = invoke(Address(base58'3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C'), "stake", nil, [AttachedPayment(base58'At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL', amount)])
505515                     if ((inv == inv))
506516                         then [IntegerEntry("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", (amountStaked + amount))]
507517                         else throw("Strict value is not equal to itself.")
508518                     }
509519                 else nil
510520 
511521 
512522 
513523 @Callable(i)
514524 func unstakeToken (assetIdStr,amount) = if ((i.caller != this))
515525     then throw("only for internal smart contract invocations")
516526     else if ((assetIdStr == "8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91"))
517527         then {
518528             let amountStaked = tryGetInteger("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91")
519529             let inv = invoke(Address(base58'3PQTM38wDmAY9vWonK6ha7QL3PAycLz5oPP'), "unStake", [amount], nil)
520530             if ((inv == inv))
521531                 then [IntegerEntry("autostake_amount_8t4DPWTwPzpatHA9AkTxWAB47THnYzBsDnoY7fQqbG91", (amountStaked - amount))]
522532                 else throw("Strict value is not equal to itself.")
523533             }
524534         else if ((assetIdStr == "At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL"))
525535             then {
526536                 let amountStaked = tryGetInteger("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL")
527537                 let inv = invoke(Address(base58'3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C'), "unstake", [amount], nil)
528538                 if ((inv == inv))
529539                     then {
530540                         let bal0 = getBalance("At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL")
531541                         if ((bal0 == bal0))
532542                             then {
533543                                 let inv2 = invoke(Address(base58'3PQrVbTVpqXHqpVKftkNdjy3zZAh4dsRzN6'), "gnsbtRewardsSYSREADONLY", [toString(this)], nil)
534544                                 if ((inv2 == inv2))
535545                                     then {
536546                                         let topupRewards =                                         match inv2 {
537547                                             case x: List[Any] => 
538548                                                 let secondEl = x[1]
539549                                                 match secondEl {
540550                                                     case secondEl: String => 
541551                                                         let usdnValue = parseIntValue(split(split(secondEl, "_")[1], ":")[1])
542552                                                         let wavesValue = parseIntValue(split(split(secondEl, "_")[0], ":")[1])
543553                                                         if (if ((usdnValue != 0))
544554                                                             then true
545555                                                             else (wavesValue != 0))
546556                                                             then {
547557                                                                 let usdnBal0 = getBalance("DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
548558                                                                 if ((usdnBal0 == usdnBal0))
549559                                                                     then {
550560                                                                         let wavesBal0 = getBalance("WAVES")
551561                                                                         if ((wavesBal0 == wavesBal0))
552562                                                                             then {
553563                                                                                 let inv3 = invoke(Address(base58'3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C'), "claimRewards", nil, nil)
554564                                                                                 if ((inv3 == inv3))
555565                                                                                     then {
556566                                                                                         let wavesBal1 = getBalance("WAVES")
557567                                                                                         if ((wavesBal1 == wavesBal1))
558568                                                                                             then {
559569                                                                                                 let inv4 = invoke(Address(base58'3PLiXyywNThdvf3vVEUxwc7TJTucjZvuegh'), "swap", ["DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p", 0], [AttachedPayment(unit, (wavesBal1 - wavesBal0))])
560570                                                                                                 if ((inv4 == inv4))
561571                                                                                                     then {
562572                                                                                                         let usdnBal1 = getBalance("DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p")
563573                                                                                                         if ((usdnBal1 == usdnBal1))
564574                                                                                                             then {
565575                                                                                                                 let inv5 = invoke(Address(base58'3P7r93vXHuusageNJVGwzqaz3WMotAu49Yz'), "swap", ["At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", 0], [AttachedPayment(base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p', (usdnBal1 - usdnBal0))])
566576                                                                                                                 if ((inv5 == inv5))
567577                                                                                                                     then {
568578                                                                                                                         let inv6 = invoke(this, "addInterest", ["At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", (getBalance("At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL") - bal0)], nil)
569579                                                                                                                         if ((inv6 == inv6))
570580                                                                                                                             then 2
571581                                                                                                                             else throw("Strict value is not equal to itself.")
572582                                                                                                                         }
573583                                                                                                                     else throw("Strict value is not equal to itself.")
574584                                                                                                                 }
575585                                                                                                             else throw("Strict value is not equal to itself.")
576586                                                                                                         }
577587                                                                                                     else throw("Strict value is not equal to itself.")
578588                                                                                                 }
579589                                                                                             else throw("Strict value is not equal to itself.")
580590                                                                                         }
581591                                                                                     else throw("Strict value is not equal to itself.")
582592                                                                                 }
583593                                                                             else throw("Strict value is not equal to itself.")
584594                                                                         }
585595                                                                     else throw("Strict value is not equal to itself.")
586596                                                                 }
587597                                                             else 1
588598                                                     case _ => 
589599                                                         1
590600                                                 }
591601                                             case _ => 
592602                                                 0
593603                                         }
594604                                         if ((topupRewards == topupRewards))
595605                                             then [IntegerEntry("autostake_amount_At8D6NFFpheCbvKVnjVoeLL84Eo8NZn6ovManxfLaFWL", (amountStaked - amount))]
596606                                             else throw("Strict value is not equal to itself.")
597607                                         }
598608                                     else throw("Strict value is not equal to itself.")
599609                                 }
600610                             else throw("Strict value is not equal to itself.")
601611                         }
602612                     else throw("Strict value is not equal to itself.")
603613                 }
604614             else nil
605615 
606616 
607617 
608618 @Callable(i)
609619 func addInterest (assetIdStr,amount) = if ((i.caller != this))
610620     then throw("only for self invocation")
611621     else {
612622         let earned = tryGetInteger(("autostake_lastEarned_" + assetIdStr))
613623         let lastHeight = tryGetInteger(("autostake_lastBlock_" + assetIdStr))
614624         let cleanAmount = fraction(amount, 80, 100)
615625         let stateChanges = if (if ((lastHeight == height))
616626             then true
617627             else (amount == 0))
618628             then nil
619629             else [IntegerEntry(("autostake_preLastEarned_" + assetIdStr), earned), IntegerEntry(("autostake_preLastBlock_" + assetIdStr), lastHeight), IntegerEntry(("autostake_lastEarned_" + assetIdStr), (earned + cleanAmount)), IntegerEntry(("autostake_lastBlock_" + assetIdStr), height)]
620630         (stateChanges ++ [IntegerEntry((assetIdStr + "_sRate"), (tryGetInteger((assetIdStr + "_sRate")) + fraction(Scale16, cleanAmount, tryGetInteger(("total_supplied_" + assetIdStr)))))])
621631         }
622632 
623633 
624634 
625635 @Callable(i)
626636 func addInterestEXTERNAL () = {
627637     let amount = fraction(i.payments[0].amount, 80, 100)
628638     let assetId = i.payments[0].assetId
629639     let assetIdStr = getAssetString(assetId)
630640     let earned = tryGetInteger(("autostake_lastEarned_" + assetIdStr))
631641     let lastHeight = tryGetInteger(("autostake_lastBlock_" + assetIdStr))
632642     let stateChanges = if (if ((lastHeight == height))
633643         then true
634644         else (amount == 0))
635645         then nil
636646         else [IntegerEntry(("autostake_preLastEarned_" + assetIdStr), earned), IntegerEntry(("autostake_preLastBlock_" + assetIdStr), lastHeight), IntegerEntry(("autostake_lastEarned_" + assetIdStr), (earned + amount)), IntegerEntry(("autostake_lastBlock_" + assetIdStr), height)]
637647     (stateChanges ++ [IntegerEntry((assetIdStr + "_sRate"), (tryGetInteger((assetIdStr + "_sRate")) + fraction(Scale16, amount, tryGetInteger(("total_supplied_" + assetIdStr)))))])
638648     }
639649 
640650 
641651 
642652 @Callable(i)
643653 func preInit (tokens,ltvs,lts,penalties) = {
644654     func f (accum,token) =     (accum ++ [IntegerEntry((token + "_bRate"), Scale16), IntegerEntry((token + "_sRate"), Scale16)])
645655 
646656     if ((i.caller != this))
647657         then throw("admin only")
648658         else {
649659             let rates = {
650660                 let $l = split(tokens, ",")
651661                 let $s = size($l)
652662                 let $acc0 = nil
653663                 func $f0_1 ($a,$i) =                 if (($i >= $s))
654664                     then $a
655665                     else f($a, $l[$i])
656666 
657667                 func $f0_2 ($a,$i) =                 if (($i >= $s))
658668                     then $a
659669                     else throw("List size exceeds 8")
660670 
661671                 $f0_2($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)
662672                 }
663673             ([StringEntry("setup_tokens", tokens), StringEntry("setup_ltvs", ltvs), StringEntry("setup_lts", lts), StringEntry("setup_penalties", penalties), BooleanEntry("setup_active", true)] ++ rates)
664674             }
665675     }
666676 
667677 
668678 
669679 @Callable(i)
670680 func initNewToken (token,ltv,lt,penalty) = if ((i.caller != this))
671681     then throw("admin only")
672682     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)]
673683 
674684 
675685 
676686 @Callable(i)
677687 func updateParameter (key,val) = if (if (if ((i.caller != this))
678688     then (i.caller != Address(base58'3P3o9cLTV2u9N4nYNKRYL6gy6cUEU9DwXW8'))
679689     else false)
680690     then (i.caller != Address(base58'3N8ZpuFLVKwxbpVFe1Pcs14hLCrujizpQsa'))
681691     else false)
682692     then throw("admin only")
683693     else [IntegerEntry(key, parseIntValue(val))]
684694 
685695 
686696 
687697 @Callable(i)
688698 func updateString (key,val) = if (if (if ((i.caller != this))
689699     then (i.caller != Address(base58'3P3o9cLTV2u9N4nYNKRYL6gy6cUEU9DwXW8'))
690700     else false)
691701     then (i.caller != Address(base58'3N8ZpuFLVKwxbpVFe1Pcs14hLCrujizpQsa'))
692702     else false)
693703     then throw("admin only")
694704     else [StringEntry(key, val)]
695705 
696706 
697707 
698708 @Callable(i)
699709 func claimToReserveFund (debug) = {
700710     let assets = getMarketAssets()
701711     let rates = getActualRate(assets[0], "sRate")._2
702712     let li = [0, 1, 2, 3, 4, 5]
703713     func f (accum,n) =     if ((n >= size(assets)))
704714         then accum
705715         else {
706716             let assetIdStr = assets[n]
707717             let autostakeAmount = tryGetString(("autostake_amount_" + assetIdStr))
708718             let amount = ((((getBalance(assetIdStr) + tryGetInteger(("autostake_amount_" + assetIdStr))) + (if ((autostakeAmount != ""))
709719                 then parseIntValue(autostakeAmount)
710720                 else 0)) + fraction(tryGetInteger(("total_borrowed_" + assetIdStr)), rates[((n * 3) + 1)].value, Scale16)) - fraction(tryGetInteger(("total_supplied_" + assetIdStr)), rates[(n * 3)].value, Scale16))
711721             let inv = if ((tryGetInteger(("autostake_amount_" + assetIdStr)) > 0))
712722                 then invoke(this, "unstakeToken", [assetIdStr, max([amount, 0])], nil)
713723                 else 0
714724             if ((inv == inv))
715725                 then (accum ++ [amount])
716726                 else throw("Strict value is not equal to itself.")
717727             }
718728 
719729     let parameter = {
720730         let $l = li
721731         let $s = size($l)
722732         let $acc0 = nil
723733         func $f0_1 ($a,$i) =         if (($i >= $s))
724734             then $a
725735             else f($a, $l[$i])
726736 
727737         func $f0_2 ($a,$i) =         if (($i >= $s))
728738             then $a
729739             else throw("List size exceeds 8")
730740 
731741         $f0_2($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)
732742         }
733743     func f2 (accum,n) =     if ((n >= size(assets)))
734744         then accum
735745         else {
736746             let assetIdStr = assets[n]
737747             (accum ++ [ScriptTransfer(reserveFundAddress, max([parameter[n], 0]), getAssetBytes(assetIdStr))])
738748             }
739749 
740750     if (debug)
741751         then throw(liIntToStr(parameter))
742752         else $Tuple2({
743753             let $l = li
744754             let $s = size($l)
745755             let $acc0 = nil
746756             func $f1_1 ($a,$i) =             if (($i >= $s))
747757                 then $a
748758                 else f2($a, $l[$i])
749759 
750760             func $f1_2 ($a,$i) =             if (($i >= $s))
751761                 then $a
752762                 else throw("List size exceeds 8")
753763 
754764             $f1_2($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)
755765             }, parameter)
756766     }
757767 
758768 
759769 
760770 @Callable(i)
761771 func reSetup (assetIdStr) = {
762772     let lastResetup = tryGetInteger("resetup_lastUpdate")
763773     if ((dayBlocks > (height - lastResetup)))
764774         then throw("can be updated only once per day")
765775         else {
766776             let lts = split(tryGetString("setup_lts"), ",")
767777             let assets = getMarketAssets()
768778             let ur = getUr(assetIdStr)
769779             let tempLT = tryGetInteger((("setup_" + assetIdStr) + "_tempLT"))
770780             let lt = parseIntValue(assets[value(indexOf(assets, assetIdStr))])
771781             if ((ur > 90000000))
772782                 then [IntegerEntry((("setup_" + assetIdStr) + "_tempLT"), fraction(tempLT, 9975, 10000))]
773783                 else if (if ((lt > tempLT))
774784                     then (90000000 > ur)
775785                     else false)
776786                     then [IntegerEntry((("setup_" + assetIdStr) + "_tempLT"), fraction(tempLT, 10025, 10000))]
777787                     else nil
778788             }
779789     }
780790 
781791 
782792 
783793 @Callable(i)
784794 func shutdown (shutdown) = if ((indexOf(shutdownWhitelist, i.caller.bytes) == unit))
785795     then throw("user not in a whitelist")
786796     else [BooleanEntry("setup_active", !(shutdown))]
787797 
788798 
789799 
790800 @Callable(i)
791801 func liquidate (debug,address,assetAmount,sAssetIdStr,bAssetIdStr,routeStr) = if (!(verifyLiquidatorRights(i.caller)))
792802     then throw("temporarily available for whitelist only")
793803     else if (!(tryGetBoolean("setup_active")))
794804         then throw("market is stopped")
795805         else {
796806             let userCollateral = calcUserCollateral(address)
797807             if ((userCollateral == userCollateral))
798808                 then {
799-                    let $t02845128513 = getActualRate(sAssetIdStr, "sRate")
800-                    let sRate = $t02845128513._1
801-                    let ratesResult = $t02845128513._2
802-                    let $t02851828587 = getActualRate(bAssetIdStr, "bRate")
803-                    let bRate = $t02851828587._1
804-                    let ratesRecalcResult2 = $t02851828587._2
809+                    let $t02874728809 = getActualRate(sAssetIdStr, "sRate")
810+                    let sRate = $t02874728809._1
811+                    let ratesResult = $t02874728809._2
812+                    let $t02881428883 = getActualRate(bAssetIdStr, "bRate")
813+                    let bRate = $t02881428883._1
814+                    let ratesRecalcResult2 = $t02881428883._2
805815                     let sAssetAmount = fraction(assetAmount, Scale16, sRate)
806816                     let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
807817                     let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
808818                     let currentBPosition = if ((currentBPositionVal > 0))
809819                         then currentBPositionVal
810820                         else throw("user has no borrow in this token")
811821                     if ((userCollateral > 0))
812822                         then throw("user can't be liquidated")
813823                         else if ((sAssetAmount > currentSPosition))
814824                             then throw("position to liquidate is bigger than user's supply")
815825                             else {
816826                                 let balance0Before = getBalance(sAssetIdStr)
817827                                 if ((balance0Before == balance0Before))
818828                                     then {
819829                                         let balance1Before = getBalance(bAssetIdStr)
820830                                         if ((balance1Before == balance1Before))
821831                                             then {
822832                                                 let exchangeInvoke = invoke(aggregatorAddress, "swap", [routeStr, 0], [AttachedPayment(getAssetBytes(sAssetIdStr), assetAmount)])
823833                                                 if ((exchangeInvoke == exchangeInvoke))
824834                                                     then {
825835                                                         let asset0Sold = (balance0Before - getBalance(sAssetIdStr))
826836                                                         if ((asset0Sold == asset0Sold))
827837                                                             then {
828838                                                                 let asset1Bought = (getBalance(bAssetIdStr) - balance1Before)
829839                                                                 if ((asset1Bought == asset1Bought))
830840                                                                     then {
831841                                                                         let asset0Price = getTokenPrice(sAssetIdStr)._1
832842                                                                         let asset0Scale = calcAssetScale(sAssetIdStr)
833843                                                                         let asset0Usd = fraction(asset0Sold, asset0Price, asset0Scale)
834844                                                                         let asset1Price = getTokenPrice(bAssetIdStr)._2
835845                                                                         let asset1Scale = calcAssetScale(bAssetIdStr)
836846                                                                         let asset1Usd = fraction(asset1Bought, asset1Price, asset1Scale)
837847                                                                         let penalty = parseIntValue(split(tryGetString("setup_penalties"), ",")[value(indexOf(getMarketAssets(), bAssetIdStr))])
838848                                                                         let liquidationProfit = (asset1Usd - fraction(asset0Usd, (Scale8 - penalty), Scale8))
839849                                                                         let sAssetChange = fraction(asset0Sold, Scale16, sRate)
840850                                                                         let bAssetChange = fraction(fraction(asset1Bought, Scale16, bRate), (Scale8 - fraction(liquidationProfit, Scale8, asset1Usd)), Scale8)
841851                                                                         if ((asset0Sold > assetAmount))
842852                                                                             then throw("more assets exchanged than expected")
843853                                                                             else if ((0 > liquidationProfit))
844854                                                                                 then throw("price impact is bigger than liquidation penalty")
845855                                                                                 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))]
846856                                                                         }
847857                                                                     else throw("Strict value is not equal to itself.")
848858                                                                 }
849859                                                             else throw("Strict value is not equal to itself.")
850860                                                         }
851861                                                     else throw("Strict value is not equal to itself.")
852862                                                 }
853863                                             else throw("Strict value is not equal to itself.")
854864                                         }
855865                                     else throw("Strict value is not equal to itself.")
856866                                 }
857867                     }
858868                 else throw("Strict value is not equal to itself.")
859869             }
860870 
861871 
862872 
863873 @Callable(i)
864874 func liquidateV2 (debug,address,sAssetIdStr) = if (!(verifyLiquidatorRights(i.caller)))
865875     then throw("temporarily available for whitelist only")
866876     else if (!(tryGetBoolean("setup_active")))
867877         then throw("market is stopped")
868878         else {
869879             let bAssetId = i.payments[0].assetId
870880             let bAssetIdStr = getAssetString(bAssetId)
871881             let bAssetAmount = i.payments[0].amount
872882             let userCollateral = calcUserCollateral(address)
873883             if ((userCollateral == userCollateral))
874884                 then if ((userCollateral > 0))
875885                     then throw("user can't be liquidated")
876886                     else {
877887                         let marketAssets = getMarketAssets()
878888                         let asset1Num = value(indexOf(marketAssets, bAssetIdStr))
879889                         let asset0Num = value(indexOf(marketAssets, sAssetIdStr))
880-                        let $t03174231804 = getActualRate(bAssetIdStr, "bRate")
881-                        let bRate = $t03174231804._1
882-                        let ratesResult = $t03174231804._2
890+                        let $t03203832100 = getActualRate(bAssetIdStr, "bRate")
891+                        let bRate = $t03203832100._1
892+                        let ratesResult = $t03203832100._2
883893                         let asset1Price = getTokenPrice(bAssetIdStr)._2
884894                         let asset1Scale = calcAssetScale(bAssetIdStr)
885895                         let bAmountUsd = fraction(bAssetAmount, asset1Price, asset1Scale)
886896                         let penalty = parseIntValue(value(split(tryGetString("setup_penalties"), ",")[asset1Num]))
887897                         let asset0Price = getTokenPrice(sAssetIdStr)._1
888898                         let asset0Scale = calcAssetScale(sAssetIdStr)
889899                         let sAmountUsd = fraction(bAmountUsd, (Scale8 + penalty), Scale8)
890900                         let sAssetAmount = fraction(sAmountUsd, asset0Scale, asset0Price)
891901                         let bAmount = fraction(bAssetAmount, Scale16, bRate)
892902                         let sAmount = fraction(sAssetAmount, Scale16, ratesResult[((asset0Num * 3) + 1)].value)
893903                         let inv = if ((indexOf(axlyLPs, sAssetIdStr) != unit))
894904                             then {
895905                                 let posId = split(address, "_")[1]
896906                                 let addressId = split(address, "_")[0]
897907                                 reentrantInvoke(axlyAddress, "liquidate", [addressId, posId, sAmount], nil)
898908                                 }
899909                             else nil
900910                         if ((inv == inv))
901911                             then {
902912                                 let currentSPosition = tryGetInteger(((address + "_supplied_") + sAssetIdStr))
903913                                 let currentBPositionVal = tryGetInteger(((address + "_borrowed_") + bAssetIdStr))
904914                                 let currentBPosition = if ((currentBPositionVal > 0))
905915                                     then currentBPositionVal
906916                                     else throw("user has no borrow in this token")
907917                                 if ((sAmount > currentSPosition))
908918                                     then throw("position to liquidate is bigger than user's supply")
909919                                     else if (debug)
910920                                         then throw("liquidation will pass")
911921                                         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)
912922                                 }
913923                             else throw("Strict value is not equal to itself.")
914924                         }
915925                 else throw("Strict value is not equal to itself.")
916926             }
917927 
918928 
919929 
920930 @Callable(i)
921931 func getUserCollateral (debug,address,minusBorrowed,afterChange) = {
922932     let assets = getMarketAssets()
923933     let ltvs = split(tryGetString("setup_ltvs"), ",")
924934     let lts = split(tryGetString("setup_lts"), ",")
925935     let rates = getActualRate(assets[0], "sRate")._2
926936     let changeHandler = split(afterChange, ",")
927937     func f (accum,next) =     if ((next >= size(assets)))
928938         then accum
929939         else {
930940             let userSupplied = tryGetInteger(((address + "_supplied_") + assets[next]))
931941             let userBorrowed = tryGetInteger(((address + "_borrowed_") + assets[next]))
932942             let needTokenAccounting = if ((afterChange == ""))
933943                 then if (if ((userBorrowed != 0))
934944                     then true
935945                     else (userSupplied != 0))
936946                     then true
937947                     else false
938948                 else true
939949             if (needTokenAccounting)
940950                 then {
941951                     let assetScale = calcAssetScale(assets[next])
942952                     let assetPrice = getTokenPrice(assets[next])
943953                     ((accum + fraction(fraction(fraction((userSupplied + (if (if (if ((afterChange != ""))
944954                         then (changeHandler[0] == assets[next])
945955                         else false)
946956                         then (changeHandler[1] == "supplied")
947957                         else false)
948958                         then parseIntValue(changeHandler[2])
949959                         else 0)), rates[(next * 3)].value, Scale16), parseIntValue(ltvs[next]), Scale8), assetPrice._1, assetScale)) - (if (minusBorrowed)
950960                         then fraction(fraction(fraction((userBorrowed + (if (if (if ((afterChange != ""))
951961                             then (changeHandler[0] == assets[next])
952962                             else false)
953963                             then (changeHandler[1] == "borrowed")
954964                             else false)
955965                             then parseIntValue(changeHandler[2])
956966                             else 0)), rates[((next * 3) + 1)].value, Scale16), Scale8, parseIntValue(lts[next])), assetPrice._2, assetScale)
957967                         else 0))
958968                     }
959969                 else accum
960970             }
961971 
962972     let result = {
963973         let $l = [0, 1, 2, 3, 4, 5]
964974         let $s = size($l)
965975         let $acc0 = 0
966976         func $f0_1 ($a,$i) =         if (($i >= $s))
967977             then $a
968978             else f($a, $l[$i])
969979 
970980         func $f0_2 ($a,$i) =         if (($i >= $s))
971981             then $a
972982             else throw("List size exceeds 8")
973983 
974984         $f0_2($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)
975985         }
976986     if (debug)
977987         then throw(toString(result))
978988         else $Tuple2(nil, result)
979989     }
980990 
981991 
982992 
983993 @Callable(i)
984994 func getAssetDebt (debug,address,assetIdStr) = {
985995     let userBorrowed = tryGetInteger(((address + "_borrowed_") + assetIdStr))
986996     let assetScale = calcAssetScale(assetIdStr)
987997     let rate = getActualRate(assetIdStr, "bRate")._1
988998     let result = fraction(userBorrowed, rate, Scale16)
989999     if (debug)
9901000         then throw(toString(result))
9911001         else $Tuple2(nil, result)
9921002     }
9931003 
9941004 
9951005 
9961006 @Callable(i)
9971007 func getPrices (debug) = {
9981008     let assets = getMarketAssets()
9991009     func f (accum,next) =     if ((next >= size(assets)))
10001010         then accum
10011011         else {
10021012             let assetPrice = getTokenPrice(assets[next])
10031013             ((((accum + toString(assetPrice._1)) + ",") + toString(assetPrice._2)) + "|")
10041014             }
10051015 
10061016     let result = {
10071017         let $l = [0, 1, 2, 3, 4, 5]
10081018         let $s = size($l)
10091019         let $acc0 = ""
10101020         func $f0_1 ($a,$i) =         if (($i >= $s))
10111021             then $a
10121022             else f($a, $l[$i])
10131023 
10141024         func $f0_2 ($a,$i) =         if (($i >= $s))
10151025             then $a
10161026             else throw("List size exceeds 8")
10171027 
10181028         $f0_2($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)
10191029         }
10201030     if (debug)
10211031         then throw(result)
10221032         else $Tuple2(nil, result)
10231033     }
10241034 
10251035 
10261036 
10271037 @Callable(i)
10281038 func calculateUtilizationRatio (assetIdStr,debug) = if (debug)
10291039     then throw(toString(getUr(assetIdStr)))
10301040     else $Tuple2(nil, getUr(assetIdStr))
10311041 
10321042 
10331043 
10341044 @Callable(i)
10351045 func calculateOutdatedUR (assetIdStr,debug) = if (debug)
10361046     then throw(toString(getOutdatedUr(assetIdStr)))
10371047     else $Tuple2(nil, getOutdatedUr(assetIdStr))
10381048 
10391049 
10401050 
10411051 @Callable(i)
10421052 func calculateTokenRates (debug) = {
10431053     func f (accum,assetIdStr) =     {
10441054         let rates = tokenRatesRecalc(assetIdStr)
10451055         $Tuple2(((((accum._1 + toString(rates[1].value)) + "|") + toString(rates[0].value)) + ","), (accum._2 ++ rates))
10461056         }
10471057 
10481058     let parameter = {
10491059         let $l = getMarketAssets()
10501060         let $s = size($l)
10511061         let $acc0 = $Tuple2("", nil)
10521062         func $f0_1 ($a,$i) =         if (($i >= $s))
10531063             then $a
10541064             else f($a, $l[$i])
10551065 
10561066         func $f0_2 ($a,$i) =         if (($i >= $s))
10571067             then $a
10581068             else throw("List size exceeds 8")
10591069 
10601070         $f0_2($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)
10611071         }
10621072     if (debug)
10631073         then throw(parameter._1)
10641074         else $Tuple2(parameter._2, parameter._1)
10651075     }
10661076 
10671077 
10681078 
10691079 @Callable(i)
10701080 func calculateTokensInterest (debug) = {
10711081     func f (accum,assetIdStr) =     {
10721082         let rate = fraction(getInterest(assetIdStr), dayBlocks, Scale8)
10731083         ((accum + toString(rate)) + ",")
10741084         }
10751085 
10761086     let parameter = {
10771087         let $l = getMarketAssets()
10781088         let $s = size($l)
10791089         let $acc0 = ""
10801090         func $f0_1 ($a,$i) =         if (($i >= $s))
10811091             then $a
10821092             else f($a, $l[$i])
10831093 
10841094         func $f0_2 ($a,$i) =         if (($i >= $s))
10851095             then $a
10861096             else throw("List size exceeds 8")
10871097 
10881098         $f0_2($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)
10891099         }
10901100     if (debug)
10911101         then throw(parameter)
10921102         else $Tuple2(nil, parameter)
10931103     }
10941104 
10951105 
10961106 @Verifier(tx)
10971107 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
10981108 
github/deemru/w8io/873ac7e 
130.77 ms ◑