tx · CNQkebmjNyy9ytjaBPF9sY3F8o2h6J3Uc3wykuWYnVWh

3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk:  -0.03100000 Waves

2023.02.27 13:49 [3533488] smart account 3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 8X97kHimyGWmQUUpVMA2rTA6h8D7Uh2WVuL6UgUHiwjm
Next: BXWRJheMyCg6dUiEDz9AwF1JYtT5VjEQyWijLUarz8pU

Diff: 

OldNewDifferences
203203         let tciPrice = fraction(lpStaked, multi8, tciIssued)
204204         let fee = fraction(pmtAmount, multi8, multi10)
205205         let userWithdrawAmount = (pmtAmount - fee)
206-        let lpToUnstake = (userWithdrawAmount * tciPrice)
206+        let lpToUnstake = fraction(userWithdrawAmount, tciPrice, multi8)
207207         let unstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", [lpIdUstake, lpToUnstake], nil)
208208         if ((unstake == unstake))
209209             then {

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 
9090 let keySWAVES_WAVES = "sWAVES_WAVES"
9191 
9292 let keySWAVES_WAVES_Compound = "sWAVES_WAVES_Compound"
9393 
9494 let def = 100000000
9595 
9696 let feePerc = 10000000000
9797 
9898 let tw = base58'3P93R2GBkTGVehRPhytHr7sdxYww93jkbhm'
9999 
100100 let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
101101 
102102 func checkAddress (caller) = if ((caller != oracle))
103103     then false
104104     else true
105105 
106106 
107107 func getTciId (id) = if ((id == usdcUsdnLP))
108108     then usdcUsdnLPTCI
109109     else if ((id == wxUsdnLP))
110110         then wxUsdnLPTCI
111111         else if ((id == usdcUsdnLP))
112112             then usdcUsdnLPTCI
113113             else if ((id == usdcUsdtLP))
114114                 then usdcUsdtLPTCI
115115                 else if ((id == puzzleUsdnLP))
116116                     then puzzleUsdnLPTCI
117117                     else throw("invalid asset")
118118 
119119 
120120 func getKeyStaked (tciId) = if ((tciId == usdtUsdnLPTCI))
121121     then keyStaked
122122     else if ((tciId == wxUsdnLPTCI))
123123         then keyWXUSDN
124124         else if ((tciId == usdcUsdnLPTCI))
125125             then keyUSDCUSDN
126126             else if ((tciId == usdcUsdtLPTCI))
127127                 then keyUSDCUSDT
128128                 else if ((tciId == puzzleUsdnLPTCI))
129129                     then keyPUZZLEUSDN
130130                     else throw("Key does not exist")
131131 
132132 
133133 func encodeId (tciId) = if ((tciId == usdtUsdnLPTCI))
134134     then toBase58String(usdtUsdnLP)
135135     else if ((tciId == wxUsdnLPTCI))
136136         then toBase58String(wxUsdnLP)
137137         else if ((tciId == usdcUsdnLPTCI))
138138             then toBase58String(usdcUsdnLP)
139139             else if ((tciId == usdcUsdtLPTCI))
140140                 then toBase58String(usdcUsdtLP)
141141                 else if ((tciId == puzzleUsdnLPTCI))
142142                     then toBase58String(puzzleUsdnLP)
143143                     else throw("Key does not exist")
144144 
145145 
146146 func convertToString (id) = match id {
147147     case id: ByteVector => 
148148         toBase58String(id)
149149     case _ => 
150150         throw("decoding function error")
151151 }
152152 
153153 
154154 @Callable(i)
155155 func deposit2 () = if ((i.caller != Address(oracle)))
156156     then throw("callable for oracle only")
157157     else {
158158         let assetId = i.payments[0].assetId
159159         let pmtAmount = value(i.payments[0]).amount
160160         let tciId = getTciId(assetId)
161161         let key = getKeyStaked(tciId)
162162         let stakedTokens = valueOrElse(getInteger(this, key), 0)
163163         let tciIssued =         match assetInfo(tciId) {
164164             case asset: Asset => 
165165                 asset.quantity
166166             case _ => 
167167                 throw("Can't find asset")
168168         }
169169         let fee = fraction(pmtAmount, multi8, multi10)
170170         let userDepositBalance = (pmtAmount - fee)
171171         let forOneTci = fraction(tciIssued, multi8, stakedTokens)
172172         let amountToIssue = fraction(userDepositBalance, forOneTci, multi8)
173173         let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [AttachedPayment(assetId, userDepositBalance)])
174174         if ((LPstake == LPstake))
175175             then {
176176                 let updateState = IntegerEntry(key, (stakedTokens + userDepositBalance))
177177                 let issueTCI = Reissue(tciId, amountToIssue, true)
178178                 let transferTCI = ScriptTransfer(i.caller, amountToIssue, tciId)
179179                 let collectFee = ScriptTransfer(Address(tw), fee, assetId)
180180 [updateState, issueTCI, transferTCI, collectFee]
181181                 }
182182             else throw("Strict value is not equal to itself.")
183183         }
184184 
185185 
186186 
187187 @Callable(i)
188188 func withdraw2 () = if ((i.caller != Address(oracle)))
189189     then throw("callable for oracle only")
190190     else {
191191         let tciId = i.payments[0].assetId
192192         let pmtAmount = value(i.payments[0]).amount
193193         let lpIdUstake = encodeId(tciId)
194194         let dataKey = getKeyStaked(tciId)
195195         let asString = convertToString(tciId)
196196         let tciIssued =         match assetInfo(fromBase58String(asString)) {
197197             case asset: Asset => 
198198                 asset.quantity
199199             case _ => 
200200                 throw("Can't pull tci issued")
201201         }
202202         let lpStaked = valueOrElse(getInteger(this, dataKey), 0)
203203         let tciPrice = fraction(lpStaked, multi8, tciIssued)
204204         let fee = fraction(pmtAmount, multi8, multi10)
205205         let userWithdrawAmount = (pmtAmount - fee)
206-        let lpToUnstake = (userWithdrawAmount * tciPrice)
206+        let lpToUnstake = fraction(userWithdrawAmount, tciPrice, multi8)
207207         let unstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", [lpIdUstake, lpToUnstake], nil)
208208         if ((unstake == unstake))
209209             then {
210210                 let burnTci = Burn(getTciId(tciId), userWithdrawAmount)
211211                 let transferFee = ScriptTransfer(Address(tw), fee, tciId)
212212                 let transferUserLP = ScriptTransfer(i.caller, lpToUnstake, fromBase58String(lpIdUstake))
213213                 let updateState = IntegerEntry(dataKey, (lpStaked - lpToUnstake))
214214 [burnTci, transferFee, transferUserLP, updateState]
215215                 }
216216             else throw("Strict value is not equal to itself.")
217217         }
218218 
219219 
220220 
221221 @Callable(i)
222222 func depositWxUsdnLP () = {
223223     let pmt = value(i.payments[0])
224224     let pmtAmount = pmt.amount
225225     if ((pmt.assetId != wxUsdnLP))
226226         then throw("attach WXUSDNLP tokens only")
227227         else if (isStopped)
228228             then throw("smart contract is on lock")
229229             else {
230230                 let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
231231                 let totalIssued =                 match assetInfo(wxUsdnLPTCI) {
232232                     case asset: Asset => 
233233                         asset.quantity
234234                     case _ => 
235235                         throw("Can't find asset")
236236                 }
237237                 let one = fraction(totalIssued, 100000000, tkStaked)
238238                 let toIssue = fraction(pmtAmount, one, 100000000)
239239                 let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
240240                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
241241                 if ((LPstake == LPstake))
242242                     then {
243243                         let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
244244                         let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
245245 [LPIssue, transfer, updateState]
246246                         }
247247                     else throw("Strict value is not equal to itself.")
248248                 }
249249     }
250250 
251251 
252252 
253253 @Callable(i)
254254 func depositUsdtUsdnLP () = {
255255     let pmt = value(i.payments[0])
256256     let pmtAmount = pmt.amount
257257     if ((pmt.assetId != usdtUsdnLP))
258258         then throw("attach USDTUSDNLP tokens only")
259259         else if (isStopped)
260260             then throw("smart contract is on lock")
261261             else {
262262                 let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
263263                 let totalIssued =                 match assetInfo(usdtUsdnLPTCI) {
264264                     case asset: Asset => 
265265                         asset.quantity
266266                     case _ => 
267267                         throw("Can't find asset")
268268                 }
269269                 let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
270270                 let forOne = fraction(totalIssued, 100000000, tkStaked)
271271                 let toIssue = fraction(pmtAmount, forOne, 100000000)
272272                 let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
273273                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
274274                 if ((LPstake == LPstake))
275275                     then {
276276                         let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
277277                         let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
278278 [LPIssue, transfer, updateState]
279279                         }
280280                     else throw("Strict value is not equal to itself.")
281281                 }
282282     }
283283 
284284 
285285 
286286 @Callable(i)
287287 func depositUsdcUsdnLP () = {
288288     let pmt = value(i.payments[0])
289289     let pmtAmount = pmt.amount
290290     if ((pmt.assetId != usdcUsdnLP))
291291         then throw("attach USDCUSDNLP tokens only")
292292         else if (isStopped)
293293             then throw("smart contract is on lock")
294294             else {
295295                 let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
296296                 let totalIssued =                 match assetInfo(usdcUsdnLPTCI) {
297297                     case asset: Asset => 
298298                         asset.quantity
299299                     case _ => 
300300                         throw("Can't find asset")
301301                 }
302302                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
303303                 let forOne = fraction(totalIssued, 100000000, tkStaked)
304304                 let toIssue = fraction(pmtAmount, forOne, 100000000)
305305                 let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
306306                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
307307                 if ((LPstake == LPstake))
308308                     then {
309309                         let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
310310                         let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
311311 [LPIssue, transfer, updateState]
312312                         }
313313                     else throw("Strict value is not equal to itself.")
314314                 }
315315     }
316316 
317317 
318318 
319319 @Callable(i)
320320 func depositUsdcUsdtLP () = {
321321     let pmt = value(i.payments[0])
322322     let pmtAmount = pmt.amount
323323     if ((pmt.assetId != usdcUsdtLP))
324324         then throw("attach USDCUSDTLP tokens only")
325325         else if (isStopped)
326326             then throw("smart contract is on lock")
327327             else {
328328                 let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
329329                 let totalIssued =                 match assetInfo(usdcUsdtLPTCI) {
330330                     case asset: Asset => 
331331                         asset.quantity
332332                     case _ => 
333333                         throw("Can't find asset")
334334                 }
335335                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
336336                 let forOne = fraction(totalIssued, 100000000, tkStaked)
337337                 let toIssue = fraction(pmtAmount, forOne, 100000000)
338338                 let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
339339                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
340340                 if ((LPstake == LPstake))
341341                     then {
342342                         let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
343343                         let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
344344 [LPIssue, transfer, updateState]
345345                         }
346346                     else throw("Strict value is not equal to itself.")
347347                 }
348348     }
349349 
350350 
351351 
352352 @Callable(i)
353353 func depositPuzzleUsdnLP () = {
354354     let pmt = value(i.payments[0])
355355     let pmtAmount = pmt.amount
356356     if ((pmt.assetId != puzzleUsdnLP))
357357         then throw("attach PUZZLEUDSNLP tokens only")
358358         else if (isStopped)
359359             then throw("smart contract is on lock")
360360             else {
361361                 let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
362362                 let totalIssued =                 match assetInfo(puzzleUsdnLPTCI) {
363363                     case asset: Asset => 
364364                         asset.quantity
365365                     case _ => 
366366                         throw("Can't find asset")
367367                 }
368368                 let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
369369                 let forOne = fraction(totalIssued, 100000000, tkStaked)
370370                 let toIssue = fraction(pmtAmount, forOne, 100000000)
371371                 let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
372372                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
373373                 if ((LPstake == LPstake))
374374                     then {
375375                         let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
376376                         let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
377377 [LPIssue, transfer, updateState]
378378                         }
379379                     else throw("Strict value is not equal to itself.")
380380                 }
381381     }
382382 
383383 
384384 
385385 @Callable(i)
386386 func depositNsbtUsdnLP () = {
387387     let pmt = value(i.payments[0])
388388     let pmtAmount = pmt.amount
389389     if ((pmt.assetId != nsbtUsdnLP))
390390         then throw("attach NSBTUSDNLP tokens only")
391391         else if (isStopped)
392392             then throw("smart contract is on lock")
393393             else {
394394                 let tkStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
395395                 let totalIssued =                 match assetInfo(nsbtUsdnLPTCI) {
396396                     case asset: Asset => 
397397                         asset.quantity
398398                     case _ => 
399399                         throw("Can't find asset")
400400                 }
401401                 let one = fraction(totalIssued, 100000000, tkStaked)
402402                 let toIssue = fraction(pmtAmount, one, 100000000)
403403                 let updateState = IntegerEntry(keyNSBTUSDN, (tkStaked + pmtAmount))
404404                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
405405                 if ((LPstake == LPstake))
406406                     then {
407407                         let LPIssue = Reissue(nsbtUsdnLPTCI, toIssue, true)
408408                         let transfer = ScriptTransfer(i.caller, toIssue, nsbtUsdnLPTCI)
409409 [LPIssue, transfer, updateState]
410410                         }
411411                     else throw("Strict value is not equal to itself.")
412412                 }
413413     }
414414 
415415 
416416 
417417 @Callable(i)
418418 func depositBtcUsdnLP () = {
419419     let pmt = value(i.payments[0])
420420     let pmtAmount = pmt.amount
421421     if ((pmt.assetId != btcUsdnLP))
422422         then throw("attach BTCUSDNLP tokens only")
423423         else if (isStopped)
424424             then throw("smart contract is on lock")
425425             else {
426426                 let tkStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
427427                 let totalIssued =                 match assetInfo(btcUsdnLPTCI) {
428428                     case asset: Asset => 
429429                         asset.quantity
430430                     case _ => 
431431                         throw("Can't find asset")
432432                 }
433433                 let forOne = fraction(totalIssued, 100000000, tkStaked)
434434                 let toIssue = fraction(pmtAmount, forOne, 100000000)
435435                 let updateState = IntegerEntry(keyBTCUSDN, (tkStaked + pmtAmount))
436436                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
437437                 if ((LPstake == LPstake))
438438                     then {
439439                         let LPIssue = Reissue(btcUsdnLPTCI, toIssue, true)
440440                         let transfer = ScriptTransfer(i.caller, toIssue, btcUsdnLPTCI)
441441 [LPIssue, transfer, updateState]
442442                         }
443443                     else throw("Strict value is not equal to itself.")
444444                 }
445445     }
446446 
447447 
448448 
449449 @Callable(i)
450450 func depositEnnoUsdnLP () = {
451451     let pmt = value(i.payments[0])
452452     let pmtAmount = pmt.amount
453453     if ((pmt.assetId != ennoUsdnLP))
454454         then throw("attach ENNOUSDNLP tokens only")
455455         else if (isStopped)
456456             then throw("smart contract is on lock")
457457             else {
458458                 let tkStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
459459                 let totalIssued =                 match assetInfo(ennoUsdnLPTCI) {
460460                     case asset: Asset => 
461461                         asset.quantity
462462                     case _ => 
463463                         throw("Can't find asset")
464464                 }
465465                 let one = fraction(totalIssued, 100000000, tkStaked)
466466                 let toIssue = fraction(pmtAmount, one, 100000000)
467467                 let updateState = IntegerEntry(keyENNOUSDN, (tkStaked + pmtAmount))
468468                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
469469                 if ((LPstake == LPstake))
470470                     then {
471471                         let LPIssue = Reissue(ennoUsdnLPTCI, toIssue, true)
472472                         let transfer = ScriptTransfer(i.caller, toIssue, ennoUsdnLPTCI)
473473 [LPIssue, transfer, updateState]
474474                         }
475475                     else throw("Strict value is not equal to itself.")
476476                 }
477477     }
478478 
479479 
480480 
481481 @Callable(i)
482482 func depositWavesUsdnLP () = {
483483     let pmt = value(i.payments[0])
484484     let pmtAmount = pmt.amount
485485     if ((pmt.assetId != wavesUsdnLP))
486486         then throw("attach WAVESUSDNLP tokens only")
487487         else if (isStopped)
488488             then throw("smart contract is on lock")
489489             else {
490490                 let tkStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
491491                 let totalIssued =                 match assetInfo(wavesUsdnLPTCI) {
492492                     case asset: Asset => 
493493                         asset.quantity
494494                     case _ => 
495495                         throw("Can't find asset")
496496                 }
497497                 let one = fraction(totalIssued, 100000000, tkStaked)
498498                 let toIssue = fraction(pmtAmount, one, 100000000)
499499                 let updateState = IntegerEntry(keyWAVESUSDN, (tkStaked + pmtAmount))
500500                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
501501                 if ((LPstake == LPstake))
502502                     then {
503503                         let LPIssue = Reissue(wavesUsdnLPTCI, toIssue, true)
504504                         let transfer = ScriptTransfer(i.caller, toIssue, wavesUsdnLPTCI)
505505 [LPIssue, transfer, updateState]
506506                         }
507507                     else throw("Strict value is not equal to itself.")
508508                 }
509509     }
510510 
511511 
512512 
513513 @Callable(i)
514514 func depositLTCUSDNLP () = {
515515     let pmt = value(i.payments[0])
516516     let pmtAmount = pmt.amount
517517     if ((pmt.assetId != ltcUsdnLP))
518518         then throw("attach LTCUSDNLP tokens only")
519519         else if (isStopped)
520520             then throw("smart contract is on lock")
521521             else {
522522                 let tkStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
523523                 let totalIssued =                 match assetInfo(ltcUsdnLPTCI) {
524524                     case asset: Asset => 
525525                         asset.quantity
526526                     case _ => 
527527                         throw("Can't find asset")
528528                 }
529529                 let one = fraction(totalIssued, 100000000, tkStaked)
530530                 let toIssue = fraction(pmtAmount, one, 100000000)
531531                 let updateState = IntegerEntry(keyLTCUSDN, (tkStaked + pmtAmount))
532532                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
533533                 if ((LPstake == LPstake))
534534                     then {
535535                         let LPIssue = Reissue(ltcUsdnLPTCI, toIssue, true)
536536                         let transfer = ScriptTransfer(i.caller, toIssue, ltcUsdnLPTCI)
537537 [LPIssue, transfer, updateState]
538538                         }
539539                     else throw("Strict value is not equal to itself.")
540540                 }
541541     }
542542 
543543 
544544 
545545 @Callable(i)
546546 func compoundWxUsdnLP () = {
547547     let compound = value(i.payments[0])
548548     let ca = compound.amount
549549     let isOracle = checkAddress(i.caller.bytes)
550550     if ((compound.assetId != wxUsdnLP))
551551         then throw("attach WXUSDNLP tokens only")
552552         else if (!(isOracle))
553553             then throw("You are not authotized to call this function")
554554             else {
555555                 let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
556556                 let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
557557                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
558558                 if ((stakeC == stakeC))
559559                     then {
560560                         let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
561561                         let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
562562 [updateState, tc]
563563                         }
564564                     else throw("Strict value is not equal to itself.")
565565                 }
566566     }
567567 
568568 
569569 
570570 @Callable(i)
571571 func compoundUsdtUsdnLP () = {
572572     let compound = value(i.payments[0])
573573     let ca = compound.amount
574574     let isOracle = checkAddress(i.caller.bytes)
575575     if ((compound.assetId != usdtUsdnLP))
576576         then throw("attach USDTUSDNLP tokens only")
577577         else if (!(isOracle))
578578             then throw("You are not authotized to call this function")
579579             else {
580580                 let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
581581                 let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
582582                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
583583                 if ((stakeC == stakeC))
584584                     then {
585585                         let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
586586                         let tc = IntegerEntry(keyCompound, (fromCompound + ca))
587587 [updateState, tc]
588588                         }
589589                     else throw("Strict value is not equal to itself.")
590590                 }
591591     }
592592 
593593 
594594 
595595 @Callable(i)
596596 func compoundUsdcUsdnLP () = {
597597     let compound = value(i.payments[0])
598598     let ca = compound.amount
599599     let isOracle = checkAddress(i.caller.bytes)
600600     if ((compound.assetId != usdcUsdnLP))
601601         then throw("attach USDCUSDNLP tokens only")
602602         else if (!(isOracle))
603603             then throw("You are not authotized to call this function")
604604             else {
605605                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
606606                 let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
607607                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
608608                 if ((stakeC == stakeC))
609609                     then {
610610                         let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
611611                         let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
612612 [updateState, tc]
613613                         }
614614                     else throw("Strict value is not equal to itself.")
615615                 }
616616     }
617617 
618618 
619619 
620620 @Callable(i)
621621 func compoundUsdcUsdtLP () = {
622622     let compound = value(i.payments[0])
623623     let ca = compound.amount
624624     let isOracle = checkAddress(i.caller.bytes)
625625     if ((compound.assetId != usdcUsdtLP))
626626         then throw("attach USDCUSDTLP tokens only")
627627         else if (!(isOracle))
628628             then throw("You are not authotized to call this function")
629629             else {
630630                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
631631                 let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
632632                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
633633                 if ((stakeC == stakeC))
634634                     then {
635635                         let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
636636                         let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
637637 [updateState, tc]
638638                         }
639639                     else throw("Strict value is not equal to itself.")
640640                 }
641641     }
642642 
643643 
644644 
645645 @Callable(i)
646646 func compountPuzzleUsdnLP () = {
647647     let compound = value(i.payments[0])
648648     let ca = compound.amount
649649     let isOracle = checkAddress(i.caller.bytes)
650650     if ((compound.assetId != puzzleUsdnLP))
651651         then throw("attach PUZZLEUSDNLP tokens only")
652652         else if (!(isOracle))
653653             then throw("You are not authotized to call this function")
654654             else {
655655                 let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
656656                 let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
657657                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
658658                 if ((stakeC == stakeC))
659659                     then {
660660                         let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
661661                         let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
662662 [updateState, tc]
663663                         }
664664                     else throw("Strict value is not equal to itself.")
665665                 }
666666     }
667667 
668668 
669669 
670670 @Callable(i)
671671 func compoundNsbtUsdnLP () = {
672672     let compound = value(i.payments[0])
673673     let ca = compound.amount
674674     let isOracle = checkAddress(i.caller.bytes)
675675     if ((compound.assetId != nsbtUsdnLP))
676676         then throw("attach NSBTUSDNLP tokens only")
677677         else if (!(isOracle))
678678             then throw("You are not authotized to call this function")
679679             else {
680680                 let fromCompound = valueOrElse(getInteger(this, keyNsbtUsdnCompound), 0)
681681                 let totalStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
682682                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
683683                 if ((stakeC == stakeC))
684684                     then {
685685                         let updateState = IntegerEntry(keyNSBTUSDN, (totalStaked + ca))
686686                         let tc = IntegerEntry(keyNsbtUsdnCompound, (fromCompound + ca))
687687 [updateState, tc]
688688                         }
689689                     else throw("Strict value is not equal to itself.")
690690                 }
691691     }
692692 
693693 
694694 
695695 @Callable(i)
696696 func compoundBtcUsdnLP () = {
697697     let compound = value(i.payments[0])
698698     let ca = compound.amount
699699     let isOracle = checkAddress(i.caller.bytes)
700700     if ((compound.assetId != btcUsdnLP))
701701         then throw("attach BTCUSDNLP tokens only")
702702         else if (!(isOracle))
703703             then throw("You are not authotized to call this function")
704704             else {
705705                 let fromCompound = valueOrElse(getInteger(this, keyBtcUsdnCompound), 0)
706706                 let totalStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
707707                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
708708                 if ((stakeC == stakeC))
709709                     then {
710710                         let updateState = IntegerEntry(keyBTCUSDN, (totalStaked + ca))
711711                         let tc = IntegerEntry(keyBtcUsdnCompound, (fromCompound + ca))
712712 [updateState, tc]
713713                         }
714714                     else throw("Strict value is not equal to itself.")
715715                 }
716716     }
717717 
718718 
719719 
720720 @Callable(i)
721721 func compoundEnnoUsdnLP () = {
722722     let compound = value(i.payments[0])
723723     let ca = compound.amount
724724     let isOracle = checkAddress(i.caller.bytes)
725725     if ((compound.assetId != ennoUsdnLP))
726726         then throw("attach ENNOUSDNLP tokens only")
727727         else if (!(isOracle))
728728             then throw("You are not authotized to call this function")
729729             else {
730730                 let fromCompound = valueOrElse(getInteger(this, keyEnnoUsdnCompound), 0)
731731                 let totalStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
732732                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
733733                 if ((stakeC == stakeC))
734734                     then {
735735                         let updateState = IntegerEntry(keyENNOUSDN, (totalStaked + ca))
736736                         let tc = IntegerEntry(keyEnnoUsdnCompound, (fromCompound + ca))
737737 [updateState, tc]
738738                         }
739739                     else throw("Strict value is not equal to itself.")
740740                 }
741741     }
742742 
743743 
744744 
745745 @Callable(i)
746746 func compoundWavesUsdnLP () = {
747747     let compound = value(i.payments[0])
748748     let ca = compound.amount
749749     let isOracle = checkAddress(i.caller.bytes)
750750     if ((compound.assetId != wavesUsdnLP))
751751         then throw("attach WAVESUSDNLP tokens only")
752752         else if (!(isOracle))
753753             then throw("You are not authotized to call this function")
754754             else {
755755                 let fromCompound = valueOrElse(getInteger(this, keyWavesUsdnCompound), 0)
756756                 let totalStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
757757                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
758758                 if ((stakeC == stakeC))
759759                     then {
760760                         let updateState = IntegerEntry(keyWAVESUSDN, (totalStaked + ca))
761761                         let tc = IntegerEntry(keyWavesUsdnCompound, (fromCompound + ca))
762762 [updateState, tc]
763763                         }
764764                     else throw("Strict value is not equal to itself.")
765765                 }
766766     }
767767 
768768 
769769 
770770 @Callable(i)
771771 func compoundLtcUsdnLP () = {
772772     let compound = value(i.payments[0])
773773     let ca = compound.amount
774774     let isOracle = checkAddress(i.caller.bytes)
775775     if ((compound.assetId != ltcUsdnLP))
776776         then throw("attach LTCUSDNLP tokens only")
777777         else if (!(isOracle))
778778             then throw("You are not authotized to call this function")
779779             else {
780780                 let fromCompound = valueOrElse(getInteger(this, keyLtcUsdnCompound), 0)
781781                 let totalStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
782782                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
783783                 if ((stakeC == stakeC))
784784                     then {
785785                         let updateState = IntegerEntry(keyLTCUSDN, (totalStaked + ca))
786786                         let tc = IntegerEntry(keyLtcUsdnCompound, (fromCompound + ca))
787787 [updateState, tc]
788788                         }
789789                     else throw("Strict value is not equal to itself.")
790790                 }
791791     }
792792 
793793 
794794 
795795 @Callable(i)
796796 func initNSBTUSDN () = {
797797     let pm = value(i.payments[0])
798798     let am = pm.amount
799799     if ((pm.assetId != nsbtUsdnLP))
800800         then throw("Unexpected token")
801801         else {
802802             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
803803             if ((s == s))
804804                 then {
805805                     let upd = IntegerEntry(keyNSBTUSDN, am)
806806                     let updK = IntegerEntry(keyNsbtUsdnCompound, 0)
807807 [upd, updK]
808808                     }
809809                 else throw("Strict value is not equal to itself.")
810810             }
811811     }
812812 
813813 
814814 
815815 @Callable(i)
816816 func initBTCUSDN () = {
817817     let pm = value(i.payments[0])
818818     let am = pm.amount
819819     if ((pm.assetId != btcUsdnLP))
820820         then throw("Unexpected token")
821821         else {
822822             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
823823             if ((s == s))
824824                 then {
825825                     let upd = IntegerEntry(keyBTCUSDN, am)
826826                     let updK = IntegerEntry(keyBtcUsdnCompound, 0)
827827 [upd, updK]
828828                     }
829829                 else throw("Strict value is not equal to itself.")
830830             }
831831     }
832832 
833833 
834834 
835835 @Callable(i)
836836 func initENNOUSDN () = {
837837     let pm = value(i.payments[0])
838838     let am = pm.amount
839839     if ((pm.assetId != ennoUsdnLP))
840840         then throw("Unexpected token")
841841         else {
842842             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
843843             if ((s == s))
844844                 then {
845845                     let upd = IntegerEntry(keyENNOUSDN, am)
846846                     let updK = IntegerEntry(keyEnnoUsdnCompound, 0)
847847 [upd, updK]
848848                     }
849849                 else throw("Strict value is not equal to itself.")
850850             }
851851     }
852852 
853853 
854854 
855855 @Callable(i)
856856 func initWAVESUSDN () = {
857857     let pm = value(i.payments[0])
858858     let am = pm.amount
859859     if ((pm.assetId != wavesUsdnLP))
860860         then throw("Unexpected token")
861861         else {
862862             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
863863             if ((s == s))
864864                 then {
865865                     let upd = IntegerEntry(keyWAVESUSDN, am)
866866                     let updK = IntegerEntry(keyWavesUsdnCompound, 0)
867867 [upd, updK]
868868                     }
869869                 else throw("Strict value is not equal to itself.")
870870             }
871871     }
872872 
873873 
874874 
875875 @Callable(i)
876876 func initLTCUSDN () = {
877877     let pm = value(i.payments[0])
878878     let am = pm.amount
879879     if ((pm.assetId != ltcUsdnLP))
880880         then throw("Unexpected token")
881881         else {
882882             let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
883883             if ((s == s))
884884                 then {
885885                     let upd = IntegerEntry(keyLTCUSDN, am)
886886                     let updK = IntegerEntry(keyLtcUsdnCompound, 0)
887887 [upd, updK]
888888                     }
889889                 else throw("Strict value is not equal to itself.")
890890             }
891891     }
892892 
893893 
894894 
895895 @Callable(i)
896896 func withdraw () = {
897897     let payment = value(i.payments[0])
898898     let am = payment.amount
899899     let id = payment.assetId
900900     if ((size(i.payments) != 1))
901901         then throw("1 pmnt expd")
902902         else if ((id == usdtUsdnLPTCI))
903903             then {
904904                 let TCIAmount =                 match assetInfo(usdtUsdnLPTCI) {
905905                     case q: Asset => 
906906                         q.quantity
907907                     case _ => 
908908                         0
909909                 }
910910                 let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
911911                 let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
912912                 let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
913913                 let fee = fraction(usdnLpToWithdraw, def, feePerc)
914914                 let unstakeUsdtUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf", usdnLpToWithdraw], nil)
915915                 if ((unstakeUsdtUsdnLP == unstakeUsdtUsdnLP))
916916                     then {
917917                         let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
918918                         let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
919919                         let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
920920                         let brn = Burn(usdtUsdnLPTCI, am)
921921 [usdnLpfeeTransfer, transfer, updateUsdnLpStaked, brn]
922922                         }
923923                     else throw("Strict value is not equal to itself.")
924924                 }
925925             else if ((id == wxUsdnLPTCI))
926926                 then {
927927                     let wxTciAm =                     match assetInfo(wxUsdnLPTCI) {
928928                         case q: Asset => 
929929                             q.quantity
930930                         case _ => 
931931                             0
932932                     }
933933                     let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
934934                     let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
935935                     let wxLpToWithdraw = fraction(singleWXLP, am, def)
936936                     let fee = fraction(wxLpToWithdraw, def, feePerc)
937937                     let unstakeWxUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9", wxLpToWithdraw], nil)
938938                     if ((unstakeWxUsdnLP == unstakeWxUsdnLP))
939939                         then {
940940                             let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
941941                             let wxLpTransfer = ScriptTransfer(i.caller, (wxLpToWithdraw - fee), wxUsdnLP)
942942                             let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
943943                             let burnWxLpTci = Burn(wxUsdnLPTCI, am)
944944 [wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked, burnWxLpTci]
945945                             }
946946                         else throw("Strict value is not equal to itself.")
947947                     }
948948                 else if ((id == usdcUsdnLPTCI))
949949                     then {
950950                         let usdcUsdnTCI =                         match assetInfo(usdcUsdnLPTCI) {
951951                             case q: Asset => 
952952                                 q.quantity
953953                             case _ => 
954954                                 0
955955                         }
956956                         let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
957957                         let singleUsdcLP = fraction(usdcUsdnStaked, def, usdcUsdnTCI)
958958                         let usdcUsdnLpToWithdraw = fraction(singleUsdcLP, am, def)
959959                         let fee = fraction(usdcUsdnLpToWithdraw, def, feePerc)
960960                         let unstakeUsdcUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5", usdcUsdnLpToWithdraw], nil)
961961                         if ((unstakeUsdcUsdnLP == unstakeUsdcUsdnLP))
962962                             then {
963963                                 let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
964964                                 let usdcUsdnTransfer = ScriptTransfer(i.caller, (usdcUsdnLpToWithdraw - fee), usdcUsdnLP)
965965                                 let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcUsdnLpToWithdraw))
966966                                 let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
967967 [usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked, burnUsdcUsdnLpTci]
968968                                 }
969969                             else throw("Strict value is not equal to itself.")
970970                         }
971971                     else if ((id == usdcUsdtLPTCI))
972972                         then {
973973                             let usdcUsdtTci =                             match assetInfo(usdcUsdtLPTCI) {
974974                                 case q: Asset => 
975975                                     q.quantity
976976                                 case _ => 
977977                                     0
978978                             }
979979                             let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
980980                             let singleUsdcUsdt = fraction(usdcUsdtStaked, def, usdcUsdtTci)
981981                             let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
982982                             let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
983983                             let unstakeUsdcUsdtLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH", usdcUsdtLpToWithdraw], nil)
984984                             if ((unstakeUsdcUsdtLP == unstakeUsdcUsdtLP))
985985                                 then {
986986                                     let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
987987                                     let usdcUsdtTransfer = ScriptTransfer(i.caller, (usdcUsdtLpToWithdraw - fee), usdcUsdtLP)
988988                                     let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
989989                                     let burnUsdcUsdtLpTci = Burn(usdcUsdtLPTCI, am)
990990 [usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked, burnUsdcUsdtLpTci]
991991                                     }
992992                                 else throw("Strict value is not equal to itself.")
993993                             }
994994                         else if ((id == puzzleUsdnLPTCI))
995995                             then {
996996                                 let puzzleUsdnTci =                                 match assetInfo(puzzleUsdnLPTCI) {
997997                                     case q: Asset => 
998998                                         q.quantity
999999                                     case _ => 
10001000                                         0
10011001                                 }
10021002                                 let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
10031003                                 let singlePuzzleUsdn = fraction(puzzleLPStaked, def, puzzleUsdnTci)
10041004                                 let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
10051005                                 let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
10061006                                 let unstakePuzzleUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP", puzzleUsdnWithdraw], nil)
10071007                                 if ((unstakePuzzleUsdnLP == unstakePuzzleUsdnLP))
10081008                                     then {
10091009                                         let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
10101010                                         let puzzleUsdnTransfer = ScriptTransfer(i.caller, (puzzleUsdnWithdraw - fee), puzzleUsdnLP)
10111011                                         let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
10121012                                         let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
10131013 [puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked, burnPuzzleTCI]
10141014                                         }
10151015                                     else throw("Strict value is not equal to itself.")
10161016                                 }
10171017                             else if ((id == btcUsdnLPTCI))
10181018                                 then {
10191019                                     let btcUsdnTCI =                                     match assetInfo(btcUsdnLPTCI) {
10201020                                         case q: Asset => 
10211021                                             q.quantity
10221022                                         case _ => 
10231023                                             0
10241024                                     }
10251025                                     let btcUsdnStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
10261026                                     let singleBtcUsdn = fraction(btcUsdnStaked, def, btcUsdnTCI)
10271027                                     let btcUsdnWithdraw = fraction(singleBtcUsdn, am, def)
10281028                                     let fee = fraction(btcUsdnWithdraw, def, feePerc)
10291029                                     let unstakeBtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy", btcUsdnWithdraw], nil)
10301030                                     if ((unstakeBtcUsdn == unstakeBtcUsdn))
10311031                                         then {
10321032                                             let btcUsdnLPFee = ScriptTransfer(Address(tw), fee, btcUsdnLP)
10331033                                             let btcUsdnTransfer = ScriptTransfer(i.caller, (btcUsdnWithdraw - fee), btcUsdnLP)
10341034                                             let updateBtcUsdnLPStaked = IntegerEntry(keyBTCUSDN, (btcUsdnStaked - btcUsdnWithdraw))
10351035                                             let burnBtcUsdnTci = Burn(btcUsdnLPTCI, am)
10361036 [btcUsdnLPFee, btcUsdnTransfer, updateBtcUsdnLPStaked, burnBtcUsdnTci]
10371037                                             }
10381038                                         else throw("Strict value is not equal to itself.")
10391039                                     }
10401040                                 else if ((id == wavesUsdnLPTCI))
10411041                                     then {
10421042                                         let wavesUsdnTCI =                                         match assetInfo(wavesUsdnLPTCI) {
10431043                                             case q: Asset => 
10441044                                                 q.quantity
10451045                                             case _ => 
10461046                                                 0
10471047                                         }
10481048                                         let wavesUsdnStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
10491049                                         let singleWavesUsdn = fraction(wavesUsdnStaked, def, wavesUsdnTCI)
10501050                                         let wavesUsdnWithdraw = fraction(singleWavesUsdn, am, def)
10511051                                         let fee = fraction(wavesUsdnWithdraw, def, feePerc)
10521052                                         let unstakeWavesUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1", wavesUsdnWithdraw], nil)
10531053                                         if ((unstakeWavesUsdn == unstakeWavesUsdn))
10541054                                             then {
10551055                                                 let wavesUsndFee = ScriptTransfer(Address(tw), fee, wavesUsdnLP)
10561056                                                 let wavesUsdnTransfer = ScriptTransfer(i.caller, (wavesUsdnWithdraw - fee), wavesUsdnLP)
10571057                                                 let updateWavesUsdnLPStaked = IntegerEntry(keyWAVESUSDN, (wavesUsdnStaked - wavesUsdnWithdraw))
10581058                                                 let burnWavesUsdnTCI = Burn(wavesUsdnLPTCI, am)
10591059 [wavesUsndFee, wavesUsdnTransfer, updateWavesUsdnLPStaked, burnWavesUsdnTCI]
10601060                                                 }
10611061                                             else throw("Strict value is not equal to itself.")
10621062                                         }
10631063                                     else if ((id == ennoUsdnLPTCI))
10641064                                         then {
10651065                                             let ennoUsdnTCI =                                             match assetInfo(ennoUsdnLPTCI) {
10661066                                                 case q: Asset => 
10671067                                                     q.quantity
10681068                                                 case _ => 
10691069                                                     0
10701070                                             }
10711071                                             let ennoUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
10721072                                             let singleEnnoUsdn = fraction(ennoUsdnStaked, def, ennoUsdnTCI)
10731073                                             let ennoUsdnWithdraw = fraction(singleEnnoUsdn, am, def)
10741074                                             let fee = fraction(ennoUsdnWithdraw, def, feePerc)
10751075                                             let unstakeEnnoUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX", ennoUsdnWithdraw], nil)
10761076                                             if ((unstakeEnnoUsdn == unstakeEnnoUsdn))
10771077                                                 then {
10781078                                                     let ennoUsdnFee = ScriptTransfer(Address(tw), fee, ennoUsdnLP)
10791079                                                     let ennoUsdnTransfer = ScriptTransfer(i.caller, (ennoUsdnWithdraw - fee), ennoUsdnLP)
10801080                                                     let updateEnnoUsdnLPStaked = IntegerEntry(keyENNOUSDN, (ennoUsdnStaked - ennoUsdnWithdraw))
10811081                                                     let burnEnnoUsdnTCI = Burn(ennoUsdnLPTCI, am)
10821082 [ennoUsdnFee, ennoUsdnTransfer, updateEnnoUsdnLPStaked, burnEnnoUsdnTCI]
10831083                                                     }
10841084                                                 else throw("Strict value is not equal to itself.")
10851085                                             }
10861086                                         else if ((id == nsbtUsdnLPTCI))
10871087                                             then {
10881088                                                 let nsbtUsdnTCI =                                                 match assetInfo(nsbtUsdnLPTCI) {
10891089                                                     case q: Asset => 
10901090                                                         q.quantity
10911091                                                     case _ => 
10921092                                                         0
10931093                                                 }
10941094                                                 let nsbtUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
10951095                                                 let singleNsbtUsdn = fraction(nsbtUsdnStaked, def, nsbtUsdnTCI)
10961096                                                 let nsbtUsdnWithdraw = fraction(singleNsbtUsdn, am, def)
10971097                                                 let fee = fraction(nsbtUsdnWithdraw, def, feePerc)
10981098                                                 let unstakeNsbtUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5", nsbtUsdnWithdraw], nil)
10991099                                                 if ((unstakeNsbtUsdn == unstakeNsbtUsdn))
11001100                                                     then {
11011101                                                         let nsbtUsdnFee = ScriptTransfer(Address(tw), fee, nsbtUsdnLP)
11021102                                                         let nsbtUsdnTransfer = ScriptTransfer(i.caller, (nsbtUsdnWithdraw - fee), nsbtUsdnLP)
11031103                                                         let updateNsbtUsdnStaked = IntegerEntry(keyNSBTUSDN, (nsbtUsdnStaked - nsbtUsdnWithdraw))
11041104                                                         let burnNsbtUsdnTCI = Burn(nsbtUsdnLPTCI, am)
11051105 [nsbtUsdnFee, nsbtUsdnTransfer, updateNsbtUsdnStaked, burnNsbtUsdnTCI]
11061106                                                         }
11071107                                                     else throw("Strict value is not equal to itself.")
11081108                                                 }
11091109                                             else if ((id == ltcUsdnLPTCI))
11101110                                                 then {
11111111                                                     let ltcUsdnTCI =                                                     match assetInfo(ltcUsdnLPTCI) {
11121112                                                         case q: Asset => 
11131113                                                             q.quantity
11141114                                                         case _ => 
11151115                                                             0
11161116                                                     }
11171117                                                     let ltcUsdnStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
11181118                                                     let singleLtcUsdn = fraction(ltcUsdnStaked, def, ltcUsdnTCI)
11191119                                                     let ltcUsdnWithdraw = fraction(singleLtcUsdn, am, def)
11201120                                                     let fee = fraction(ltcUsdnWithdraw, def, feePerc)
11211121                                                     let unstakeLtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv", ltcUsdnWithdraw], nil)
11221122                                                     if ((unstakeLtcUsdn == unstakeLtcUsdn))
11231123                                                         then {
11241124                                                             let ltcUsdnFee = ScriptTransfer(Address(tw), fee, ltcUsdnLP)
11251125                                                             let ltcUsdnTransfer = ScriptTransfer(i.caller, (ltcUsdnWithdraw - fee), ltcUsdnLP)
11261126                                                             let updateLtcUsdnStaked = IntegerEntry(keyLTCUSDN, (ltcUsdnStaked - ltcUsdnWithdraw))
11271127                                                             let burnLtcUsdnTCI = Burn(ltcUsdnLPTCI, am)
11281128 [ltcUsdnFee, ltcUsdnTransfer, updateLtcUsdnStaked, burnLtcUsdnTCI]
11291129                                                             }
11301130                                                         else throw("Strict value is not equal to itself.")
11311131                                                     }
11321132                                                 else throw("Invalid asset")
11331133     }
11341134 
11351135 
11361136 @Verifier(tx)
11371137 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
11381138 
github/deemru/w8io/3ef1775 
86.47 ms ◑