tx · 8X97kHimyGWmQUUpVMA2rTA6h8D7Uh2WVuL6UgUHiwjm

3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk:  -0.03100000 Waves

2023.02.27 13:06 [3533443] smart account 3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8X97kHimyGWmQUUpVMA2rTA6h8D7Uh2WVuL6UgUHiwjm",
    "fee": 3100000,
    "feeAssetId": null,
    "timestamp": 1677492404050,
    "version": 2,
    "chainId": 87,
    "sender": "3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk",
    "senderPublicKey": "8bMNZV1S5S2hfim2ZPy5hsSdC1AHBwPHUEXPBhdEF2Mk",
    "proofs": [
        "Rn3HeVjvQwHkNybSciR2eCRb9ArAZQLKTZ7uff1ncvpCiMUPHZKHRzFDjD59ZVwEnaQraXjT8M5qYwMzExM95uQ"
    ],
    "script": "base64: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",
    "height": 3533443,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: G3YdFR5MsKPiHYpbS5Y7ywUEQ4X3nAhBsmK6Ay5oG8wK
Next: CNQkebmjNyy9ytjaBPF9sY3F8o2h6J3Uc3wykuWYnVWh

Diff: 

OldNewDifferences
8787 
8888 let keyLtcUsdnCompound = "LTC_USDN_Compound"
8989 
90+let keySWAVES_WAVES = "sWAVES_WAVES"
91+
92+let keySWAVES_WAVES_Compound = "sWAVES_WAVES_Compound"
93+
9094 let def = 100000000
9195 
9296 let feePerc = 10000000000
139143                     else throw("Key does not exist")
140144 
141145 
146+func convertToString (id) = match id {
147+    case id: ByteVector => 
148+        toBase58String(id)
149+    case _ => 
150+        throw("decoding function error")
151+}
152+
153+
142154 @Callable(i)
143155 func deposit2 () = if ((i.caller != Address(oracle)))
144156     then throw("callable for oracle only")
180192         let pmtAmount = value(i.payments[0]).amount
181193         let lpIdUstake = encodeId(tciId)
182194         let dataKey = getKeyStaked(tciId)
183-        let tciIssued =         match assetInfo(getTciId(tciId)) {
195+        let asString = convertToString(tciId)
196+        let tciIssued =         match assetInfo(fromBase58String(asString)) {
184197             case asset: Asset => 
185198                 asset.quantity
186199             case _ => 
187-                throw("Can't find asset")
200+                throw("Can't pull tci issued")
188201         }
189202         let lpStaked = valueOrElse(getInteger(this, dataKey), 0)
190203         let tciPrice = fraction(lpStaked, multi8, tciIssued)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let multi8 = 100000000
55 
66 let multi10 = 10000000000
77 
88 let usdtUsdnLP = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
99 
1010 let usdtUsdnLPTCI = base58'2CD44HANZzsdU7yqRsmz7L9eA2Foh4YYMC4azMbaZEj6'
1111 
1212 let wxUsdnLP = base58'F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9'
1313 
1414 let wxUsdnLPTCI = base58'FuUobp3DcfARzDLcvtVW37i7FvMPvCCpgdcvWke8sBuh'
1515 
1616 let usdcUsdnLP = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
1717 
1818 let usdcUsdnLPTCI = base58'HZKFpNfyPG5gt4D6Nfy1zQSg2Ptmqv932GjNTCyBEeKP'
1919 
2020 let usdcUsdtLP = base58'EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH'
2121 
2222 let usdcUsdtLPTCI = base58'BqPYkaiz7Le6fFu1rjZ54anrpT57EpvyugZCUqrsjXj'
2323 
2424 let puzzleUsdnLP = base58'E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP'
2525 
2626 let puzzleUsdnLPTCI = base58'Dh9QXSSABE5V6aRfu3mCbDAUokbpE7ER7pbZV6cvyg1A'
2727 
2828 let nsbtUsdnLP = base58'AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5'
2929 
3030 let nsbtUsdnLPTCI = base58'3hty6p21a9M4t9greh13nydX84bvaPyXDhKZ2FSmLNRg'
3131 
3232 let btcUsdnLP = base58'8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy'
3333 
3434 let btcUsdnLPTCI = base58'FpRckcTCzfsfXwWhQCrL5rcrStRB6HxmRjP28qVFz4iu'
3535 
3636 let ennoUsdnLP = base58'HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX'
3737 
3838 let ennoUsdnLPTCI = base58'57kEMQuVpmhsG9eCkcGRA3hTsZZGa6axKJfNwXEU4EM1'
3939 
4040 let wavesUsdnLP = base58'7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1'
4141 
4242 let wavesUsdnLPTCI = base58'EHia7oPmBSJyTd3Uix8sdpEvFXB9X18ioqreXiTaKyVJ'
4343 
4444 let ltcUsdnLP = base58'CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv'
4545 
4646 let ltcUsdnLPTCI = base58'HgD36mcgHVF5beAQi6rPtatg4gVmMckvPExFR3jEDydW'
4747 
4848 let isStopped = false
4949 
5050 let keyStaked = "STAKED_LP"
5151 
5252 let keyCompound = "From_Compound"
5353 
5454 let keywxUsdnCompound = "WX_USDN_compound"
5555 
5656 let keyWXUSDN = "WX_USDN"
5757 
5858 let keyUsdcUsdnCompound = "USDC_USDN_compound"
5959 
6060 let keyUSDCUSDN = "USDC_USDN"
6161 
6262 let keyUsdcUsdtCompound = "USDC_USDT_compound"
6363 
6464 let keyUSDCUSDT = "USDC_USDT"
6565 
6666 let keyPuzzleUsdnCompound = "PUZZLE_USDN_compound"
6767 
6868 let keyPUZZLEUSDN = "PUZZLE_USDN"
6969 
7070 let keyNsbtUsdnCompound = "NSBT_USDN_compound"
7171 
7272 let keyNSBTUSDN = "NSBT_USDN"
7373 
7474 let keyBTCUSDN = "BTC_USDN"
7575 
7676 let keyBtcUsdnCompound = "BTC_USDN_Compound"
7777 
7878 let keyENNOUSDN = "ENNO_USDN"
7979 
8080 let keyEnnoUsdnCompound = "ENNO_USDN_Compound"
8181 
8282 let keyWAVESUSDN = "WAVES_USDN"
8383 
8484 let keyWavesUsdnCompound = "WAVES_USDN_Compound"
8585 
8686 let keyLTCUSDN = "LTC_USDN"
8787 
8888 let keyLtcUsdnCompound = "LTC_USDN_Compound"
8989 
90+let keySWAVES_WAVES = "sWAVES_WAVES"
91+
92+let keySWAVES_WAVES_Compound = "sWAVES_WAVES_Compound"
93+
9094 let def = 100000000
9195 
9296 let feePerc = 10000000000
9397 
9498 let tw = base58'3P93R2GBkTGVehRPhytHr7sdxYww93jkbhm'
9599 
96100 let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
97101 
98102 func checkAddress (caller) = if ((caller != oracle))
99103     then false
100104     else true
101105 
102106 
103107 func getTciId (id) = if ((id == usdcUsdnLP))
104108     then usdcUsdnLPTCI
105109     else if ((id == wxUsdnLP))
106110         then wxUsdnLPTCI
107111         else if ((id == usdcUsdnLP))
108112             then usdcUsdnLPTCI
109113             else if ((id == usdcUsdtLP))
110114                 then usdcUsdtLPTCI
111115                 else if ((id == puzzleUsdnLP))
112116                     then puzzleUsdnLPTCI
113117                     else throw("invalid asset")
114118 
115119 
116120 func getKeyStaked (tciId) = if ((tciId == usdtUsdnLPTCI))
117121     then keyStaked
118122     else if ((tciId == wxUsdnLPTCI))
119123         then keyWXUSDN
120124         else if ((tciId == usdcUsdnLPTCI))
121125             then keyUSDCUSDN
122126             else if ((tciId == usdcUsdtLPTCI))
123127                 then keyUSDCUSDT
124128                 else if ((tciId == puzzleUsdnLPTCI))
125129                     then keyPUZZLEUSDN
126130                     else throw("Key does not exist")
127131 
128132 
129133 func encodeId (tciId) = if ((tciId == usdtUsdnLPTCI))
130134     then toBase58String(usdtUsdnLP)
131135     else if ((tciId == wxUsdnLPTCI))
132136         then toBase58String(wxUsdnLP)
133137         else if ((tciId == usdcUsdnLPTCI))
134138             then toBase58String(usdcUsdnLP)
135139             else if ((tciId == usdcUsdtLPTCI))
136140                 then toBase58String(usdcUsdtLP)
137141                 else if ((tciId == puzzleUsdnLPTCI))
138142                     then toBase58String(puzzleUsdnLP)
139143                     else throw("Key does not exist")
140144 
141145 
146+func convertToString (id) = match id {
147+    case id: ByteVector => 
148+        toBase58String(id)
149+    case _ => 
150+        throw("decoding function error")
151+}
152+
153+
142154 @Callable(i)
143155 func deposit2 () = if ((i.caller != Address(oracle)))
144156     then throw("callable for oracle only")
145157     else {
146158         let assetId = i.payments[0].assetId
147159         let pmtAmount = value(i.payments[0]).amount
148160         let tciId = getTciId(assetId)
149161         let key = getKeyStaked(tciId)
150162         let stakedTokens = valueOrElse(getInteger(this, key), 0)
151163         let tciIssued =         match assetInfo(tciId) {
152164             case asset: Asset => 
153165                 asset.quantity
154166             case _ => 
155167                 throw("Can't find asset")
156168         }
157169         let fee = fraction(pmtAmount, multi8, multi10)
158170         let userDepositBalance = (pmtAmount - fee)
159171         let forOneTci = fraction(tciIssued, multi8, stakedTokens)
160172         let amountToIssue = fraction(userDepositBalance, forOneTci, multi8)
161173         let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [AttachedPayment(assetId, userDepositBalance)])
162174         if ((LPstake == LPstake))
163175             then {
164176                 let updateState = IntegerEntry(key, (stakedTokens + userDepositBalance))
165177                 let issueTCI = Reissue(tciId, amountToIssue, true)
166178                 let transferTCI = ScriptTransfer(i.caller, amountToIssue, tciId)
167179                 let collectFee = ScriptTransfer(Address(tw), fee, assetId)
168180 [updateState, issueTCI, transferTCI, collectFee]
169181                 }
170182             else throw("Strict value is not equal to itself.")
171183         }
172184 
173185 
174186 
175187 @Callable(i)
176188 func withdraw2 () = if ((i.caller != Address(oracle)))
177189     then throw("callable for oracle only")
178190     else {
179191         let tciId = i.payments[0].assetId
180192         let pmtAmount = value(i.payments[0]).amount
181193         let lpIdUstake = encodeId(tciId)
182194         let dataKey = getKeyStaked(tciId)
183-        let tciIssued =         match assetInfo(getTciId(tciId)) {
195+        let asString = convertToString(tciId)
196+        let tciIssued =         match assetInfo(fromBase58String(asString)) {
184197             case asset: Asset => 
185198                 asset.quantity
186199             case _ => 
187-                throw("Can't find asset")
200+                throw("Can't pull tci issued")
188201         }
189202         let lpStaked = valueOrElse(getInteger(this, dataKey), 0)
190203         let tciPrice = fraction(lpStaked, multi8, tciIssued)
191204         let fee = fraction(pmtAmount, multi8, multi10)
192205         let userWithdrawAmount = (pmtAmount - fee)
193206         let lpToUnstake = (userWithdrawAmount * tciPrice)
194207         let unstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", [lpIdUstake, lpToUnstake], nil)
195208         if ((unstake == unstake))
196209             then {
197210                 let burnTci = Burn(getTciId(tciId), userWithdrawAmount)
198211                 let transferFee = ScriptTransfer(Address(tw), fee, tciId)
199212                 let transferUserLP = ScriptTransfer(i.caller, lpToUnstake, fromBase58String(lpIdUstake))
200213                 let updateState = IntegerEntry(dataKey, (lpStaked - lpToUnstake))
201214 [burnTci, transferFee, transferUserLP, updateState]
202215                 }
203216             else throw("Strict value is not equal to itself.")
204217         }
205218 
206219 
207220 
208221 @Callable(i)
209222 func depositWxUsdnLP () = {
210223     let pmt = value(i.payments[0])
211224     let pmtAmount = pmt.amount
212225     if ((pmt.assetId != wxUsdnLP))
213226         then throw("attach WXUSDNLP tokens only")
214227         else if (isStopped)
215228             then throw("smart contract is on lock")
216229             else {
217230                 let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
218231                 let totalIssued =                 match assetInfo(wxUsdnLPTCI) {
219232                     case asset: Asset => 
220233                         asset.quantity
221234                     case _ => 
222235                         throw("Can't find asset")
223236                 }
224237                 let one = fraction(totalIssued, 100000000, tkStaked)
225238                 let toIssue = fraction(pmtAmount, one, 100000000)
226239                 let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
227240                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
228241                 if ((LPstake == LPstake))
229242                     then {
230243                         let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
231244                         let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
232245 [LPIssue, transfer, updateState]
233246                         }
234247                     else throw("Strict value is not equal to itself.")
235248                 }
236249     }
237250 
238251 
239252 
240253 @Callable(i)
241254 func depositUsdtUsdnLP () = {
242255     let pmt = value(i.payments[0])
243256     let pmtAmount = pmt.amount
244257     if ((pmt.assetId != usdtUsdnLP))
245258         then throw("attach USDTUSDNLP tokens only")
246259         else if (isStopped)
247260             then throw("smart contract is on lock")
248261             else {
249262                 let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
250263                 let totalIssued =                 match assetInfo(usdtUsdnLPTCI) {
251264                     case asset: Asset => 
252265                         asset.quantity
253266                     case _ => 
254267                         throw("Can't find asset")
255268                 }
256269                 let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
257270                 let forOne = fraction(totalIssued, 100000000, tkStaked)
258271                 let toIssue = fraction(pmtAmount, forOne, 100000000)
259272                 let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
260273                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
261274                 if ((LPstake == LPstake))
262275                     then {
263276                         let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
264277                         let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
265278 [LPIssue, transfer, updateState]
266279                         }
267280                     else throw("Strict value is not equal to itself.")
268281                 }
269282     }
270283 
271284 
272285 
273286 @Callable(i)
274287 func depositUsdcUsdnLP () = {
275288     let pmt = value(i.payments[0])
276289     let pmtAmount = pmt.amount
277290     if ((pmt.assetId != usdcUsdnLP))
278291         then throw("attach USDCUSDNLP tokens only")
279292         else if (isStopped)
280293             then throw("smart contract is on lock")
281294             else {
282295                 let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
283296                 let totalIssued =                 match assetInfo(usdcUsdnLPTCI) {
284297                     case asset: Asset => 
285298                         asset.quantity
286299                     case _ => 
287300                         throw("Can't find asset")
288301                 }
289302                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
290303                 let forOne = fraction(totalIssued, 100000000, tkStaked)
291304                 let toIssue = fraction(pmtAmount, forOne, 100000000)
292305                 let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
293306                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
294307                 if ((LPstake == LPstake))
295308                     then {
296309                         let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
297310                         let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
298311 [LPIssue, transfer, updateState]
299312                         }
300313                     else throw("Strict value is not equal to itself.")
301314                 }
302315     }
303316 
304317 
305318 
306319 @Callable(i)
307320 func depositUsdcUsdtLP () = {
308321     let pmt = value(i.payments[0])
309322     let pmtAmount = pmt.amount
310323     if ((pmt.assetId != usdcUsdtLP))
311324         then throw("attach USDCUSDTLP tokens only")
312325         else if (isStopped)
313326             then throw("smart contract is on lock")
314327             else {
315328                 let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
316329                 let totalIssued =                 match assetInfo(usdcUsdtLPTCI) {
317330                     case asset: Asset => 
318331                         asset.quantity
319332                     case _ => 
320333                         throw("Can't find asset")
321334                 }
322335                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
323336                 let forOne = fraction(totalIssued, 100000000, tkStaked)
324337                 let toIssue = fraction(pmtAmount, forOne, 100000000)
325338                 let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
326339                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
327340                 if ((LPstake == LPstake))
328341                     then {
329342                         let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
330343                         let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
331344 [LPIssue, transfer, updateState]
332345                         }
333346                     else throw("Strict value is not equal to itself.")
334347                 }
335348     }
336349 
337350 
338351 
339352 @Callable(i)
340353 func depositPuzzleUsdnLP () = {
341354     let pmt = value(i.payments[0])
342355     let pmtAmount = pmt.amount
343356     if ((pmt.assetId != puzzleUsdnLP))
344357         then throw("attach PUZZLEUDSNLP tokens only")
345358         else if (isStopped)
346359             then throw("smart contract is on lock")
347360             else {
348361                 let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
349362                 let totalIssued =                 match assetInfo(puzzleUsdnLPTCI) {
350363                     case asset: Asset => 
351364                         asset.quantity
352365                     case _ => 
353366                         throw("Can't find asset")
354367                 }
355368                 let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
356369                 let forOne = fraction(totalIssued, 100000000, tkStaked)
357370                 let toIssue = fraction(pmtAmount, forOne, 100000000)
358371                 let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
359372                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
360373                 if ((LPstake == LPstake))
361374                     then {
362375                         let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
363376                         let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
364377 [LPIssue, transfer, updateState]
365378                         }
366379                     else throw("Strict value is not equal to itself.")
367380                 }
368381     }
369382 
370383 
371384 
372385 @Callable(i)
373386 func depositNsbtUsdnLP () = {
374387     let pmt = value(i.payments[0])
375388     let pmtAmount = pmt.amount
376389     if ((pmt.assetId != nsbtUsdnLP))
377390         then throw("attach NSBTUSDNLP tokens only")
378391         else if (isStopped)
379392             then throw("smart contract is on lock")
380393             else {
381394                 let tkStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
382395                 let totalIssued =                 match assetInfo(nsbtUsdnLPTCI) {
383396                     case asset: Asset => 
384397                         asset.quantity
385398                     case _ => 
386399                         throw("Can't find asset")
387400                 }
388401                 let one = fraction(totalIssued, 100000000, tkStaked)
389402                 let toIssue = fraction(pmtAmount, one, 100000000)
390403                 let updateState = IntegerEntry(keyNSBTUSDN, (tkStaked + pmtAmount))
391404                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
392405                 if ((LPstake == LPstake))
393406                     then {
394407                         let LPIssue = Reissue(nsbtUsdnLPTCI, toIssue, true)
395408                         let transfer = ScriptTransfer(i.caller, toIssue, nsbtUsdnLPTCI)
396409 [LPIssue, transfer, updateState]
397410                         }
398411                     else throw("Strict value is not equal to itself.")
399412                 }
400413     }
401414 
402415 
403416 
404417 @Callable(i)
405418 func depositBtcUsdnLP () = {
406419     let pmt = value(i.payments[0])
407420     let pmtAmount = pmt.amount
408421     if ((pmt.assetId != btcUsdnLP))
409422         then throw("attach BTCUSDNLP tokens only")
410423         else if (isStopped)
411424             then throw("smart contract is on lock")
412425             else {
413426                 let tkStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
414427                 let totalIssued =                 match assetInfo(btcUsdnLPTCI) {
415428                     case asset: Asset => 
416429                         asset.quantity
417430                     case _ => 
418431                         throw("Can't find asset")
419432                 }
420433                 let forOne = fraction(totalIssued, 100000000, tkStaked)
421434                 let toIssue = fraction(pmtAmount, forOne, 100000000)
422435                 let updateState = IntegerEntry(keyBTCUSDN, (tkStaked + pmtAmount))
423436                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
424437                 if ((LPstake == LPstake))
425438                     then {
426439                         let LPIssue = Reissue(btcUsdnLPTCI, toIssue, true)
427440                         let transfer = ScriptTransfer(i.caller, toIssue, btcUsdnLPTCI)
428441 [LPIssue, transfer, updateState]
429442                         }
430443                     else throw("Strict value is not equal to itself.")
431444                 }
432445     }
433446 
434447 
435448 
436449 @Callable(i)
437450 func depositEnnoUsdnLP () = {
438451     let pmt = value(i.payments[0])
439452     let pmtAmount = pmt.amount
440453     if ((pmt.assetId != ennoUsdnLP))
441454         then throw("attach ENNOUSDNLP tokens only")
442455         else if (isStopped)
443456             then throw("smart contract is on lock")
444457             else {
445458                 let tkStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
446459                 let totalIssued =                 match assetInfo(ennoUsdnLPTCI) {
447460                     case asset: Asset => 
448461                         asset.quantity
449462                     case _ => 
450463                         throw("Can't find asset")
451464                 }
452465                 let one = fraction(totalIssued, 100000000, tkStaked)
453466                 let toIssue = fraction(pmtAmount, one, 100000000)
454467                 let updateState = IntegerEntry(keyENNOUSDN, (tkStaked + pmtAmount))
455468                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
456469                 if ((LPstake == LPstake))
457470                     then {
458471                         let LPIssue = Reissue(ennoUsdnLPTCI, toIssue, true)
459472                         let transfer = ScriptTransfer(i.caller, toIssue, ennoUsdnLPTCI)
460473 [LPIssue, transfer, updateState]
461474                         }
462475                     else throw("Strict value is not equal to itself.")
463476                 }
464477     }
465478 
466479 
467480 
468481 @Callable(i)
469482 func depositWavesUsdnLP () = {
470483     let pmt = value(i.payments[0])
471484     let pmtAmount = pmt.amount
472485     if ((pmt.assetId != wavesUsdnLP))
473486         then throw("attach WAVESUSDNLP tokens only")
474487         else if (isStopped)
475488             then throw("smart contract is on lock")
476489             else {
477490                 let tkStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
478491                 let totalIssued =                 match assetInfo(wavesUsdnLPTCI) {
479492                     case asset: Asset => 
480493                         asset.quantity
481494                     case _ => 
482495                         throw("Can't find asset")
483496                 }
484497                 let one = fraction(totalIssued, 100000000, tkStaked)
485498                 let toIssue = fraction(pmtAmount, one, 100000000)
486499                 let updateState = IntegerEntry(keyWAVESUSDN, (tkStaked + pmtAmount))
487500                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
488501                 if ((LPstake == LPstake))
489502                     then {
490503                         let LPIssue = Reissue(wavesUsdnLPTCI, toIssue, true)
491504                         let transfer = ScriptTransfer(i.caller, toIssue, wavesUsdnLPTCI)
492505 [LPIssue, transfer, updateState]
493506                         }
494507                     else throw("Strict value is not equal to itself.")
495508                 }
496509     }
497510 
498511 
499512 
500513 @Callable(i)
501514 func depositLTCUSDNLP () = {
502515     let pmt = value(i.payments[0])
503516     let pmtAmount = pmt.amount
504517     if ((pmt.assetId != ltcUsdnLP))
505518         then throw("attach LTCUSDNLP tokens only")
506519         else if (isStopped)
507520             then throw("smart contract is on lock")
508521             else {
509522                 let tkStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
510523                 let totalIssued =                 match assetInfo(ltcUsdnLPTCI) {
511524                     case asset: Asset => 
512525                         asset.quantity
513526                     case _ => 
514527                         throw("Can't find asset")
515528                 }
516529                 let one = fraction(totalIssued, 100000000, tkStaked)
517530                 let toIssue = fraction(pmtAmount, one, 100000000)
518531                 let updateState = IntegerEntry(keyLTCUSDN, (tkStaked + pmtAmount))
519532                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
520533                 if ((LPstake == LPstake))
521534                     then {
522535                         let LPIssue = Reissue(ltcUsdnLPTCI, toIssue, true)
523536                         let transfer = ScriptTransfer(i.caller, toIssue, ltcUsdnLPTCI)
524537 [LPIssue, transfer, updateState]
525538                         }
526539                     else throw("Strict value is not equal to itself.")
527540                 }
528541     }
529542 
530543 
531544 
532545 @Callable(i)
533546 func compoundWxUsdnLP () = {
534547     let compound = value(i.payments[0])
535548     let ca = compound.amount
536549     let isOracle = checkAddress(i.caller.bytes)
537550     if ((compound.assetId != wxUsdnLP))
538551         then throw("attach WXUSDNLP tokens only")
539552         else if (!(isOracle))
540553             then throw("You are not authotized to call this function")
541554             else {
542555                 let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
543556                 let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
544557                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
545558                 if ((stakeC == stakeC))
546559                     then {
547560                         let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
548561                         let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
549562 [updateState, tc]
550563                         }
551564                     else throw("Strict value is not equal to itself.")
552565                 }
553566     }
554567 
555568 
556569 
557570 @Callable(i)
558571 func compoundUsdtUsdnLP () = {
559572     let compound = value(i.payments[0])
560573     let ca = compound.amount
561574     let isOracle = checkAddress(i.caller.bytes)
562575     if ((compound.assetId != usdtUsdnLP))
563576         then throw("attach USDTUSDNLP tokens only")
564577         else if (!(isOracle))
565578             then throw("You are not authotized to call this function")
566579             else {
567580                 let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
568581                 let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
569582                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
570583                 if ((stakeC == stakeC))
571584                     then {
572585                         let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
573586                         let tc = IntegerEntry(keyCompound, (fromCompound + ca))
574587 [updateState, tc]
575588                         }
576589                     else throw("Strict value is not equal to itself.")
577590                 }
578591     }
579592 
580593 
581594 
582595 @Callable(i)
583596 func compoundUsdcUsdnLP () = {
584597     let compound = value(i.payments[0])
585598     let ca = compound.amount
586599     let isOracle = checkAddress(i.caller.bytes)
587600     if ((compound.assetId != usdcUsdnLP))
588601         then throw("attach USDCUSDNLP tokens only")
589602         else if (!(isOracle))
590603             then throw("You are not authotized to call this function")
591604             else {
592605                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
593606                 let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
594607                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
595608                 if ((stakeC == stakeC))
596609                     then {
597610                         let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
598611                         let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
599612 [updateState, tc]
600613                         }
601614                     else throw("Strict value is not equal to itself.")
602615                 }
603616     }
604617 
605618 
606619 
607620 @Callable(i)
608621 func compoundUsdcUsdtLP () = {
609622     let compound = value(i.payments[0])
610623     let ca = compound.amount
611624     let isOracle = checkAddress(i.caller.bytes)
612625     if ((compound.assetId != usdcUsdtLP))
613626         then throw("attach USDCUSDTLP tokens only")
614627         else if (!(isOracle))
615628             then throw("You are not authotized to call this function")
616629             else {
617630                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
618631                 let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
619632                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
620633                 if ((stakeC == stakeC))
621634                     then {
622635                         let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
623636                         let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
624637 [updateState, tc]
625638                         }
626639                     else throw("Strict value is not equal to itself.")
627640                 }
628641     }
629642 
630643 
631644 
632645 @Callable(i)
633646 func compountPuzzleUsdnLP () = {
634647     let compound = value(i.payments[0])
635648     let ca = compound.amount
636649     let isOracle = checkAddress(i.caller.bytes)
637650     if ((compound.assetId != puzzleUsdnLP))
638651         then throw("attach PUZZLEUSDNLP tokens only")
639652         else if (!(isOracle))
640653             then throw("You are not authotized to call this function")
641654             else {
642655                 let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
643656                 let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
644657                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
645658                 if ((stakeC == stakeC))
646659                     then {
647660                         let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
648661                         let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
649662 [updateState, tc]
650663                         }
651664                     else throw("Strict value is not equal to itself.")
652665                 }
653666     }
654667 
655668 
656669 
657670 @Callable(i)
658671 func compoundNsbtUsdnLP () = {
659672     let compound = value(i.payments[0])
660673     let ca = compound.amount
661674     let isOracle = checkAddress(i.caller.bytes)
662675     if ((compound.assetId != nsbtUsdnLP))
663676         then throw("attach NSBTUSDNLP tokens only")
664677         else if (!(isOracle))
665678             then throw("You are not authotized to call this function")
666679             else {
667680                 let fromCompound = valueOrElse(getInteger(this, keyNsbtUsdnCompound), 0)
668681                 let totalStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
669682                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
670683                 if ((stakeC == stakeC))
671684                     then {
672685                         let updateState = IntegerEntry(keyNSBTUSDN, (totalStaked + ca))
673686                         let tc = IntegerEntry(keyNsbtUsdnCompound, (fromCompound + ca))
674687 [updateState, tc]
675688                         }
676689                     else throw("Strict value is not equal to itself.")
677690                 }
678691     }
679692 
680693 
681694 
682695 @Callable(i)
683696 func compoundBtcUsdnLP () = {
684697     let compound = value(i.payments[0])
685698     let ca = compound.amount
686699     let isOracle = checkAddress(i.caller.bytes)
687700     if ((compound.assetId != btcUsdnLP))
688701         then throw("attach BTCUSDNLP tokens only")
689702         else if (!(isOracle))
690703             then throw("You are not authotized to call this function")
691704             else {
692705                 let fromCompound = valueOrElse(getInteger(this, keyBtcUsdnCompound), 0)
693706                 let totalStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
694707                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
695708                 if ((stakeC == stakeC))
696709                     then {
697710                         let updateState = IntegerEntry(keyBTCUSDN, (totalStaked + ca))
698711                         let tc = IntegerEntry(keyBtcUsdnCompound, (fromCompound + ca))
699712 [updateState, tc]
700713                         }
701714                     else throw("Strict value is not equal to itself.")
702715                 }
703716     }
704717 
705718 
706719 
707720 @Callable(i)
708721 func compoundEnnoUsdnLP () = {
709722     let compound = value(i.payments[0])
710723     let ca = compound.amount
711724     let isOracle = checkAddress(i.caller.bytes)
712725     if ((compound.assetId != ennoUsdnLP))
713726         then throw("attach ENNOUSDNLP tokens only")
714727         else if (!(isOracle))
715728             then throw("You are not authotized to call this function")
716729             else {
717730                 let fromCompound = valueOrElse(getInteger(this, keyEnnoUsdnCompound), 0)
718731                 let totalStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
719732                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
720733                 if ((stakeC == stakeC))
721734                     then {
722735                         let updateState = IntegerEntry(keyENNOUSDN, (totalStaked + ca))
723736                         let tc = IntegerEntry(keyEnnoUsdnCompound, (fromCompound + ca))
724737 [updateState, tc]
725738                         }
726739                     else throw("Strict value is not equal to itself.")
727740                 }
728741     }
729742 
730743 
731744 
732745 @Callable(i)
733746 func compoundWavesUsdnLP () = {
734747     let compound = value(i.payments[0])
735748     let ca = compound.amount
736749     let isOracle = checkAddress(i.caller.bytes)
737750     if ((compound.assetId != wavesUsdnLP))
738751         then throw("attach WAVESUSDNLP tokens only")
739752         else if (!(isOracle))
740753             then throw("You are not authotized to call this function")
741754             else {
742755                 let fromCompound = valueOrElse(getInteger(this, keyWavesUsdnCompound), 0)
743756                 let totalStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
744757                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
745758                 if ((stakeC == stakeC))
746759                     then {
747760                         let updateState = IntegerEntry(keyWAVESUSDN, (totalStaked + ca))
748761                         let tc = IntegerEntry(keyWavesUsdnCompound, (fromCompound + ca))
749762 [updateState, tc]
750763                         }
751764                     else throw("Strict value is not equal to itself.")
752765                 }
753766     }
754767 
755768 
756769 
757770 @Callable(i)
758771 func compoundLtcUsdnLP () = {
759772     let compound = value(i.payments[0])
760773     let ca = compound.amount
761774     let isOracle = checkAddress(i.caller.bytes)
762775     if ((compound.assetId != ltcUsdnLP))
763776         then throw("attach LTCUSDNLP tokens only")
764777         else if (!(isOracle))
765778             then throw("You are not authotized to call this function")
766779             else {
767780                 let fromCompound = valueOrElse(getInteger(this, keyLtcUsdnCompound), 0)
768781                 let totalStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
769782                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
770783                 if ((stakeC == stakeC))
771784                     then {
772785                         let updateState = IntegerEntry(keyLTCUSDN, (totalStaked + ca))
773786                         let tc = IntegerEntry(keyLtcUsdnCompound, (fromCompound + ca))
774787 [updateState, tc]
775788                         }
776789                     else throw("Strict value is not equal to itself.")
777790                 }
778791     }
779792 
780793 
781794 
782795 @Callable(i)
783796 func initNSBTUSDN () = {
784797     let pm = value(i.payments[0])
785798     let am = pm.amount
786799     if ((pm.assetId != nsbtUsdnLP))
787800         then throw("Unexpected token")
788801         else {
789802             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
790803             if ((s == s))
791804                 then {
792805                     let upd = IntegerEntry(keyNSBTUSDN, am)
793806                     let updK = IntegerEntry(keyNsbtUsdnCompound, 0)
794807 [upd, updK]
795808                     }
796809                 else throw("Strict value is not equal to itself.")
797810             }
798811     }
799812 
800813 
801814 
802815 @Callable(i)
803816 func initBTCUSDN () = {
804817     let pm = value(i.payments[0])
805818     let am = pm.amount
806819     if ((pm.assetId != btcUsdnLP))
807820         then throw("Unexpected token")
808821         else {
809822             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
810823             if ((s == s))
811824                 then {
812825                     let upd = IntegerEntry(keyBTCUSDN, am)
813826                     let updK = IntegerEntry(keyBtcUsdnCompound, 0)
814827 [upd, updK]
815828                     }
816829                 else throw("Strict value is not equal to itself.")
817830             }
818831     }
819832 
820833 
821834 
822835 @Callable(i)
823836 func initENNOUSDN () = {
824837     let pm = value(i.payments[0])
825838     let am = pm.amount
826839     if ((pm.assetId != ennoUsdnLP))
827840         then throw("Unexpected token")
828841         else {
829842             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
830843             if ((s == s))
831844                 then {
832845                     let upd = IntegerEntry(keyENNOUSDN, am)
833846                     let updK = IntegerEntry(keyEnnoUsdnCompound, 0)
834847 [upd, updK]
835848                     }
836849                 else throw("Strict value is not equal to itself.")
837850             }
838851     }
839852 
840853 
841854 
842855 @Callable(i)
843856 func initWAVESUSDN () = {
844857     let pm = value(i.payments[0])
845858     let am = pm.amount
846859     if ((pm.assetId != wavesUsdnLP))
847860         then throw("Unexpected token")
848861         else {
849862             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
850863             if ((s == s))
851864                 then {
852865                     let upd = IntegerEntry(keyWAVESUSDN, am)
853866                     let updK = IntegerEntry(keyWavesUsdnCompound, 0)
854867 [upd, updK]
855868                     }
856869                 else throw("Strict value is not equal to itself.")
857870             }
858871     }
859872 
860873 
861874 
862875 @Callable(i)
863876 func initLTCUSDN () = {
864877     let pm = value(i.payments[0])
865878     let am = pm.amount
866879     if ((pm.assetId != ltcUsdnLP))
867880         then throw("Unexpected token")
868881         else {
869882             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
870883             if ((s == s))
871884                 then {
872885                     let upd = IntegerEntry(keyLTCUSDN, am)
873886                     let updK = IntegerEntry(keyLtcUsdnCompound, 0)
874887 [upd, updK]
875888                     }
876889                 else throw("Strict value is not equal to itself.")
877890             }
878891     }
879892 
880893 
881894 
882895 @Callable(i)
883896 func withdraw () = {
884897     let payment = value(i.payments[0])
885898     let am = payment.amount
886899     let id = payment.assetId
887900     if ((size(i.payments) != 1))
888901         then throw("1 pmnt expd")
889902         else if ((id == usdtUsdnLPTCI))
890903             then {
891904                 let TCIAmount =                 match assetInfo(usdtUsdnLPTCI) {
892905                     case q: Asset => 
893906                         q.quantity
894907                     case _ => 
895908                         0
896909                 }
897910                 let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
898911                 let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
899912                 let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
900913                 let fee = fraction(usdnLpToWithdraw, def, feePerc)
901914                 let unstakeUsdtUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf", usdnLpToWithdraw], nil)
902915                 if ((unstakeUsdtUsdnLP == unstakeUsdtUsdnLP))
903916                     then {
904917                         let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
905918                         let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
906919                         let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
907920                         let brn = Burn(usdtUsdnLPTCI, am)
908921 [usdnLpfeeTransfer, transfer, updateUsdnLpStaked, brn]
909922                         }
910923                     else throw("Strict value is not equal to itself.")
911924                 }
912925             else if ((id == wxUsdnLPTCI))
913926                 then {
914927                     let wxTciAm =                     match assetInfo(wxUsdnLPTCI) {
915928                         case q: Asset => 
916929                             q.quantity
917930                         case _ => 
918931                             0
919932                     }
920933                     let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
921934                     let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
922935                     let wxLpToWithdraw = fraction(singleWXLP, am, def)
923936                     let fee = fraction(wxLpToWithdraw, def, feePerc)
924937                     let unstakeWxUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9", wxLpToWithdraw], nil)
925938                     if ((unstakeWxUsdnLP == unstakeWxUsdnLP))
926939                         then {
927940                             let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
928941                             let wxLpTransfer = ScriptTransfer(i.caller, (wxLpToWithdraw - fee), wxUsdnLP)
929942                             let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
930943                             let burnWxLpTci = Burn(wxUsdnLPTCI, am)
931944 [wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked, burnWxLpTci]
932945                             }
933946                         else throw("Strict value is not equal to itself.")
934947                     }
935948                 else if ((id == usdcUsdnLPTCI))
936949                     then {
937950                         let usdcUsdnTCI =                         match assetInfo(usdcUsdnLPTCI) {
938951                             case q: Asset => 
939952                                 q.quantity
940953                             case _ => 
941954                                 0
942955                         }
943956                         let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
944957                         let singleUsdcLP = fraction(usdcUsdnStaked, def, usdcUsdnTCI)
945958                         let usdcUsdnLpToWithdraw = fraction(singleUsdcLP, am, def)
946959                         let fee = fraction(usdcUsdnLpToWithdraw, def, feePerc)
947960                         let unstakeUsdcUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5", usdcUsdnLpToWithdraw], nil)
948961                         if ((unstakeUsdcUsdnLP == unstakeUsdcUsdnLP))
949962                             then {
950963                                 let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
951964                                 let usdcUsdnTransfer = ScriptTransfer(i.caller, (usdcUsdnLpToWithdraw - fee), usdcUsdnLP)
952965                                 let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcUsdnLpToWithdraw))
953966                                 let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
954967 [usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked, burnUsdcUsdnLpTci]
955968                                 }
956969                             else throw("Strict value is not equal to itself.")
957970                         }
958971                     else if ((id == usdcUsdtLPTCI))
959972                         then {
960973                             let usdcUsdtTci =                             match assetInfo(usdcUsdtLPTCI) {
961974                                 case q: Asset => 
962975                                     q.quantity
963976                                 case _ => 
964977                                     0
965978                             }
966979                             let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
967980                             let singleUsdcUsdt = fraction(usdcUsdtStaked, def, usdcUsdtTci)
968981                             let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
969982                             let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
970983                             let unstakeUsdcUsdtLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH", usdcUsdtLpToWithdraw], nil)
971984                             if ((unstakeUsdcUsdtLP == unstakeUsdcUsdtLP))
972985                                 then {
973986                                     let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
974987                                     let usdcUsdtTransfer = ScriptTransfer(i.caller, (usdcUsdtLpToWithdraw - fee), usdcUsdtLP)
975988                                     let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
976989                                     let burnUsdcUsdtLpTci = Burn(usdcUsdtLPTCI, am)
977990 [usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked, burnUsdcUsdtLpTci]
978991                                     }
979992                                 else throw("Strict value is not equal to itself.")
980993                             }
981994                         else if ((id == puzzleUsdnLPTCI))
982995                             then {
983996                                 let puzzleUsdnTci =                                 match assetInfo(puzzleUsdnLPTCI) {
984997                                     case q: Asset => 
985998                                         q.quantity
986999                                     case _ => 
9871000                                         0
9881001                                 }
9891002                                 let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
9901003                                 let singlePuzzleUsdn = fraction(puzzleLPStaked, def, puzzleUsdnTci)
9911004                                 let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
9921005                                 let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
9931006                                 let unstakePuzzleUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP", puzzleUsdnWithdraw], nil)
9941007                                 if ((unstakePuzzleUsdnLP == unstakePuzzleUsdnLP))
9951008                                     then {
9961009                                         let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
9971010                                         let puzzleUsdnTransfer = ScriptTransfer(i.caller, (puzzleUsdnWithdraw - fee), puzzleUsdnLP)
9981011                                         let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
9991012                                         let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
10001013 [puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked, burnPuzzleTCI]
10011014                                         }
10021015                                     else throw("Strict value is not equal to itself.")
10031016                                 }
10041017                             else if ((id == btcUsdnLPTCI))
10051018                                 then {
10061019                                     let btcUsdnTCI =                                     match assetInfo(btcUsdnLPTCI) {
10071020                                         case q: Asset => 
10081021                                             q.quantity
10091022                                         case _ => 
10101023                                             0
10111024                                     }
10121025                                     let btcUsdnStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
10131026                                     let singleBtcUsdn = fraction(btcUsdnStaked, def, btcUsdnTCI)
10141027                                     let btcUsdnWithdraw = fraction(singleBtcUsdn, am, def)
10151028                                     let fee = fraction(btcUsdnWithdraw, def, feePerc)
10161029                                     let unstakeBtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy", btcUsdnWithdraw], nil)
10171030                                     if ((unstakeBtcUsdn == unstakeBtcUsdn))
10181031                                         then {
10191032                                             let btcUsdnLPFee = ScriptTransfer(Address(tw), fee, btcUsdnLP)
10201033                                             let btcUsdnTransfer = ScriptTransfer(i.caller, (btcUsdnWithdraw - fee), btcUsdnLP)
10211034                                             let updateBtcUsdnLPStaked = IntegerEntry(keyBTCUSDN, (btcUsdnStaked - btcUsdnWithdraw))
10221035                                             let burnBtcUsdnTci = Burn(btcUsdnLPTCI, am)
10231036 [btcUsdnLPFee, btcUsdnTransfer, updateBtcUsdnLPStaked, burnBtcUsdnTci]
10241037                                             }
10251038                                         else throw("Strict value is not equal to itself.")
10261039                                     }
10271040                                 else if ((id == wavesUsdnLPTCI))
10281041                                     then {
10291042                                         let wavesUsdnTCI =                                         match assetInfo(wavesUsdnLPTCI) {
10301043                                             case q: Asset => 
10311044                                                 q.quantity
10321045                                             case _ => 
10331046                                                 0
10341047                                         }
10351048                                         let wavesUsdnStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
10361049                                         let singleWavesUsdn = fraction(wavesUsdnStaked, def, wavesUsdnTCI)
10371050                                         let wavesUsdnWithdraw = fraction(singleWavesUsdn, am, def)
10381051                                         let fee = fraction(wavesUsdnWithdraw, def, feePerc)
10391052                                         let unstakeWavesUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1", wavesUsdnWithdraw], nil)
10401053                                         if ((unstakeWavesUsdn == unstakeWavesUsdn))
10411054                                             then {
10421055                                                 let wavesUsndFee = ScriptTransfer(Address(tw), fee, wavesUsdnLP)
10431056                                                 let wavesUsdnTransfer = ScriptTransfer(i.caller, (wavesUsdnWithdraw - fee), wavesUsdnLP)
10441057                                                 let updateWavesUsdnLPStaked = IntegerEntry(keyWAVESUSDN, (wavesUsdnStaked - wavesUsdnWithdraw))
10451058                                                 let burnWavesUsdnTCI = Burn(wavesUsdnLPTCI, am)
10461059 [wavesUsndFee, wavesUsdnTransfer, updateWavesUsdnLPStaked, burnWavesUsdnTCI]
10471060                                                 }
10481061                                             else throw("Strict value is not equal to itself.")
10491062                                         }
10501063                                     else if ((id == ennoUsdnLPTCI))
10511064                                         then {
10521065                                             let ennoUsdnTCI =                                             match assetInfo(ennoUsdnLPTCI) {
10531066                                                 case q: Asset => 
10541067                                                     q.quantity
10551068                                                 case _ => 
10561069                                                     0
10571070                                             }
10581071                                             let ennoUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
10591072                                             let singleEnnoUsdn = fraction(ennoUsdnStaked, def, ennoUsdnTCI)
10601073                                             let ennoUsdnWithdraw = fraction(singleEnnoUsdn, am, def)
10611074                                             let fee = fraction(ennoUsdnWithdraw, def, feePerc)
10621075                                             let unstakeEnnoUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX", ennoUsdnWithdraw], nil)
10631076                                             if ((unstakeEnnoUsdn == unstakeEnnoUsdn))
10641077                                                 then {
10651078                                                     let ennoUsdnFee = ScriptTransfer(Address(tw), fee, ennoUsdnLP)
10661079                                                     let ennoUsdnTransfer = ScriptTransfer(i.caller, (ennoUsdnWithdraw - fee), ennoUsdnLP)
10671080                                                     let updateEnnoUsdnLPStaked = IntegerEntry(keyENNOUSDN, (ennoUsdnStaked - ennoUsdnWithdraw))
10681081                                                     let burnEnnoUsdnTCI = Burn(ennoUsdnLPTCI, am)
10691082 [ennoUsdnFee, ennoUsdnTransfer, updateEnnoUsdnLPStaked, burnEnnoUsdnTCI]
10701083                                                     }
10711084                                                 else throw("Strict value is not equal to itself.")
10721085                                             }
10731086                                         else if ((id == nsbtUsdnLPTCI))
10741087                                             then {
10751088                                                 let nsbtUsdnTCI =                                                 match assetInfo(nsbtUsdnLPTCI) {
10761089                                                     case q: Asset => 
10771090                                                         q.quantity
10781091                                                     case _ => 
10791092                                                         0
10801093                                                 }
10811094                                                 let nsbtUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
10821095                                                 let singleNsbtUsdn = fraction(nsbtUsdnStaked, def, nsbtUsdnTCI)
10831096                                                 let nsbtUsdnWithdraw = fraction(singleNsbtUsdn, am, def)
10841097                                                 let fee = fraction(nsbtUsdnWithdraw, def, feePerc)
10851098                                                 let unstakeNsbtUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5", nsbtUsdnWithdraw], nil)
10861099                                                 if ((unstakeNsbtUsdn == unstakeNsbtUsdn))
10871100                                                     then {
10881101                                                         let nsbtUsdnFee = ScriptTransfer(Address(tw), fee, nsbtUsdnLP)
10891102                                                         let nsbtUsdnTransfer = ScriptTransfer(i.caller, (nsbtUsdnWithdraw - fee), nsbtUsdnLP)
10901103                                                         let updateNsbtUsdnStaked = IntegerEntry(keyNSBTUSDN, (nsbtUsdnStaked - nsbtUsdnWithdraw))
10911104                                                         let burnNsbtUsdnTCI = Burn(nsbtUsdnLPTCI, am)
10921105 [nsbtUsdnFee, nsbtUsdnTransfer, updateNsbtUsdnStaked, burnNsbtUsdnTCI]
10931106                                                         }
10941107                                                     else throw("Strict value is not equal to itself.")
10951108                                                 }
10961109                                             else if ((id == ltcUsdnLPTCI))
10971110                                                 then {
10981111                                                     let ltcUsdnTCI =                                                     match assetInfo(ltcUsdnLPTCI) {
10991112                                                         case q: Asset => 
11001113                                                             q.quantity
11011114                                                         case _ => 
11021115                                                             0
11031116                                                     }
11041117                                                     let ltcUsdnStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
11051118                                                     let singleLtcUsdn = fraction(ltcUsdnStaked, def, ltcUsdnTCI)
11061119                                                     let ltcUsdnWithdraw = fraction(singleLtcUsdn, am, def)
11071120                                                     let fee = fraction(ltcUsdnWithdraw, def, feePerc)
11081121                                                     let unstakeLtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv", ltcUsdnWithdraw], nil)
11091122                                                     if ((unstakeLtcUsdn == unstakeLtcUsdn))
11101123                                                         then {
11111124                                                             let ltcUsdnFee = ScriptTransfer(Address(tw), fee, ltcUsdnLP)
11121125                                                             let ltcUsdnTransfer = ScriptTransfer(i.caller, (ltcUsdnWithdraw - fee), ltcUsdnLP)
11131126                                                             let updateLtcUsdnStaked = IntegerEntry(keyLTCUSDN, (ltcUsdnStaked - ltcUsdnWithdraw))
11141127                                                             let burnLtcUsdnTCI = Burn(ltcUsdnLPTCI, am)
11151128 [ltcUsdnFee, ltcUsdnTransfer, updateLtcUsdnStaked, burnLtcUsdnTCI]
11161129                                                             }
11171130                                                         else throw("Strict value is not equal to itself.")
11181131                                                     }
11191132                                                 else throw("Invalid asset")
11201133     }
11211134 
11221135 
11231136 @Verifier(tx)
11241137 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
11251138 
github/deemru/w8io/6500d08 
110.46 ms ◑