tx · G3YdFR5MsKPiHYpbS5Y7ywUEQ4X3nAhBsmK6Ay5oG8wK

3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk:  -0.03100000 Waves

2023.02.02 16:08 [3497567] smart account 3PQV9AUMU36fdDYMmMZw6urSYG3BuMahQuk > SELF 0.00000000 Waves

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

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

Diff: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4+let multi8 = 100000000
5+
6+let multi10 = 10000000000
7+
48 let usdtUsdnLP = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
59 
610 let usdtUsdnLPTCI = base58'2CD44HANZzsdU7yqRsmz7L9eA2Foh4YYMC4azMbaZEj6'
8387 
8488 let keyLtcUsdnCompound = "LTC_USDN_Compound"
8589 
86-let wxId = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
87-
88-let keySponsorship = "Sponsorship_in_lock"
89-
9090 let def = 100000000
9191 
9292 let feePerc = 10000000000
9898 func checkAddress (caller) = if ((caller != oracle))
9999     then false
100100     else true
101+
102+
103+func getTciId (id) = if ((id == usdcUsdnLP))
104+    then usdcUsdnLPTCI
105+    else if ((id == wxUsdnLP))
106+        then wxUsdnLPTCI
107+        else if ((id == usdcUsdnLP))
108+            then usdcUsdnLPTCI
109+            else if ((id == usdcUsdtLP))
110+                then usdcUsdtLPTCI
111+                else if ((id == puzzleUsdnLP))
112+                    then puzzleUsdnLPTCI
113+                    else throw("invalid asset")
114+
115+
116+func getKeyStaked (tciId) = if ((tciId == usdtUsdnLPTCI))
117+    then keyStaked
118+    else if ((tciId == wxUsdnLPTCI))
119+        then keyWXUSDN
120+        else if ((tciId == usdcUsdnLPTCI))
121+            then keyUSDCUSDN
122+            else if ((tciId == usdcUsdtLPTCI))
123+                then keyUSDCUSDT
124+                else if ((tciId == puzzleUsdnLPTCI))
125+                    then keyPUZZLEUSDN
126+                    else throw("Key does not exist")
127+
128+
129+func encodeId (tciId) = if ((tciId == usdtUsdnLPTCI))
130+    then toBase58String(usdtUsdnLP)
131+    else if ((tciId == wxUsdnLPTCI))
132+        then toBase58String(wxUsdnLP)
133+        else if ((tciId == usdcUsdnLPTCI))
134+            then toBase58String(usdcUsdnLP)
135+            else if ((tciId == usdcUsdtLPTCI))
136+                then toBase58String(usdcUsdtLP)
137+                else if ((tciId == puzzleUsdnLPTCI))
138+                    then toBase58String(puzzleUsdnLP)
139+                    else throw("Key does not exist")
140+
141+
142+@Callable(i)
143+func deposit2 () = if ((i.caller != Address(oracle)))
144+    then throw("callable for oracle only")
145+    else {
146+        let assetId = i.payments[0].assetId
147+        let pmtAmount = value(i.payments[0]).amount
148+        let tciId = getTciId(assetId)
149+        let key = getKeyStaked(tciId)
150+        let stakedTokens = valueOrElse(getInteger(this, key), 0)
151+        let tciIssued =         match assetInfo(tciId) {
152+            case asset: Asset => 
153+                asset.quantity
154+            case _ => 
155+                throw("Can't find asset")
156+        }
157+        let fee = fraction(pmtAmount, multi8, multi10)
158+        let userDepositBalance = (pmtAmount - fee)
159+        let forOneTci = fraction(tciIssued, multi8, stakedTokens)
160+        let amountToIssue = fraction(userDepositBalance, forOneTci, multi8)
161+        let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [AttachedPayment(assetId, userDepositBalance)])
162+        if ((LPstake == LPstake))
163+            then {
164+                let updateState = IntegerEntry(key, (stakedTokens + userDepositBalance))
165+                let issueTCI = Reissue(tciId, amountToIssue, true)
166+                let transferTCI = ScriptTransfer(i.caller, amountToIssue, tciId)
167+                let collectFee = ScriptTransfer(Address(tw), fee, assetId)
168+[updateState, issueTCI, transferTCI, collectFee]
169+                }
170+            else throw("Strict value is not equal to itself.")
171+        }
172+
173+
174+
175+@Callable(i)
176+func withdraw2 () = if ((i.caller != Address(oracle)))
177+    then throw("callable for oracle only")
178+    else {
179+        let tciId = i.payments[0].assetId
180+        let pmtAmount = value(i.payments[0]).amount
181+        let lpIdUstake = encodeId(tciId)
182+        let dataKey = getKeyStaked(tciId)
183+        let tciIssued =         match assetInfo(getTciId(tciId)) {
184+            case asset: Asset => 
185+                asset.quantity
186+            case _ => 
187+                throw("Can't find asset")
188+        }
189+        let lpStaked = valueOrElse(getInteger(this, dataKey), 0)
190+        let tciPrice = fraction(lpStaked, multi8, tciIssued)
191+        let fee = fraction(pmtAmount, multi8, multi10)
192+        let userWithdrawAmount = (pmtAmount - fee)
193+        let lpToUnstake = (userWithdrawAmount * tciPrice)
194+        let unstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", [lpIdUstake, lpToUnstake], nil)
195+        if ((unstake == unstake))
196+            then {
197+                let burnTci = Burn(getTciId(tciId), userWithdrawAmount)
198+                let transferFee = ScriptTransfer(Address(tw), fee, tciId)
199+                let transferUserLP = ScriptTransfer(i.caller, lpToUnstake, fromBase58String(lpIdUstake))
200+                let updateState = IntegerEntry(dataKey, (lpStaked - lpToUnstake))
201+[burnTci, transferFee, transferUserLP, updateState]
202+                }
203+            else throw("Strict value is not equal to itself.")
204+        }
205+
101206 
102207 
103208 @Callable(i)
393498 
394499 
395500 @Callable(i)
396-func depositLtcUsdnLP () = {
501+func depositLTCUSDNLP () = {
397502     let pmt = value(i.payments[0])
398503     let pmtAmount = pmt.amount
399504     if ((pmt.assetId != ltcUsdnLP))
420525                         }
421526                     else throw("Strict value is not equal to itself.")
422527                 }
423-    }
424-
425-
426-
427-@Callable(i)
428-func withdraw () = {
429-    let payment = value(i.payments[0])
430-    let am = payment.amount
431-    let id = payment.assetId
432-    if (isStopped)
433-        then throw("smart contract is on lock")
434-        else if ((size(i.payments) != 1))
435-            then throw("1 pmnt expd")
436-            else if ((id == usdtUsdnLPTCI))
437-                then {
438-                    let TCIAmount =                     match assetInfo(usdtUsdnLPTCI) {
439-                        case q: Asset => 
440-                            q.quantity
441-                        case _ => 
442-                            0
443-                    }
444-                    let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
445-                    let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
446-                    let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
447-                    let fee = fraction(usdnLpToWithdraw, def, feePerc)
448-                    let unstakeUsdtUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf", usdnLpToWithdraw], nil)
449-                    if ((unstakeUsdtUsdnLP == unstakeUsdtUsdnLP))
450-                        then {
451-                            let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
452-                            let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
453-                            let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
454-                            let brn = Burn(usdtUsdnLPTCI, am)
455-[usdnLpfeeTransfer, transfer, updateUsdnLpStaked, brn]
456-                            }
457-                        else throw("Strict value is not equal to itself.")
458-                    }
459-                else if ((id == wxUsdnLPTCI))
460-                    then {
461-                        let wxTciAm =                         match assetInfo(wxUsdnLPTCI) {
462-                            case q: Asset => 
463-                                q.quantity
464-                            case _ => 
465-                                0
466-                        }
467-                        let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
468-                        let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
469-                        let wxLpToWithdraw = fraction(singleWXLP, am, def)
470-                        let fee = fraction(wxLpToWithdraw, def, feePerc)
471-                        let unstakeWxUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9", wxLpToWithdraw], nil)
472-                        if ((unstakeWxUsdnLP == unstakeWxUsdnLP))
473-                            then {
474-                                let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
475-                                let wxLpTransfer = ScriptTransfer(i.caller, (wxLpToWithdraw - fee), wxUsdnLP)
476-                                let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
477-                                let burnWxLpTci = Burn(wxUsdnLPTCI, am)
478-[wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked, burnWxLpTci]
479-                                }
480-                            else throw("Strict value is not equal to itself.")
481-                        }
482-                    else if ((id == usdcUsdnLPTCI))
483-                        then {
484-                            let usdcUsdnTCI =                             match assetInfo(usdcUsdnLPTCI) {
485-                                case q: Asset => 
486-                                    q.quantity
487-                                case _ => 
488-                                    0
489-                            }
490-                            let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
491-                            let singleUsdcLP = fraction(usdcUsdnStaked, def, usdcUsdnTCI)
492-                            let usdcUsdnLpToWithdraw = fraction(singleUsdcLP, am, def)
493-                            let fee = fraction(usdcUsdnLpToWithdraw, def, feePerc)
494-                            let unstakeUsdcUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5", usdcUsdnLpToWithdraw], nil)
495-                            if ((unstakeUsdcUsdnLP == unstakeUsdcUsdnLP))
496-                                then {
497-                                    let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
498-                                    let usdcUsdnTransfer = ScriptTransfer(i.caller, (usdcUsdnLpToWithdraw - fee), usdcUsdnLP)
499-                                    let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcUsdnLpToWithdraw))
500-                                    let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
501-[usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked, burnUsdcUsdnLpTci]
502-                                    }
503-                                else throw("Strict value is not equal to itself.")
504-                            }
505-                        else if ((id == usdcUsdtLPTCI))
506-                            then {
507-                                let usdcUsdtTci =                                 match assetInfo(usdcUsdtLPTCI) {
508-                                    case q: Asset => 
509-                                        q.quantity
510-                                    case _ => 
511-                                        0
512-                                }
513-                                let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
514-                                let singleUsdcUsdt = fraction(usdcUsdtStaked, def, usdcUsdtTci)
515-                                let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
516-                                let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
517-                                let unstakeUsdcUsdtLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH", usdcUsdtLpToWithdraw], nil)
518-                                if ((unstakeUsdcUsdtLP == unstakeUsdcUsdtLP))
519-                                    then {
520-                                        let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
521-                                        let usdcUsdtTransfer = ScriptTransfer(i.caller, (usdcUsdtLpToWithdraw - fee), usdcUsdtLP)
522-                                        let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
523-                                        let burnUsdcUsdtLpTci = Burn(usdcUsdtLPTCI, am)
524-[usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked, burnUsdcUsdtLpTci]
525-                                        }
526-                                    else throw("Strict value is not equal to itself.")
527-                                }
528-                            else if ((id == puzzleUsdnLPTCI))
529-                                then {
530-                                    let puzzleUsdnTci =                                     match assetInfo(puzzleUsdnLPTCI) {
531-                                        case q: Asset => 
532-                                            q.quantity
533-                                        case _ => 
534-                                            0
535-                                    }
536-                                    let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
537-                                    let singlePuzzleUsdn = fraction(puzzleLPStaked, def, puzzleUsdnTci)
538-                                    let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
539-                                    let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
540-                                    let unstakePuzzleUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP", puzzleUsdnWithdraw], nil)
541-                                    if ((unstakePuzzleUsdnLP == unstakePuzzleUsdnLP))
542-                                        then {
543-                                            let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
544-                                            let puzzleUsdnTransfer = ScriptTransfer(i.caller, (puzzleUsdnWithdraw - fee), puzzleUsdnLP)
545-                                            let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
546-                                            let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
547-[puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked, burnPuzzleTCI]
548-                                            }
549-                                        else throw("Strict value is not equal to itself.")
550-                                    }
551-                                else if ((id == btcUsdnLPTCI))
552-                                    then {
553-                                        let btcUsdnTCI =                                         match assetInfo(btcUsdnLPTCI) {
554-                                            case q: Asset => 
555-                                                q.quantity
556-                                            case _ => 
557-                                                0
558-                                        }
559-                                        let btcUsdnStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
560-                                        let singleBtcUsdn = fraction(btcUsdnStaked, def, btcUsdnTCI)
561-                                        let btcUsdnWithdraw = fraction(singleBtcUsdn, am, def)
562-                                        let fee = fraction(btcUsdnWithdraw, def, feePerc)
563-                                        let unstakeBtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy", btcUsdnWithdraw], nil)
564-                                        if ((unstakeBtcUsdn == unstakeBtcUsdn))
565-                                            then {
566-                                                let btcUsdnLPFee = ScriptTransfer(Address(tw), fee, btcUsdnLP)
567-                                                let btcUsdnTransfer = ScriptTransfer(i.caller, (btcUsdnWithdraw - fee), btcUsdnLP)
568-                                                let updateBtcUsdnLPStaked = IntegerEntry(keyBTCUSDN, (btcUsdnStaked - btcUsdnWithdraw))
569-                                                let burnBtcUsdnTci = Burn(btcUsdnLPTCI, am)
570-[btcUsdnLPFee, btcUsdnTransfer, updateBtcUsdnLPStaked, burnBtcUsdnTci]
571-                                                }
572-                                            else throw("Strict value is not equal to itself.")
573-                                        }
574-                                    else if ((id == wavesUsdnLPTCI))
575-                                        then {
576-                                            let wavesUsdnTCI =                                             match assetInfo(wavesUsdnLPTCI) {
577-                                                case q: Asset => 
578-                                                    q.quantity
579-                                                case _ => 
580-                                                    0
581-                                            }
582-                                            let wavesUsdnStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
583-                                            let singleWavesUsdn = fraction(wavesUsdnStaked, def, wavesUsdnTCI)
584-                                            let wavesUsdnWithdraw = fraction(singleWavesUsdn, am, def)
585-                                            let fee = fraction(wavesUsdnWithdraw, def, feePerc)
586-                                            let unstakeWavesUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1", wavesUsdnWithdraw], nil)
587-                                            if ((unstakeWavesUsdn == unstakeWavesUsdn))
588-                                                then {
589-                                                    let wavesUsndFee = ScriptTransfer(Address(tw), fee, wavesUsdnLP)
590-                                                    let wavesUsdnTransfer = ScriptTransfer(i.caller, (wavesUsdnWithdraw - fee), wavesUsdnLP)
591-                                                    let updateWavesUsdnLPStaked = IntegerEntry(keyWAVESUSDN, (wavesUsdnStaked - wavesUsdnWithdraw))
592-                                                    let burnWavesUsdnTCI = Burn(wavesUsdnLPTCI, am)
593-[wavesUsndFee, wavesUsdnTransfer, updateWavesUsdnLPStaked, burnWavesUsdnTCI]
594-                                                    }
595-                                                else throw("Strict value is not equal to itself.")
596-                                            }
597-                                        else if ((id == ennoUsdnLPTCI))
598-                                            then {
599-                                                let ennoUsdnTCI =                                                 match assetInfo(ennoUsdnLPTCI) {
600-                                                    case q: Asset => 
601-                                                        q.quantity
602-                                                    case _ => 
603-                                                        0
604-                                                }
605-                                                let ennoUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
606-                                                let singleEnnoUsdn = fraction(ennoUsdnStaked, def, ennoUsdnTCI)
607-                                                let ennoUsdnWithdraw = fraction(singleEnnoUsdn, am, def)
608-                                                let fee = fraction(ennoUsdnWithdraw, def, feePerc)
609-                                                let unstakeEnnoUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX", ennoUsdnWithdraw], nil)
610-                                                if ((unstakeEnnoUsdn == unstakeEnnoUsdn))
611-                                                    then {
612-                                                        let ennoUsdnFee = ScriptTransfer(Address(tw), fee, ennoUsdnLP)
613-                                                        let ennoUsdnTransfer = ScriptTransfer(i.caller, (ennoUsdnWithdraw - fee), ennoUsdnLP)
614-                                                        let updateEnnoUsdnLPStaked = IntegerEntry(keyENNOUSDN, (ennoUsdnStaked - ennoUsdnWithdraw))
615-                                                        let burnEnnoUsdnTCI = Burn(ennoUsdnLPTCI, am)
616-[ennoUsdnFee, ennoUsdnTransfer, updateEnnoUsdnLPStaked, burnEnnoUsdnTCI]
617-                                                        }
618-                                                    else throw("Strict value is not equal to itself.")
619-                                                }
620-                                            else if ((id == nsbtUsdnLPTCI))
621-                                                then {
622-                                                    let nsbtUsdnTCI =                                                     match assetInfo(nsbtUsdnLPTCI) {
623-                                                        case q: Asset => 
624-                                                            q.quantity
625-                                                        case _ => 
626-                                                            0
627-                                                    }
628-                                                    let nsbtUsdnStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
629-                                                    let singleNsbtUsdn = fraction(nsbtUsdnStaked, def, nsbtUsdnTCI)
630-                                                    let nsbtUsdnWithdraw = fraction(singleNsbtUsdn, am, def)
631-                                                    let fee = fraction(nsbtUsdnWithdraw, def, feePerc)
632-                                                    let unstakeNsbtUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5", nsbtUsdnWithdraw], nil)
633-                                                    if ((unstakeNsbtUsdn == unstakeNsbtUsdn))
634-                                                        then {
635-                                                            let nsbtUsdnFee = ScriptTransfer(Address(tw), fee, nsbtUsdnLP)
636-                                                            let nsbtUsdnTransfer = ScriptTransfer(i.caller, (nsbtUsdnWithdraw - fee), nsbtUsdnLP)
637-                                                            let updateNsbtUsdnStaked = IntegerEntry(keyNSBTUSDN, (nsbtUsdnStaked - nsbtUsdnWithdraw))
638-                                                            let burnNsbtUsdnTCI = Burn(nsbtUsdnLPTCI, am)
639-[nsbtUsdnFee, nsbtUsdnTransfer, updateNsbtUsdnStaked, burnNsbtUsdnTCI]
640-                                                            }
641-                                                        else throw("Strict value is not equal to itself.")
642-                                                    }
643-                                                else if ((id == ltcUsdnLPTCI))
644-                                                    then {
645-                                                        let ltcUsdnTCI =                                                         match assetInfo(ltcUsdnLPTCI) {
646-                                                            case q: Asset => 
647-                                                                q.quantity
648-                                                            case _ => 
649-                                                                0
650-                                                        }
651-                                                        let ltcUsdnStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
652-                                                        let singleLtcUsdn = fraction(ltcUsdnStaked, def, ltcUsdnTCI)
653-                                                        let ltcUsdnWithdraw = fraction(singleLtcUsdn, am, def)
654-                                                        let fee = fraction(ltcUsdnWithdraw, def, feePerc)
655-                                                        let unstakeLtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv", ltcUsdnWithdraw], nil)
656-                                                        if ((unstakeLtcUsdn == unstakeLtcUsdn))
657-                                                            then {
658-                                                                let ltcUsdnFee = ScriptTransfer(Address(tw), fee, ltcUsdnLP)
659-                                                                let ltcUsdnTransfer = ScriptTransfer(i.caller, (ltcUsdnWithdraw - fee), ltcUsdnLP)
660-                                                                let updateLtcUsdnStaked = IntegerEntry(keyLTCUSDN, (ltcUsdnStaked - ltcUsdnWithdraw))
661-                                                                let burnLtcUsdnTCI = Burn(ltcUsdnLPTCI, am)
662-[ltcUsdnFee, ltcUsdnTransfer, updateLtcUsdnStaked, burnLtcUsdnTCI]
663-                                                                }
664-                                                            else throw("Strict value is not equal to itself.")
665-                                                        }
666-                                                    else throw("Invalid asset")
667528     }
668529 
669530 
769630 
770631 
771632 @Callable(i)
772-func compoundPuzzleUsdnLP () = {
633+func compountPuzzleUsdnLP () = {
773634     let compound = value(i.payments[0])
774635     let ca = compound.amount
775636     let isOracle = checkAddress(i.caller.bytes)
919780 
920781 
921782 @Callable(i)
922-func sponsorBoost () = {
783+func initNSBTUSDN () = {
923784     let pm = value(i.payments[0])
924-    let lockPeriod = 100
925-    if ((pm.assetId != wxId))
926-        then throw("Error")
785+    let am = pm.amount
786+    if ((pm.assetId != nsbtUsdnLP))
787+        then throw("Unexpected token")
927788         else {
928-            let sponsored = valueOrElse(getInteger(this, keySponsorship), 0)
929-            let lock = invoke(Address(base58'3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP'), "increaseLock", [lockPeriod], [pm])
930-            if ((lock == lock))
789+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
790+            if ((s == s))
931791                 then {
932-                    let s = IntegerEntry(keySponsorship, (pm.amount + sponsored))
933-[s]
792+                    let upd = IntegerEntry(keyNSBTUSDN, am)
793+                    let updK = IntegerEntry(keyNsbtUsdnCompound, 0)
794+[upd, updK]
934795                     }
935796                 else throw("Strict value is not equal to itself.")
936797             }
798+    }
799+
800+
801+
802+@Callable(i)
803+func initBTCUSDN () = {
804+    let pm = value(i.payments[0])
805+    let am = pm.amount
806+    if ((pm.assetId != btcUsdnLP))
807+        then throw("Unexpected token")
808+        else {
809+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
810+            if ((s == s))
811+                then {
812+                    let upd = IntegerEntry(keyBTCUSDN, am)
813+                    let updK = IntegerEntry(keyBtcUsdnCompound, 0)
814+[upd, updK]
815+                    }
816+                else throw("Strict value is not equal to itself.")
817+            }
818+    }
819+
820+
821+
822+@Callable(i)
823+func initENNOUSDN () = {
824+    let pm = value(i.payments[0])
825+    let am = pm.amount
826+    if ((pm.assetId != ennoUsdnLP))
827+        then throw("Unexpected token")
828+        else {
829+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
830+            if ((s == s))
831+                then {
832+                    let upd = IntegerEntry(keyENNOUSDN, am)
833+                    let updK = IntegerEntry(keyEnnoUsdnCompound, 0)
834+[upd, updK]
835+                    }
836+                else throw("Strict value is not equal to itself.")
837+            }
838+    }
839+
840+
841+
842+@Callable(i)
843+func initWAVESUSDN () = {
844+    let pm = value(i.payments[0])
845+    let am = pm.amount
846+    if ((pm.assetId != wavesUsdnLP))
847+        then throw("Unexpected token")
848+        else {
849+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
850+            if ((s == s))
851+                then {
852+                    let upd = IntegerEntry(keyWAVESUSDN, am)
853+                    let updK = IntegerEntry(keyWavesUsdnCompound, 0)
854+[upd, updK]
855+                    }
856+                else throw("Strict value is not equal to itself.")
857+            }
858+    }
859+
860+
861+
862+@Callable(i)
863+func initLTCUSDN () = {
864+    let pm = value(i.payments[0])
865+    let am = pm.amount
866+    if ((pm.assetId != ltcUsdnLP))
867+        then throw("Unexpected token")
868+        else {
869+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
870+            if ((s == s))
871+                then {
872+                    let upd = IntegerEntry(keyLTCUSDN, am)
873+                    let updK = IntegerEntry(keyLtcUsdnCompound, 0)
874+[upd, updK]
875+                    }
876+                else throw("Strict value is not equal to itself.")
877+            }
878+    }
879+
880+
881+
882+@Callable(i)
883+func withdraw () = {
884+    let payment = value(i.payments[0])
885+    let am = payment.amount
886+    let id = payment.assetId
887+    if ((size(i.payments) != 1))
888+        then throw("1 pmnt expd")
889+        else if ((id == usdtUsdnLPTCI))
890+            then {
891+                let TCIAmount =                 match assetInfo(usdtUsdnLPTCI) {
892+                    case q: Asset => 
893+                        q.quantity
894+                    case _ => 
895+                        0
896+                }
897+                let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
898+                let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
899+                let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
900+                let fee = fraction(usdnLpToWithdraw, def, feePerc)
901+                let unstakeUsdtUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf", usdnLpToWithdraw], nil)
902+                if ((unstakeUsdtUsdnLP == unstakeUsdtUsdnLP))
903+                    then {
904+                        let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
905+                        let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
906+                        let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
907+                        let brn = Burn(usdtUsdnLPTCI, am)
908+[usdnLpfeeTransfer, transfer, updateUsdnLpStaked, brn]
909+                        }
910+                    else throw("Strict value is not equal to itself.")
911+                }
912+            else if ((id == wxUsdnLPTCI))
913+                then {
914+                    let wxTciAm =                     match assetInfo(wxUsdnLPTCI) {
915+                        case q: Asset => 
916+                            q.quantity
917+                        case _ => 
918+                            0
919+                    }
920+                    let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
921+                    let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
922+                    let wxLpToWithdraw = fraction(singleWXLP, am, def)
923+                    let fee = fraction(wxLpToWithdraw, def, feePerc)
924+                    let unstakeWxUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9", wxLpToWithdraw], nil)
925+                    if ((unstakeWxUsdnLP == unstakeWxUsdnLP))
926+                        then {
927+                            let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
928+                            let wxLpTransfer = ScriptTransfer(i.caller, (wxLpToWithdraw - fee), wxUsdnLP)
929+                            let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
930+                            let burnWxLpTci = Burn(wxUsdnLPTCI, am)
931+[wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked, burnWxLpTci]
932+                            }
933+                        else throw("Strict value is not equal to itself.")
934+                    }
935+                else if ((id == usdcUsdnLPTCI))
936+                    then {
937+                        let usdcUsdnTCI =                         match assetInfo(usdcUsdnLPTCI) {
938+                            case q: Asset => 
939+                                q.quantity
940+                            case _ => 
941+                                0
942+                        }
943+                        let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
944+                        let singleUsdcLP = fraction(usdcUsdnStaked, def, usdcUsdnTCI)
945+                        let usdcUsdnLpToWithdraw = fraction(singleUsdcLP, am, def)
946+                        let fee = fraction(usdcUsdnLpToWithdraw, def, feePerc)
947+                        let unstakeUsdcUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5", usdcUsdnLpToWithdraw], nil)
948+                        if ((unstakeUsdcUsdnLP == unstakeUsdcUsdnLP))
949+                            then {
950+                                let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
951+                                let usdcUsdnTransfer = ScriptTransfer(i.caller, (usdcUsdnLpToWithdraw - fee), usdcUsdnLP)
952+                                let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcUsdnLpToWithdraw))
953+                                let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
954+[usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked, burnUsdcUsdnLpTci]
955+                                }
956+                            else throw("Strict value is not equal to itself.")
957+                        }
958+                    else if ((id == usdcUsdtLPTCI))
959+                        then {
960+                            let usdcUsdtTci =                             match assetInfo(usdcUsdtLPTCI) {
961+                                case q: Asset => 
962+                                    q.quantity
963+                                case _ => 
964+                                    0
965+                            }
966+                            let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
967+                            let singleUsdcUsdt = fraction(usdcUsdtStaked, def, usdcUsdtTci)
968+                            let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
969+                            let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
970+                            let unstakeUsdcUsdtLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH", usdcUsdtLpToWithdraw], nil)
971+                            if ((unstakeUsdcUsdtLP == unstakeUsdcUsdtLP))
972+                                then {
973+                                    let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
974+                                    let usdcUsdtTransfer = ScriptTransfer(i.caller, (usdcUsdtLpToWithdraw - fee), usdcUsdtLP)
975+                                    let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
976+                                    let burnUsdcUsdtLpTci = Burn(usdcUsdtLPTCI, am)
977+[usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked, burnUsdcUsdtLpTci]
978+                                    }
979+                                else throw("Strict value is not equal to itself.")
980+                            }
981+                        else if ((id == puzzleUsdnLPTCI))
982+                            then {
983+                                let puzzleUsdnTci =                                 match assetInfo(puzzleUsdnLPTCI) {
984+                                    case q: Asset => 
985+                                        q.quantity
986+                                    case _ => 
987+                                        0
988+                                }
989+                                let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
990+                                let singlePuzzleUsdn = fraction(puzzleLPStaked, def, puzzleUsdnTci)
991+                                let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
992+                                let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
993+                                let unstakePuzzleUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP", puzzleUsdnWithdraw], nil)
994+                                if ((unstakePuzzleUsdnLP == unstakePuzzleUsdnLP))
995+                                    then {
996+                                        let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
997+                                        let puzzleUsdnTransfer = ScriptTransfer(i.caller, (puzzleUsdnWithdraw - fee), puzzleUsdnLP)
998+                                        let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
999+                                        let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
1000+[puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked, burnPuzzleTCI]
1001+                                        }
1002+                                    else throw("Strict value is not equal to itself.")
1003+                                }
1004+                            else if ((id == btcUsdnLPTCI))
1005+                                then {
1006+                                    let btcUsdnTCI =                                     match assetInfo(btcUsdnLPTCI) {
1007+                                        case q: Asset => 
1008+                                            q.quantity
1009+                                        case _ => 
1010+                                            0
1011+                                    }
1012+                                    let btcUsdnStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
1013+                                    let singleBtcUsdn = fraction(btcUsdnStaked, def, btcUsdnTCI)
1014+                                    let btcUsdnWithdraw = fraction(singleBtcUsdn, am, def)
1015+                                    let fee = fraction(btcUsdnWithdraw, def, feePerc)
1016+                                    let unstakeBtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy", btcUsdnWithdraw], nil)
1017+                                    if ((unstakeBtcUsdn == unstakeBtcUsdn))
1018+                                        then {
1019+                                            let btcUsdnLPFee = ScriptTransfer(Address(tw), fee, btcUsdnLP)
1020+                                            let btcUsdnTransfer = ScriptTransfer(i.caller, (btcUsdnWithdraw - fee), btcUsdnLP)
1021+                                            let updateBtcUsdnLPStaked = IntegerEntry(keyBTCUSDN, (btcUsdnStaked - btcUsdnWithdraw))
1022+                                            let burnBtcUsdnTci = Burn(btcUsdnLPTCI, am)
1023+[btcUsdnLPFee, btcUsdnTransfer, updateBtcUsdnLPStaked, burnBtcUsdnTci]
1024+                                            }
1025+                                        else throw("Strict value is not equal to itself.")
1026+                                    }
1027+                                else if ((id == wavesUsdnLPTCI))
1028+                                    then {
1029+                                        let wavesUsdnTCI =                                         match assetInfo(wavesUsdnLPTCI) {
1030+                                            case q: Asset => 
1031+                                                q.quantity
1032+                                            case _ => 
1033+                                                0
1034+                                        }
1035+                                        let wavesUsdnStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
1036+                                        let singleWavesUsdn = fraction(wavesUsdnStaked, def, wavesUsdnTCI)
1037+                                        let wavesUsdnWithdraw = fraction(singleWavesUsdn, am, def)
1038+                                        let fee = fraction(wavesUsdnWithdraw, def, feePerc)
1039+                                        let unstakeWavesUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1", wavesUsdnWithdraw], nil)
1040+                                        if ((unstakeWavesUsdn == unstakeWavesUsdn))
1041+                                            then {
1042+                                                let wavesUsndFee = ScriptTransfer(Address(tw), fee, wavesUsdnLP)
1043+                                                let wavesUsdnTransfer = ScriptTransfer(i.caller, (wavesUsdnWithdraw - fee), wavesUsdnLP)
1044+                                                let updateWavesUsdnLPStaked = IntegerEntry(keyWAVESUSDN, (wavesUsdnStaked - wavesUsdnWithdraw))
1045+                                                let burnWavesUsdnTCI = Burn(wavesUsdnLPTCI, am)
1046+[wavesUsndFee, wavesUsdnTransfer, updateWavesUsdnLPStaked, burnWavesUsdnTCI]
1047+                                                }
1048+                                            else throw("Strict value is not equal to itself.")
1049+                                        }
1050+                                    else if ((id == ennoUsdnLPTCI))
1051+                                        then {
1052+                                            let ennoUsdnTCI =                                             match assetInfo(ennoUsdnLPTCI) {
1053+                                                case q: Asset => 
1054+                                                    q.quantity
1055+                                                case _ => 
1056+                                                    0
1057+                                            }
1058+                                            let ennoUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
1059+                                            let singleEnnoUsdn = fraction(ennoUsdnStaked, def, ennoUsdnTCI)
1060+                                            let ennoUsdnWithdraw = fraction(singleEnnoUsdn, am, def)
1061+                                            let fee = fraction(ennoUsdnWithdraw, def, feePerc)
1062+                                            let unstakeEnnoUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX", ennoUsdnWithdraw], nil)
1063+                                            if ((unstakeEnnoUsdn == unstakeEnnoUsdn))
1064+                                                then {
1065+                                                    let ennoUsdnFee = ScriptTransfer(Address(tw), fee, ennoUsdnLP)
1066+                                                    let ennoUsdnTransfer = ScriptTransfer(i.caller, (ennoUsdnWithdraw - fee), ennoUsdnLP)
1067+                                                    let updateEnnoUsdnLPStaked = IntegerEntry(keyENNOUSDN, (ennoUsdnStaked - ennoUsdnWithdraw))
1068+                                                    let burnEnnoUsdnTCI = Burn(ennoUsdnLPTCI, am)
1069+[ennoUsdnFee, ennoUsdnTransfer, updateEnnoUsdnLPStaked, burnEnnoUsdnTCI]
1070+                                                    }
1071+                                                else throw("Strict value is not equal to itself.")
1072+                                            }
1073+                                        else if ((id == nsbtUsdnLPTCI))
1074+                                            then {
1075+                                                let nsbtUsdnTCI =                                                 match assetInfo(nsbtUsdnLPTCI) {
1076+                                                    case q: Asset => 
1077+                                                        q.quantity
1078+                                                    case _ => 
1079+                                                        0
1080+                                                }
1081+                                                let nsbtUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
1082+                                                let singleNsbtUsdn = fraction(nsbtUsdnStaked, def, nsbtUsdnTCI)
1083+                                                let nsbtUsdnWithdraw = fraction(singleNsbtUsdn, am, def)
1084+                                                let fee = fraction(nsbtUsdnWithdraw, def, feePerc)
1085+                                                let unstakeNsbtUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5", nsbtUsdnWithdraw], nil)
1086+                                                if ((unstakeNsbtUsdn == unstakeNsbtUsdn))
1087+                                                    then {
1088+                                                        let nsbtUsdnFee = ScriptTransfer(Address(tw), fee, nsbtUsdnLP)
1089+                                                        let nsbtUsdnTransfer = ScriptTransfer(i.caller, (nsbtUsdnWithdraw - fee), nsbtUsdnLP)
1090+                                                        let updateNsbtUsdnStaked = IntegerEntry(keyNSBTUSDN, (nsbtUsdnStaked - nsbtUsdnWithdraw))
1091+                                                        let burnNsbtUsdnTCI = Burn(nsbtUsdnLPTCI, am)
1092+[nsbtUsdnFee, nsbtUsdnTransfer, updateNsbtUsdnStaked, burnNsbtUsdnTCI]
1093+                                                        }
1094+                                                    else throw("Strict value is not equal to itself.")
1095+                                                }
1096+                                            else if ((id == ltcUsdnLPTCI))
1097+                                                then {
1098+                                                    let ltcUsdnTCI =                                                     match assetInfo(ltcUsdnLPTCI) {
1099+                                                        case q: Asset => 
1100+                                                            q.quantity
1101+                                                        case _ => 
1102+                                                            0
1103+                                                    }
1104+                                                    let ltcUsdnStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
1105+                                                    let singleLtcUsdn = fraction(ltcUsdnStaked, def, ltcUsdnTCI)
1106+                                                    let ltcUsdnWithdraw = fraction(singleLtcUsdn, am, def)
1107+                                                    let fee = fraction(ltcUsdnWithdraw, def, feePerc)
1108+                                                    let unstakeLtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv", ltcUsdnWithdraw], nil)
1109+                                                    if ((unstakeLtcUsdn == unstakeLtcUsdn))
1110+                                                        then {
1111+                                                            let ltcUsdnFee = ScriptTransfer(Address(tw), fee, ltcUsdnLP)
1112+                                                            let ltcUsdnTransfer = ScriptTransfer(i.caller, (ltcUsdnWithdraw - fee), ltcUsdnLP)
1113+                                                            let updateLtcUsdnStaked = IntegerEntry(keyLTCUSDN, (ltcUsdnStaked - ltcUsdnWithdraw))
1114+                                                            let burnLtcUsdnTCI = Burn(ltcUsdnLPTCI, am)
1115+[ltcUsdnFee, ltcUsdnTransfer, updateLtcUsdnStaked, burnLtcUsdnTCI]
1116+                                                            }
1117+                                                        else throw("Strict value is not equal to itself.")
1118+                                                    }
1119+                                                else throw("Invalid asset")
9371120     }
9381121 
9391122 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4+let multi8 = 100000000
5+
6+let multi10 = 10000000000
7+
48 let usdtUsdnLP = base58'97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf'
59 
610 let usdtUsdnLPTCI = base58'2CD44HANZzsdU7yqRsmz7L9eA2Foh4YYMC4azMbaZEj6'
711 
812 let wxUsdnLP = base58'F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9'
913 
1014 let wxUsdnLPTCI = base58'FuUobp3DcfARzDLcvtVW37i7FvMPvCCpgdcvWke8sBuh'
1115 
1216 let usdcUsdnLP = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
1317 
1418 let usdcUsdnLPTCI = base58'HZKFpNfyPG5gt4D6Nfy1zQSg2Ptmqv932GjNTCyBEeKP'
1519 
1620 let usdcUsdtLP = base58'EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH'
1721 
1822 let usdcUsdtLPTCI = base58'BqPYkaiz7Le6fFu1rjZ54anrpT57EpvyugZCUqrsjXj'
1923 
2024 let puzzleUsdnLP = base58'E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP'
2125 
2226 let puzzleUsdnLPTCI = base58'Dh9QXSSABE5V6aRfu3mCbDAUokbpE7ER7pbZV6cvyg1A'
2327 
2428 let nsbtUsdnLP = base58'AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5'
2529 
2630 let nsbtUsdnLPTCI = base58'3hty6p21a9M4t9greh13nydX84bvaPyXDhKZ2FSmLNRg'
2731 
2832 let btcUsdnLP = base58'8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy'
2933 
3034 let btcUsdnLPTCI = base58'FpRckcTCzfsfXwWhQCrL5rcrStRB6HxmRjP28qVFz4iu'
3135 
3236 let ennoUsdnLP = base58'HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX'
3337 
3438 let ennoUsdnLPTCI = base58'57kEMQuVpmhsG9eCkcGRA3hTsZZGa6axKJfNwXEU4EM1'
3539 
3640 let wavesUsdnLP = base58'7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1'
3741 
3842 let wavesUsdnLPTCI = base58'EHia7oPmBSJyTd3Uix8sdpEvFXB9X18ioqreXiTaKyVJ'
3943 
4044 let ltcUsdnLP = base58'CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv'
4145 
4246 let ltcUsdnLPTCI = base58'HgD36mcgHVF5beAQi6rPtatg4gVmMckvPExFR3jEDydW'
4347 
4448 let isStopped = false
4549 
4650 let keyStaked = "STAKED_LP"
4751 
4852 let keyCompound = "From_Compound"
4953 
5054 let keywxUsdnCompound = "WX_USDN_compound"
5155 
5256 let keyWXUSDN = "WX_USDN"
5357 
5458 let keyUsdcUsdnCompound = "USDC_USDN_compound"
5559 
5660 let keyUSDCUSDN = "USDC_USDN"
5761 
5862 let keyUsdcUsdtCompound = "USDC_USDT_compound"
5963 
6064 let keyUSDCUSDT = "USDC_USDT"
6165 
6266 let keyPuzzleUsdnCompound = "PUZZLE_USDN_compound"
6367 
6468 let keyPUZZLEUSDN = "PUZZLE_USDN"
6569 
6670 let keyNsbtUsdnCompound = "NSBT_USDN_compound"
6771 
6872 let keyNSBTUSDN = "NSBT_USDN"
6973 
7074 let keyBTCUSDN = "BTC_USDN"
7175 
7276 let keyBtcUsdnCompound = "BTC_USDN_Compound"
7377 
7478 let keyENNOUSDN = "ENNO_USDN"
7579 
7680 let keyEnnoUsdnCompound = "ENNO_USDN_Compound"
7781 
7882 let keyWAVESUSDN = "WAVES_USDN"
7983 
8084 let keyWavesUsdnCompound = "WAVES_USDN_Compound"
8185 
8286 let keyLTCUSDN = "LTC_USDN"
8387 
8488 let keyLtcUsdnCompound = "LTC_USDN_Compound"
8589 
86-let wxId = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
87-
88-let keySponsorship = "Sponsorship_in_lock"
89-
9090 let def = 100000000
9191 
9292 let feePerc = 10000000000
9393 
9494 let tw = base58'3P93R2GBkTGVehRPhytHr7sdxYww93jkbhm'
9595 
9696 let oracle = base58'3P6phwFZFQtZFuc9dvdXsgvtg8JEFVgECPA'
9797 
9898 func checkAddress (caller) = if ((caller != oracle))
9999     then false
100100     else true
101+
102+
103+func getTciId (id) = if ((id == usdcUsdnLP))
104+    then usdcUsdnLPTCI
105+    else if ((id == wxUsdnLP))
106+        then wxUsdnLPTCI
107+        else if ((id == usdcUsdnLP))
108+            then usdcUsdnLPTCI
109+            else if ((id == usdcUsdtLP))
110+                then usdcUsdtLPTCI
111+                else if ((id == puzzleUsdnLP))
112+                    then puzzleUsdnLPTCI
113+                    else throw("invalid asset")
114+
115+
116+func getKeyStaked (tciId) = if ((tciId == usdtUsdnLPTCI))
117+    then keyStaked
118+    else if ((tciId == wxUsdnLPTCI))
119+        then keyWXUSDN
120+        else if ((tciId == usdcUsdnLPTCI))
121+            then keyUSDCUSDN
122+            else if ((tciId == usdcUsdtLPTCI))
123+                then keyUSDCUSDT
124+                else if ((tciId == puzzleUsdnLPTCI))
125+                    then keyPUZZLEUSDN
126+                    else throw("Key does not exist")
127+
128+
129+func encodeId (tciId) = if ((tciId == usdtUsdnLPTCI))
130+    then toBase58String(usdtUsdnLP)
131+    else if ((tciId == wxUsdnLPTCI))
132+        then toBase58String(wxUsdnLP)
133+        else if ((tciId == usdcUsdnLPTCI))
134+            then toBase58String(usdcUsdnLP)
135+            else if ((tciId == usdcUsdtLPTCI))
136+                then toBase58String(usdcUsdtLP)
137+                else if ((tciId == puzzleUsdnLPTCI))
138+                    then toBase58String(puzzleUsdnLP)
139+                    else throw("Key does not exist")
140+
141+
142+@Callable(i)
143+func deposit2 () = if ((i.caller != Address(oracle)))
144+    then throw("callable for oracle only")
145+    else {
146+        let assetId = i.payments[0].assetId
147+        let pmtAmount = value(i.payments[0]).amount
148+        let tciId = getTciId(assetId)
149+        let key = getKeyStaked(tciId)
150+        let stakedTokens = valueOrElse(getInteger(this, key), 0)
151+        let tciIssued =         match assetInfo(tciId) {
152+            case asset: Asset => 
153+                asset.quantity
154+            case _ => 
155+                throw("Can't find asset")
156+        }
157+        let fee = fraction(pmtAmount, multi8, multi10)
158+        let userDepositBalance = (pmtAmount - fee)
159+        let forOneTci = fraction(tciIssued, multi8, stakedTokens)
160+        let amountToIssue = fraction(userDepositBalance, forOneTci, multi8)
161+        let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [AttachedPayment(assetId, userDepositBalance)])
162+        if ((LPstake == LPstake))
163+            then {
164+                let updateState = IntegerEntry(key, (stakedTokens + userDepositBalance))
165+                let issueTCI = Reissue(tciId, amountToIssue, true)
166+                let transferTCI = ScriptTransfer(i.caller, amountToIssue, tciId)
167+                let collectFee = ScriptTransfer(Address(tw), fee, assetId)
168+[updateState, issueTCI, transferTCI, collectFee]
169+                }
170+            else throw("Strict value is not equal to itself.")
171+        }
172+
173+
174+
175+@Callable(i)
176+func withdraw2 () = if ((i.caller != Address(oracle)))
177+    then throw("callable for oracle only")
178+    else {
179+        let tciId = i.payments[0].assetId
180+        let pmtAmount = value(i.payments[0]).amount
181+        let lpIdUstake = encodeId(tciId)
182+        let dataKey = getKeyStaked(tciId)
183+        let tciIssued =         match assetInfo(getTciId(tciId)) {
184+            case asset: Asset => 
185+                asset.quantity
186+            case _ => 
187+                throw("Can't find asset")
188+        }
189+        let lpStaked = valueOrElse(getInteger(this, dataKey), 0)
190+        let tciPrice = fraction(lpStaked, multi8, tciIssued)
191+        let fee = fraction(pmtAmount, multi8, multi10)
192+        let userWithdrawAmount = (pmtAmount - fee)
193+        let lpToUnstake = (userWithdrawAmount * tciPrice)
194+        let unstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", [lpIdUstake, lpToUnstake], nil)
195+        if ((unstake == unstake))
196+            then {
197+                let burnTci = Burn(getTciId(tciId), userWithdrawAmount)
198+                let transferFee = ScriptTransfer(Address(tw), fee, tciId)
199+                let transferUserLP = ScriptTransfer(i.caller, lpToUnstake, fromBase58String(lpIdUstake))
200+                let updateState = IntegerEntry(dataKey, (lpStaked - lpToUnstake))
201+[burnTci, transferFee, transferUserLP, updateState]
202+                }
203+            else throw("Strict value is not equal to itself.")
204+        }
205+
101206 
102207 
103208 @Callable(i)
104209 func depositWxUsdnLP () = {
105210     let pmt = value(i.payments[0])
106211     let pmtAmount = pmt.amount
107212     if ((pmt.assetId != wxUsdnLP))
108213         then throw("attach WXUSDNLP tokens only")
109214         else if (isStopped)
110215             then throw("smart contract is on lock")
111216             else {
112217                 let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
113218                 let totalIssued =                 match assetInfo(wxUsdnLPTCI) {
114219                     case asset: Asset => 
115220                         asset.quantity
116221                     case _ => 
117222                         throw("Can't find asset")
118223                 }
119224                 let one = fraction(totalIssued, 100000000, tkStaked)
120225                 let toIssue = fraction(pmtAmount, one, 100000000)
121226                 let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
122227                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
123228                 if ((LPstake == LPstake))
124229                     then {
125230                         let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
126231                         let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
127232 [LPIssue, transfer, updateState]
128233                         }
129234                     else throw("Strict value is not equal to itself.")
130235                 }
131236     }
132237 
133238 
134239 
135240 @Callable(i)
136241 func depositUsdtUsdnLP () = {
137242     let pmt = value(i.payments[0])
138243     let pmtAmount = pmt.amount
139244     if ((pmt.assetId != usdtUsdnLP))
140245         then throw("attach USDTUSDNLP tokens only")
141246         else if (isStopped)
142247             then throw("smart contract is on lock")
143248             else {
144249                 let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
145250                 let totalIssued =                 match assetInfo(usdtUsdnLPTCI) {
146251                     case asset: Asset => 
147252                         asset.quantity
148253                     case _ => 
149254                         throw("Can't find asset")
150255                 }
151256                 let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
152257                 let forOne = fraction(totalIssued, 100000000, tkStaked)
153258                 let toIssue = fraction(pmtAmount, forOne, 100000000)
154259                 let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
155260                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
156261                 if ((LPstake == LPstake))
157262                     then {
158263                         let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
159264                         let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
160265 [LPIssue, transfer, updateState]
161266                         }
162267                     else throw("Strict value is not equal to itself.")
163268                 }
164269     }
165270 
166271 
167272 
168273 @Callable(i)
169274 func depositUsdcUsdnLP () = {
170275     let pmt = value(i.payments[0])
171276     let pmtAmount = pmt.amount
172277     if ((pmt.assetId != usdcUsdnLP))
173278         then throw("attach USDCUSDNLP tokens only")
174279         else if (isStopped)
175280             then throw("smart contract is on lock")
176281             else {
177282                 let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
178283                 let totalIssued =                 match assetInfo(usdcUsdnLPTCI) {
179284                     case asset: Asset => 
180285                         asset.quantity
181286                     case _ => 
182287                         throw("Can't find asset")
183288                 }
184289                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
185290                 let forOne = fraction(totalIssued, 100000000, tkStaked)
186291                 let toIssue = fraction(pmtAmount, forOne, 100000000)
187292                 let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
188293                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
189294                 if ((LPstake == LPstake))
190295                     then {
191296                         let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
192297                         let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
193298 [LPIssue, transfer, updateState]
194299                         }
195300                     else throw("Strict value is not equal to itself.")
196301                 }
197302     }
198303 
199304 
200305 
201306 @Callable(i)
202307 func depositUsdcUsdtLP () = {
203308     let pmt = value(i.payments[0])
204309     let pmtAmount = pmt.amount
205310     if ((pmt.assetId != usdcUsdtLP))
206311         then throw("attach USDCUSDTLP tokens only")
207312         else if (isStopped)
208313             then throw("smart contract is on lock")
209314             else {
210315                 let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
211316                 let totalIssued =                 match assetInfo(usdcUsdtLPTCI) {
212317                     case asset: Asset => 
213318                         asset.quantity
214319                     case _ => 
215320                         throw("Can't find asset")
216321                 }
217322                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
218323                 let forOne = fraction(totalIssued, 100000000, tkStaked)
219324                 let toIssue = fraction(pmtAmount, forOne, 100000000)
220325                 let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
221326                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
222327                 if ((LPstake == LPstake))
223328                     then {
224329                         let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
225330                         let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
226331 [LPIssue, transfer, updateState]
227332                         }
228333                     else throw("Strict value is not equal to itself.")
229334                 }
230335     }
231336 
232337 
233338 
234339 @Callable(i)
235340 func depositPuzzleUsdnLP () = {
236341     let pmt = value(i.payments[0])
237342     let pmtAmount = pmt.amount
238343     if ((pmt.assetId != puzzleUsdnLP))
239344         then throw("attach PUZZLEUDSNLP tokens only")
240345         else if (isStopped)
241346             then throw("smart contract is on lock")
242347             else {
243348                 let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
244349                 let totalIssued =                 match assetInfo(puzzleUsdnLPTCI) {
245350                     case asset: Asset => 
246351                         asset.quantity
247352                     case _ => 
248353                         throw("Can't find asset")
249354                 }
250355                 let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
251356                 let forOne = fraction(totalIssued, 100000000, tkStaked)
252357                 let toIssue = fraction(pmtAmount, forOne, 100000000)
253358                 let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
254359                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
255360                 if ((LPstake == LPstake))
256361                     then {
257362                         let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
258363                         let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
259364 [LPIssue, transfer, updateState]
260365                         }
261366                     else throw("Strict value is not equal to itself.")
262367                 }
263368     }
264369 
265370 
266371 
267372 @Callable(i)
268373 func depositNsbtUsdnLP () = {
269374     let pmt = value(i.payments[0])
270375     let pmtAmount = pmt.amount
271376     if ((pmt.assetId != nsbtUsdnLP))
272377         then throw("attach NSBTUSDNLP tokens only")
273378         else if (isStopped)
274379             then throw("smart contract is on lock")
275380             else {
276381                 let tkStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
277382                 let totalIssued =                 match assetInfo(nsbtUsdnLPTCI) {
278383                     case asset: Asset => 
279384                         asset.quantity
280385                     case _ => 
281386                         throw("Can't find asset")
282387                 }
283388                 let one = fraction(totalIssued, 100000000, tkStaked)
284389                 let toIssue = fraction(pmtAmount, one, 100000000)
285390                 let updateState = IntegerEntry(keyNSBTUSDN, (tkStaked + pmtAmount))
286391                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
287392                 if ((LPstake == LPstake))
288393                     then {
289394                         let LPIssue = Reissue(nsbtUsdnLPTCI, toIssue, true)
290395                         let transfer = ScriptTransfer(i.caller, toIssue, nsbtUsdnLPTCI)
291396 [LPIssue, transfer, updateState]
292397                         }
293398                     else throw("Strict value is not equal to itself.")
294399                 }
295400     }
296401 
297402 
298403 
299404 @Callable(i)
300405 func depositBtcUsdnLP () = {
301406     let pmt = value(i.payments[0])
302407     let pmtAmount = pmt.amount
303408     if ((pmt.assetId != btcUsdnLP))
304409         then throw("attach BTCUSDNLP tokens only")
305410         else if (isStopped)
306411             then throw("smart contract is on lock")
307412             else {
308413                 let tkStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
309414                 let totalIssued =                 match assetInfo(btcUsdnLPTCI) {
310415                     case asset: Asset => 
311416                         asset.quantity
312417                     case _ => 
313418                         throw("Can't find asset")
314419                 }
315420                 let forOne = fraction(totalIssued, 100000000, tkStaked)
316421                 let toIssue = fraction(pmtAmount, forOne, 100000000)
317422                 let updateState = IntegerEntry(keyBTCUSDN, (tkStaked + pmtAmount))
318423                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
319424                 if ((LPstake == LPstake))
320425                     then {
321426                         let LPIssue = Reissue(btcUsdnLPTCI, toIssue, true)
322427                         let transfer = ScriptTransfer(i.caller, toIssue, btcUsdnLPTCI)
323428 [LPIssue, transfer, updateState]
324429                         }
325430                     else throw("Strict value is not equal to itself.")
326431                 }
327432     }
328433 
329434 
330435 
331436 @Callable(i)
332437 func depositEnnoUsdnLP () = {
333438     let pmt = value(i.payments[0])
334439     let pmtAmount = pmt.amount
335440     if ((pmt.assetId != ennoUsdnLP))
336441         then throw("attach ENNOUSDNLP tokens only")
337442         else if (isStopped)
338443             then throw("smart contract is on lock")
339444             else {
340445                 let tkStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
341446                 let totalIssued =                 match assetInfo(ennoUsdnLPTCI) {
342447                     case asset: Asset => 
343448                         asset.quantity
344449                     case _ => 
345450                         throw("Can't find asset")
346451                 }
347452                 let one = fraction(totalIssued, 100000000, tkStaked)
348453                 let toIssue = fraction(pmtAmount, one, 100000000)
349454                 let updateState = IntegerEntry(keyENNOUSDN, (tkStaked + pmtAmount))
350455                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
351456                 if ((LPstake == LPstake))
352457                     then {
353458                         let LPIssue = Reissue(ennoUsdnLPTCI, toIssue, true)
354459                         let transfer = ScriptTransfer(i.caller, toIssue, ennoUsdnLPTCI)
355460 [LPIssue, transfer, updateState]
356461                         }
357462                     else throw("Strict value is not equal to itself.")
358463                 }
359464     }
360465 
361466 
362467 
363468 @Callable(i)
364469 func depositWavesUsdnLP () = {
365470     let pmt = value(i.payments[0])
366471     let pmtAmount = pmt.amount
367472     if ((pmt.assetId != wavesUsdnLP))
368473         then throw("attach WAVESUSDNLP tokens only")
369474         else if (isStopped)
370475             then throw("smart contract is on lock")
371476             else {
372477                 let tkStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
373478                 let totalIssued =                 match assetInfo(wavesUsdnLPTCI) {
374479                     case asset: Asset => 
375480                         asset.quantity
376481                     case _ => 
377482                         throw("Can't find asset")
378483                 }
379484                 let one = fraction(totalIssued, 100000000, tkStaked)
380485                 let toIssue = fraction(pmtAmount, one, 100000000)
381486                 let updateState = IntegerEntry(keyWAVESUSDN, (tkStaked + pmtAmount))
382487                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
383488                 if ((LPstake == LPstake))
384489                     then {
385490                         let LPIssue = Reissue(wavesUsdnLPTCI, toIssue, true)
386491                         let transfer = ScriptTransfer(i.caller, toIssue, wavesUsdnLPTCI)
387492 [LPIssue, transfer, updateState]
388493                         }
389494                     else throw("Strict value is not equal to itself.")
390495                 }
391496     }
392497 
393498 
394499 
395500 @Callable(i)
396-func depositLtcUsdnLP () = {
501+func depositLTCUSDNLP () = {
397502     let pmt = value(i.payments[0])
398503     let pmtAmount = pmt.amount
399504     if ((pmt.assetId != ltcUsdnLP))
400505         then throw("attach LTCUSDNLP tokens only")
401506         else if (isStopped)
402507             then throw("smart contract is on lock")
403508             else {
404509                 let tkStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
405510                 let totalIssued =                 match assetInfo(ltcUsdnLPTCI) {
406511                     case asset: Asset => 
407512                         asset.quantity
408513                     case _ => 
409514                         throw("Can't find asset")
410515                 }
411516                 let one = fraction(totalIssued, 100000000, tkStaked)
412517                 let toIssue = fraction(pmtAmount, one, 100000000)
413518                 let updateState = IntegerEntry(keyLTCUSDN, (tkStaked + pmtAmount))
414519                 let LPstake = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [pmt])
415520                 if ((LPstake == LPstake))
416521                     then {
417522                         let LPIssue = Reissue(ltcUsdnLPTCI, toIssue, true)
418523                         let transfer = ScriptTransfer(i.caller, toIssue, ltcUsdnLPTCI)
419524 [LPIssue, transfer, updateState]
420525                         }
421526                     else throw("Strict value is not equal to itself.")
422527                 }
423-    }
424-
425-
426-
427-@Callable(i)
428-func withdraw () = {
429-    let payment = value(i.payments[0])
430-    let am = payment.amount
431-    let id = payment.assetId
432-    if (isStopped)
433-        then throw("smart contract is on lock")
434-        else if ((size(i.payments) != 1))
435-            then throw("1 pmnt expd")
436-            else if ((id == usdtUsdnLPTCI))
437-                then {
438-                    let TCIAmount =                     match assetInfo(usdtUsdnLPTCI) {
439-                        case q: Asset => 
440-                            q.quantity
441-                        case _ => 
442-                            0
443-                    }
444-                    let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
445-                    let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
446-                    let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
447-                    let fee = fraction(usdnLpToWithdraw, def, feePerc)
448-                    let unstakeUsdtUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf", usdnLpToWithdraw], nil)
449-                    if ((unstakeUsdtUsdnLP == unstakeUsdtUsdnLP))
450-                        then {
451-                            let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
452-                            let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
453-                            let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
454-                            let brn = Burn(usdtUsdnLPTCI, am)
455-[usdnLpfeeTransfer, transfer, updateUsdnLpStaked, brn]
456-                            }
457-                        else throw("Strict value is not equal to itself.")
458-                    }
459-                else if ((id == wxUsdnLPTCI))
460-                    then {
461-                        let wxTciAm =                         match assetInfo(wxUsdnLPTCI) {
462-                            case q: Asset => 
463-                                q.quantity
464-                            case _ => 
465-                                0
466-                        }
467-                        let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
468-                        let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
469-                        let wxLpToWithdraw = fraction(singleWXLP, am, def)
470-                        let fee = fraction(wxLpToWithdraw, def, feePerc)
471-                        let unstakeWxUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9", wxLpToWithdraw], nil)
472-                        if ((unstakeWxUsdnLP == unstakeWxUsdnLP))
473-                            then {
474-                                let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
475-                                let wxLpTransfer = ScriptTransfer(i.caller, (wxLpToWithdraw - fee), wxUsdnLP)
476-                                let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
477-                                let burnWxLpTci = Burn(wxUsdnLPTCI, am)
478-[wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked, burnWxLpTci]
479-                                }
480-                            else throw("Strict value is not equal to itself.")
481-                        }
482-                    else if ((id == usdcUsdnLPTCI))
483-                        then {
484-                            let usdcUsdnTCI =                             match assetInfo(usdcUsdnLPTCI) {
485-                                case q: Asset => 
486-                                    q.quantity
487-                                case _ => 
488-                                    0
489-                            }
490-                            let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
491-                            let singleUsdcLP = fraction(usdcUsdnStaked, def, usdcUsdnTCI)
492-                            let usdcUsdnLpToWithdraw = fraction(singleUsdcLP, am, def)
493-                            let fee = fraction(usdcUsdnLpToWithdraw, def, feePerc)
494-                            let unstakeUsdcUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5", usdcUsdnLpToWithdraw], nil)
495-                            if ((unstakeUsdcUsdnLP == unstakeUsdcUsdnLP))
496-                                then {
497-                                    let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
498-                                    let usdcUsdnTransfer = ScriptTransfer(i.caller, (usdcUsdnLpToWithdraw - fee), usdcUsdnLP)
499-                                    let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcUsdnLpToWithdraw))
500-                                    let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
501-[usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked, burnUsdcUsdnLpTci]
502-                                    }
503-                                else throw("Strict value is not equal to itself.")
504-                            }
505-                        else if ((id == usdcUsdtLPTCI))
506-                            then {
507-                                let usdcUsdtTci =                                 match assetInfo(usdcUsdtLPTCI) {
508-                                    case q: Asset => 
509-                                        q.quantity
510-                                    case _ => 
511-                                        0
512-                                }
513-                                let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
514-                                let singleUsdcUsdt = fraction(usdcUsdtStaked, def, usdcUsdtTci)
515-                                let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
516-                                let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
517-                                let unstakeUsdcUsdtLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH", usdcUsdtLpToWithdraw], nil)
518-                                if ((unstakeUsdcUsdtLP == unstakeUsdcUsdtLP))
519-                                    then {
520-                                        let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
521-                                        let usdcUsdtTransfer = ScriptTransfer(i.caller, (usdcUsdtLpToWithdraw - fee), usdcUsdtLP)
522-                                        let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
523-                                        let burnUsdcUsdtLpTci = Burn(usdcUsdtLPTCI, am)
524-[usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked, burnUsdcUsdtLpTci]
525-                                        }
526-                                    else throw("Strict value is not equal to itself.")
527-                                }
528-                            else if ((id == puzzleUsdnLPTCI))
529-                                then {
530-                                    let puzzleUsdnTci =                                     match assetInfo(puzzleUsdnLPTCI) {
531-                                        case q: Asset => 
532-                                            q.quantity
533-                                        case _ => 
534-                                            0
535-                                    }
536-                                    let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
537-                                    let singlePuzzleUsdn = fraction(puzzleLPStaked, def, puzzleUsdnTci)
538-                                    let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
539-                                    let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
540-                                    let unstakePuzzleUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP", puzzleUsdnWithdraw], nil)
541-                                    if ((unstakePuzzleUsdnLP == unstakePuzzleUsdnLP))
542-                                        then {
543-                                            let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
544-                                            let puzzleUsdnTransfer = ScriptTransfer(i.caller, (puzzleUsdnWithdraw - fee), puzzleUsdnLP)
545-                                            let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
546-                                            let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
547-[puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked, burnPuzzleTCI]
548-                                            }
549-                                        else throw("Strict value is not equal to itself.")
550-                                    }
551-                                else if ((id == btcUsdnLPTCI))
552-                                    then {
553-                                        let btcUsdnTCI =                                         match assetInfo(btcUsdnLPTCI) {
554-                                            case q: Asset => 
555-                                                q.quantity
556-                                            case _ => 
557-                                                0
558-                                        }
559-                                        let btcUsdnStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
560-                                        let singleBtcUsdn = fraction(btcUsdnStaked, def, btcUsdnTCI)
561-                                        let btcUsdnWithdraw = fraction(singleBtcUsdn, am, def)
562-                                        let fee = fraction(btcUsdnWithdraw, def, feePerc)
563-                                        let unstakeBtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy", btcUsdnWithdraw], nil)
564-                                        if ((unstakeBtcUsdn == unstakeBtcUsdn))
565-                                            then {
566-                                                let btcUsdnLPFee = ScriptTransfer(Address(tw), fee, btcUsdnLP)
567-                                                let btcUsdnTransfer = ScriptTransfer(i.caller, (btcUsdnWithdraw - fee), btcUsdnLP)
568-                                                let updateBtcUsdnLPStaked = IntegerEntry(keyBTCUSDN, (btcUsdnStaked - btcUsdnWithdraw))
569-                                                let burnBtcUsdnTci = Burn(btcUsdnLPTCI, am)
570-[btcUsdnLPFee, btcUsdnTransfer, updateBtcUsdnLPStaked, burnBtcUsdnTci]
571-                                                }
572-                                            else throw("Strict value is not equal to itself.")
573-                                        }
574-                                    else if ((id == wavesUsdnLPTCI))
575-                                        then {
576-                                            let wavesUsdnTCI =                                             match assetInfo(wavesUsdnLPTCI) {
577-                                                case q: Asset => 
578-                                                    q.quantity
579-                                                case _ => 
580-                                                    0
581-                                            }
582-                                            let wavesUsdnStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
583-                                            let singleWavesUsdn = fraction(wavesUsdnStaked, def, wavesUsdnTCI)
584-                                            let wavesUsdnWithdraw = fraction(singleWavesUsdn, am, def)
585-                                            let fee = fraction(wavesUsdnWithdraw, def, feePerc)
586-                                            let unstakeWavesUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1", wavesUsdnWithdraw], nil)
587-                                            if ((unstakeWavesUsdn == unstakeWavesUsdn))
588-                                                then {
589-                                                    let wavesUsndFee = ScriptTransfer(Address(tw), fee, wavesUsdnLP)
590-                                                    let wavesUsdnTransfer = ScriptTransfer(i.caller, (wavesUsdnWithdraw - fee), wavesUsdnLP)
591-                                                    let updateWavesUsdnLPStaked = IntegerEntry(keyWAVESUSDN, (wavesUsdnStaked - wavesUsdnWithdraw))
592-                                                    let burnWavesUsdnTCI = Burn(wavesUsdnLPTCI, am)
593-[wavesUsndFee, wavesUsdnTransfer, updateWavesUsdnLPStaked, burnWavesUsdnTCI]
594-                                                    }
595-                                                else throw("Strict value is not equal to itself.")
596-                                            }
597-                                        else if ((id == ennoUsdnLPTCI))
598-                                            then {
599-                                                let ennoUsdnTCI =                                                 match assetInfo(ennoUsdnLPTCI) {
600-                                                    case q: Asset => 
601-                                                        q.quantity
602-                                                    case _ => 
603-                                                        0
604-                                                }
605-                                                let ennoUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
606-                                                let singleEnnoUsdn = fraction(ennoUsdnStaked, def, ennoUsdnTCI)
607-                                                let ennoUsdnWithdraw = fraction(singleEnnoUsdn, am, def)
608-                                                let fee = fraction(ennoUsdnWithdraw, def, feePerc)
609-                                                let unstakeEnnoUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX", ennoUsdnWithdraw], nil)
610-                                                if ((unstakeEnnoUsdn == unstakeEnnoUsdn))
611-                                                    then {
612-                                                        let ennoUsdnFee = ScriptTransfer(Address(tw), fee, ennoUsdnLP)
613-                                                        let ennoUsdnTransfer = ScriptTransfer(i.caller, (ennoUsdnWithdraw - fee), ennoUsdnLP)
614-                                                        let updateEnnoUsdnLPStaked = IntegerEntry(keyENNOUSDN, (ennoUsdnStaked - ennoUsdnWithdraw))
615-                                                        let burnEnnoUsdnTCI = Burn(ennoUsdnLPTCI, am)
616-[ennoUsdnFee, ennoUsdnTransfer, updateEnnoUsdnLPStaked, burnEnnoUsdnTCI]
617-                                                        }
618-                                                    else throw("Strict value is not equal to itself.")
619-                                                }
620-                                            else if ((id == nsbtUsdnLPTCI))
621-                                                then {
622-                                                    let nsbtUsdnTCI =                                                     match assetInfo(nsbtUsdnLPTCI) {
623-                                                        case q: Asset => 
624-                                                            q.quantity
625-                                                        case _ => 
626-                                                            0
627-                                                    }
628-                                                    let nsbtUsdnStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
629-                                                    let singleNsbtUsdn = fraction(nsbtUsdnStaked, def, nsbtUsdnTCI)
630-                                                    let nsbtUsdnWithdraw = fraction(singleNsbtUsdn, am, def)
631-                                                    let fee = fraction(nsbtUsdnWithdraw, def, feePerc)
632-                                                    let unstakeNsbtUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5", nsbtUsdnWithdraw], nil)
633-                                                    if ((unstakeNsbtUsdn == unstakeNsbtUsdn))
634-                                                        then {
635-                                                            let nsbtUsdnFee = ScriptTransfer(Address(tw), fee, nsbtUsdnLP)
636-                                                            let nsbtUsdnTransfer = ScriptTransfer(i.caller, (nsbtUsdnWithdraw - fee), nsbtUsdnLP)
637-                                                            let updateNsbtUsdnStaked = IntegerEntry(keyNSBTUSDN, (nsbtUsdnStaked - nsbtUsdnWithdraw))
638-                                                            let burnNsbtUsdnTCI = Burn(nsbtUsdnLPTCI, am)
639-[nsbtUsdnFee, nsbtUsdnTransfer, updateNsbtUsdnStaked, burnNsbtUsdnTCI]
640-                                                            }
641-                                                        else throw("Strict value is not equal to itself.")
642-                                                    }
643-                                                else if ((id == ltcUsdnLPTCI))
644-                                                    then {
645-                                                        let ltcUsdnTCI =                                                         match assetInfo(ltcUsdnLPTCI) {
646-                                                            case q: Asset => 
647-                                                                q.quantity
648-                                                            case _ => 
649-                                                                0
650-                                                        }
651-                                                        let ltcUsdnStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
652-                                                        let singleLtcUsdn = fraction(ltcUsdnStaked, def, ltcUsdnTCI)
653-                                                        let ltcUsdnWithdraw = fraction(singleLtcUsdn, am, def)
654-                                                        let fee = fraction(ltcUsdnWithdraw, def, feePerc)
655-                                                        let unstakeLtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv", ltcUsdnWithdraw], nil)
656-                                                        if ((unstakeLtcUsdn == unstakeLtcUsdn))
657-                                                            then {
658-                                                                let ltcUsdnFee = ScriptTransfer(Address(tw), fee, ltcUsdnLP)
659-                                                                let ltcUsdnTransfer = ScriptTransfer(i.caller, (ltcUsdnWithdraw - fee), ltcUsdnLP)
660-                                                                let updateLtcUsdnStaked = IntegerEntry(keyLTCUSDN, (ltcUsdnStaked - ltcUsdnWithdraw))
661-                                                                let burnLtcUsdnTCI = Burn(ltcUsdnLPTCI, am)
662-[ltcUsdnFee, ltcUsdnTransfer, updateLtcUsdnStaked, burnLtcUsdnTCI]
663-                                                                }
664-                                                            else throw("Strict value is not equal to itself.")
665-                                                        }
666-                                                    else throw("Invalid asset")
667528     }
668529 
669530 
670531 
671532 @Callable(i)
672533 func compoundWxUsdnLP () = {
673534     let compound = value(i.payments[0])
674535     let ca = compound.amount
675536     let isOracle = checkAddress(i.caller.bytes)
676537     if ((compound.assetId != wxUsdnLP))
677538         then throw("attach WXUSDNLP tokens only")
678539         else if (!(isOracle))
679540             then throw("You are not authotized to call this function")
680541             else {
681542                 let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
682543                 let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
683544                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
684545                 if ((stakeC == stakeC))
685546                     then {
686547                         let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
687548                         let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
688549 [updateState, tc]
689550                         }
690551                     else throw("Strict value is not equal to itself.")
691552                 }
692553     }
693554 
694555 
695556 
696557 @Callable(i)
697558 func compoundUsdtUsdnLP () = {
698559     let compound = value(i.payments[0])
699560     let ca = compound.amount
700561     let isOracle = checkAddress(i.caller.bytes)
701562     if ((compound.assetId != usdtUsdnLP))
702563         then throw("attach USDTUSDNLP tokens only")
703564         else if (!(isOracle))
704565             then throw("You are not authotized to call this function")
705566             else {
706567                 let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
707568                 let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
708569                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
709570                 if ((stakeC == stakeC))
710571                     then {
711572                         let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
712573                         let tc = IntegerEntry(keyCompound, (fromCompound + ca))
713574 [updateState, tc]
714575                         }
715576                     else throw("Strict value is not equal to itself.")
716577                 }
717578     }
718579 
719580 
720581 
721582 @Callable(i)
722583 func compoundUsdcUsdnLP () = {
723584     let compound = value(i.payments[0])
724585     let ca = compound.amount
725586     let isOracle = checkAddress(i.caller.bytes)
726587     if ((compound.assetId != usdcUsdnLP))
727588         then throw("attach USDCUSDNLP tokens only")
728589         else if (!(isOracle))
729590             then throw("You are not authotized to call this function")
730591             else {
731592                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
732593                 let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
733594                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
734595                 if ((stakeC == stakeC))
735596                     then {
736597                         let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
737598                         let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
738599 [updateState, tc]
739600                         }
740601                     else throw("Strict value is not equal to itself.")
741602                 }
742603     }
743604 
744605 
745606 
746607 @Callable(i)
747608 func compoundUsdcUsdtLP () = {
748609     let compound = value(i.payments[0])
749610     let ca = compound.amount
750611     let isOracle = checkAddress(i.caller.bytes)
751612     if ((compound.assetId != usdcUsdtLP))
752613         then throw("attach USDCUSDTLP tokens only")
753614         else if (!(isOracle))
754615             then throw("You are not authotized to call this function")
755616             else {
756617                 let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
757618                 let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
758619                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
759620                 if ((stakeC == stakeC))
760621                     then {
761622                         let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
762623                         let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
763624 [updateState, tc]
764625                         }
765626                     else throw("Strict value is not equal to itself.")
766627                 }
767628     }
768629 
769630 
770631 
771632 @Callable(i)
772-func compoundPuzzleUsdnLP () = {
633+func compountPuzzleUsdnLP () = {
773634     let compound = value(i.payments[0])
774635     let ca = compound.amount
775636     let isOracle = checkAddress(i.caller.bytes)
776637     if ((compound.assetId != puzzleUsdnLP))
777638         then throw("attach PUZZLEUSDNLP tokens only")
778639         else if (!(isOracle))
779640             then throw("You are not authotized to call this function")
780641             else {
781642                 let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
782643                 let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
783644                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
784645                 if ((stakeC == stakeC))
785646                     then {
786647                         let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
787648                         let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
788649 [updateState, tc]
789650                         }
790651                     else throw("Strict value is not equal to itself.")
791652                 }
792653     }
793654 
794655 
795656 
796657 @Callable(i)
797658 func compoundNsbtUsdnLP () = {
798659     let compound = value(i.payments[0])
799660     let ca = compound.amount
800661     let isOracle = checkAddress(i.caller.bytes)
801662     if ((compound.assetId != nsbtUsdnLP))
802663         then throw("attach NSBTUSDNLP tokens only")
803664         else if (!(isOracle))
804665             then throw("You are not authotized to call this function")
805666             else {
806667                 let fromCompound = valueOrElse(getInteger(this, keyNsbtUsdnCompound), 0)
807668                 let totalStaked = valueOrElse(getInteger(this, keyNSBTUSDN), 0)
808669                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
809670                 if ((stakeC == stakeC))
810671                     then {
811672                         let updateState = IntegerEntry(keyNSBTUSDN, (totalStaked + ca))
812673                         let tc = IntegerEntry(keyNsbtUsdnCompound, (fromCompound + ca))
813674 [updateState, tc]
814675                         }
815676                     else throw("Strict value is not equal to itself.")
816677                 }
817678     }
818679 
819680 
820681 
821682 @Callable(i)
822683 func compoundBtcUsdnLP () = {
823684     let compound = value(i.payments[0])
824685     let ca = compound.amount
825686     let isOracle = checkAddress(i.caller.bytes)
826687     if ((compound.assetId != btcUsdnLP))
827688         then throw("attach BTCUSDNLP tokens only")
828689         else if (!(isOracle))
829690             then throw("You are not authotized to call this function")
830691             else {
831692                 let fromCompound = valueOrElse(getInteger(this, keyBtcUsdnCompound), 0)
832693                 let totalStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
833694                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
834695                 if ((stakeC == stakeC))
835696                     then {
836697                         let updateState = IntegerEntry(keyBTCUSDN, (totalStaked + ca))
837698                         let tc = IntegerEntry(keyBtcUsdnCompound, (fromCompound + ca))
838699 [updateState, tc]
839700                         }
840701                     else throw("Strict value is not equal to itself.")
841702                 }
842703     }
843704 
844705 
845706 
846707 @Callable(i)
847708 func compoundEnnoUsdnLP () = {
848709     let compound = value(i.payments[0])
849710     let ca = compound.amount
850711     let isOracle = checkAddress(i.caller.bytes)
851712     if ((compound.assetId != ennoUsdnLP))
852713         then throw("attach ENNOUSDNLP tokens only")
853714         else if (!(isOracle))
854715             then throw("You are not authotized to call this function")
855716             else {
856717                 let fromCompound = valueOrElse(getInteger(this, keyEnnoUsdnCompound), 0)
857718                 let totalStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
858719                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
859720                 if ((stakeC == stakeC))
860721                     then {
861722                         let updateState = IntegerEntry(keyENNOUSDN, (totalStaked + ca))
862723                         let tc = IntegerEntry(keyEnnoUsdnCompound, (fromCompound + ca))
863724 [updateState, tc]
864725                         }
865726                     else throw("Strict value is not equal to itself.")
866727                 }
867728     }
868729 
869730 
870731 
871732 @Callable(i)
872733 func compoundWavesUsdnLP () = {
873734     let compound = value(i.payments[0])
874735     let ca = compound.amount
875736     let isOracle = checkAddress(i.caller.bytes)
876737     if ((compound.assetId != wavesUsdnLP))
877738         then throw("attach WAVESUSDNLP tokens only")
878739         else if (!(isOracle))
879740             then throw("You are not authotized to call this function")
880741             else {
881742                 let fromCompound = valueOrElse(getInteger(this, keyWavesUsdnCompound), 0)
882743                 let totalStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
883744                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
884745                 if ((stakeC == stakeC))
885746                     then {
886747                         let updateState = IntegerEntry(keyWAVESUSDN, (totalStaked + ca))
887748                         let tc = IntegerEntry(keyWavesUsdnCompound, (fromCompound + ca))
888749 [updateState, tc]
889750                         }
890751                     else throw("Strict value is not equal to itself.")
891752                 }
892753     }
893754 
894755 
895756 
896757 @Callable(i)
897758 func compoundLtcUsdnLP () = {
898759     let compound = value(i.payments[0])
899760     let ca = compound.amount
900761     let isOracle = checkAddress(i.caller.bytes)
901762     if ((compound.assetId != ltcUsdnLP))
902763         then throw("attach LTCUSDNLP tokens only")
903764         else if (!(isOracle))
904765             then throw("You are not authotized to call this function")
905766             else {
906767                 let fromCompound = valueOrElse(getInteger(this, keyLtcUsdnCompound), 0)
907768                 let totalStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
908769                 let stakeC = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "stake", nil, [compound])
909770                 if ((stakeC == stakeC))
910771                     then {
911772                         let updateState = IntegerEntry(keyLTCUSDN, (totalStaked + ca))
912773                         let tc = IntegerEntry(keyLtcUsdnCompound, (fromCompound + ca))
913774 [updateState, tc]
914775                         }
915776                     else throw("Strict value is not equal to itself.")
916777                 }
917778     }
918779 
919780 
920781 
921782 @Callable(i)
922-func sponsorBoost () = {
783+func initNSBTUSDN () = {
923784     let pm = value(i.payments[0])
924-    let lockPeriod = 100
925-    if ((pm.assetId != wxId))
926-        then throw("Error")
785+    let am = pm.amount
786+    if ((pm.assetId != nsbtUsdnLP))
787+        then throw("Unexpected token")
927788         else {
928-            let sponsored = valueOrElse(getInteger(this, keySponsorship), 0)
929-            let lock = invoke(Address(base58'3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP'), "increaseLock", [lockPeriod], [pm])
930-            if ((lock == lock))
789+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
790+            if ((s == s))
931791                 then {
932-                    let s = IntegerEntry(keySponsorship, (pm.amount + sponsored))
933-[s]
792+                    let upd = IntegerEntry(keyNSBTUSDN, am)
793+                    let updK = IntegerEntry(keyNsbtUsdnCompound, 0)
794+[upd, updK]
934795                     }
935796                 else throw("Strict value is not equal to itself.")
936797             }
798+    }
799+
800+
801+
802+@Callable(i)
803+func initBTCUSDN () = {
804+    let pm = value(i.payments[0])
805+    let am = pm.amount
806+    if ((pm.assetId != btcUsdnLP))
807+        then throw("Unexpected token")
808+        else {
809+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
810+            if ((s == s))
811+                then {
812+                    let upd = IntegerEntry(keyBTCUSDN, am)
813+                    let updK = IntegerEntry(keyBtcUsdnCompound, 0)
814+[upd, updK]
815+                    }
816+                else throw("Strict value is not equal to itself.")
817+            }
818+    }
819+
820+
821+
822+@Callable(i)
823+func initENNOUSDN () = {
824+    let pm = value(i.payments[0])
825+    let am = pm.amount
826+    if ((pm.assetId != ennoUsdnLP))
827+        then throw("Unexpected token")
828+        else {
829+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
830+            if ((s == s))
831+                then {
832+                    let upd = IntegerEntry(keyENNOUSDN, am)
833+                    let updK = IntegerEntry(keyEnnoUsdnCompound, 0)
834+[upd, updK]
835+                    }
836+                else throw("Strict value is not equal to itself.")
837+            }
838+    }
839+
840+
841+
842+@Callable(i)
843+func initWAVESUSDN () = {
844+    let pm = value(i.payments[0])
845+    let am = pm.amount
846+    if ((pm.assetId != wavesUsdnLP))
847+        then throw("Unexpected token")
848+        else {
849+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
850+            if ((s == s))
851+                then {
852+                    let upd = IntegerEntry(keyWAVESUSDN, am)
853+                    let updK = IntegerEntry(keyWavesUsdnCompound, 0)
854+[upd, updK]
855+                    }
856+                else throw("Strict value is not equal to itself.")
857+            }
858+    }
859+
860+
861+
862+@Callable(i)
863+func initLTCUSDN () = {
864+    let pm = value(i.payments[0])
865+    let am = pm.amount
866+    if ((pm.assetId != ltcUsdnLP))
867+        then throw("Unexpected token")
868+        else {
869+            let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
870+            if ((s == s))
871+                then {
872+                    let upd = IntegerEntry(keyLTCUSDN, am)
873+                    let updK = IntegerEntry(keyLtcUsdnCompound, 0)
874+[upd, updK]
875+                    }
876+                else throw("Strict value is not equal to itself.")
877+            }
878+    }
879+
880+
881+
882+@Callable(i)
883+func withdraw () = {
884+    let payment = value(i.payments[0])
885+    let am = payment.amount
886+    let id = payment.assetId
887+    if ((size(i.payments) != 1))
888+        then throw("1 pmnt expd")
889+        else if ((id == usdtUsdnLPTCI))
890+            then {
891+                let TCIAmount =                 match assetInfo(usdtUsdnLPTCI) {
892+                    case q: Asset => 
893+                        q.quantity
894+                    case _ => 
895+                        0
896+                }
897+                let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
898+                let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
899+                let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
900+                let fee = fraction(usdnLpToWithdraw, def, feePerc)
901+                let unstakeUsdtUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["97zHFp1C3cB7qfvx8Xv5f2rWp9nUSG5UnAamfPcW6txf", usdnLpToWithdraw], nil)
902+                if ((unstakeUsdtUsdnLP == unstakeUsdtUsdnLP))
903+                    then {
904+                        let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
905+                        let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
906+                        let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
907+                        let brn = Burn(usdtUsdnLPTCI, am)
908+[usdnLpfeeTransfer, transfer, updateUsdnLpStaked, brn]
909+                        }
910+                    else throw("Strict value is not equal to itself.")
911+                }
912+            else if ((id == wxUsdnLPTCI))
913+                then {
914+                    let wxTciAm =                     match assetInfo(wxUsdnLPTCI) {
915+                        case q: Asset => 
916+                            q.quantity
917+                        case _ => 
918+                            0
919+                    }
920+                    let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
921+                    let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
922+                    let wxLpToWithdraw = fraction(singleWXLP, am, def)
923+                    let fee = fraction(wxLpToWithdraw, def, feePerc)
924+                    let unstakeWxUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["F2AKkA513k5yHEJkLsU6vWxCYYk811GpjLhwEv2WGwZ9", wxLpToWithdraw], nil)
925+                    if ((unstakeWxUsdnLP == unstakeWxUsdnLP))
926+                        then {
927+                            let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
928+                            let wxLpTransfer = ScriptTransfer(i.caller, (wxLpToWithdraw - fee), wxUsdnLP)
929+                            let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
930+                            let burnWxLpTci = Burn(wxUsdnLPTCI, am)
931+[wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked, burnWxLpTci]
932+                            }
933+                        else throw("Strict value is not equal to itself.")
934+                    }
935+                else if ((id == usdcUsdnLPTCI))
936+                    then {
937+                        let usdcUsdnTCI =                         match assetInfo(usdcUsdnLPTCI) {
938+                            case q: Asset => 
939+                                q.quantity
940+                            case _ => 
941+                                0
942+                        }
943+                        let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
944+                        let singleUsdcLP = fraction(usdcUsdnStaked, def, usdcUsdnTCI)
945+                        let usdcUsdnLpToWithdraw = fraction(singleUsdcLP, am, def)
946+                        let fee = fraction(usdcUsdnLpToWithdraw, def, feePerc)
947+                        let unstakeUsdcUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5", usdcUsdnLpToWithdraw], nil)
948+                        if ((unstakeUsdcUsdnLP == unstakeUsdcUsdnLP))
949+                            then {
950+                                let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
951+                                let usdcUsdnTransfer = ScriptTransfer(i.caller, (usdcUsdnLpToWithdraw - fee), usdcUsdnLP)
952+                                let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcUsdnLpToWithdraw))
953+                                let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
954+[usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked, burnUsdcUsdnLpTci]
955+                                }
956+                            else throw("Strict value is not equal to itself.")
957+                        }
958+                    else if ((id == usdcUsdtLPTCI))
959+                        then {
960+                            let usdcUsdtTci =                             match assetInfo(usdcUsdtLPTCI) {
961+                                case q: Asset => 
962+                                    q.quantity
963+                                case _ => 
964+                                    0
965+                            }
966+                            let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
967+                            let singleUsdcUsdt = fraction(usdcUsdtStaked, def, usdcUsdtTci)
968+                            let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
969+                            let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
970+                            let unstakeUsdcUsdtLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH", usdcUsdtLpToWithdraw], nil)
971+                            if ((unstakeUsdcUsdtLP == unstakeUsdcUsdtLP))
972+                                then {
973+                                    let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
974+                                    let usdcUsdtTransfer = ScriptTransfer(i.caller, (usdcUsdtLpToWithdraw - fee), usdcUsdtLP)
975+                                    let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
976+                                    let burnUsdcUsdtLpTci = Burn(usdcUsdtLPTCI, am)
977+[usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked, burnUsdcUsdtLpTci]
978+                                    }
979+                                else throw("Strict value is not equal to itself.")
980+                            }
981+                        else if ((id == puzzleUsdnLPTCI))
982+                            then {
983+                                let puzzleUsdnTci =                                 match assetInfo(puzzleUsdnLPTCI) {
984+                                    case q: Asset => 
985+                                        q.quantity
986+                                    case _ => 
987+                                        0
988+                                }
989+                                let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
990+                                let singlePuzzleUsdn = fraction(puzzleLPStaked, def, puzzleUsdnTci)
991+                                let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
992+                                let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
993+                                let unstakePuzzleUsdnLP = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP", puzzleUsdnWithdraw], nil)
994+                                if ((unstakePuzzleUsdnLP == unstakePuzzleUsdnLP))
995+                                    then {
996+                                        let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
997+                                        let puzzleUsdnTransfer = ScriptTransfer(i.caller, (puzzleUsdnWithdraw - fee), puzzleUsdnLP)
998+                                        let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
999+                                        let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
1000+[puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked, burnPuzzleTCI]
1001+                                        }
1002+                                    else throw("Strict value is not equal to itself.")
1003+                                }
1004+                            else if ((id == btcUsdnLPTCI))
1005+                                then {
1006+                                    let btcUsdnTCI =                                     match assetInfo(btcUsdnLPTCI) {
1007+                                        case q: Asset => 
1008+                                            q.quantity
1009+                                        case _ => 
1010+                                            0
1011+                                    }
1012+                                    let btcUsdnStaked = valueOrElse(getInteger(this, keyBTCUSDN), 0)
1013+                                    let singleBtcUsdn = fraction(btcUsdnStaked, def, btcUsdnTCI)
1014+                                    let btcUsdnWithdraw = fraction(singleBtcUsdn, am, def)
1015+                                    let fee = fraction(btcUsdnWithdraw, def, feePerc)
1016+                                    let unstakeBtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["8WhH5CCJ6NakPvEvAJcizqqD7H6axhupdYHDFumSDwsy", btcUsdnWithdraw], nil)
1017+                                    if ((unstakeBtcUsdn == unstakeBtcUsdn))
1018+                                        then {
1019+                                            let btcUsdnLPFee = ScriptTransfer(Address(tw), fee, btcUsdnLP)
1020+                                            let btcUsdnTransfer = ScriptTransfer(i.caller, (btcUsdnWithdraw - fee), btcUsdnLP)
1021+                                            let updateBtcUsdnLPStaked = IntegerEntry(keyBTCUSDN, (btcUsdnStaked - btcUsdnWithdraw))
1022+                                            let burnBtcUsdnTci = Burn(btcUsdnLPTCI, am)
1023+[btcUsdnLPFee, btcUsdnTransfer, updateBtcUsdnLPStaked, burnBtcUsdnTci]
1024+                                            }
1025+                                        else throw("Strict value is not equal to itself.")
1026+                                    }
1027+                                else if ((id == wavesUsdnLPTCI))
1028+                                    then {
1029+                                        let wavesUsdnTCI =                                         match assetInfo(wavesUsdnLPTCI) {
1030+                                            case q: Asset => 
1031+                                                q.quantity
1032+                                            case _ => 
1033+                                                0
1034+                                        }
1035+                                        let wavesUsdnStaked = valueOrElse(getInteger(this, keyWAVESUSDN), 0)
1036+                                        let singleWavesUsdn = fraction(wavesUsdnStaked, def, wavesUsdnTCI)
1037+                                        let wavesUsdnWithdraw = fraction(singleWavesUsdn, am, def)
1038+                                        let fee = fraction(wavesUsdnWithdraw, def, feePerc)
1039+                                        let unstakeWavesUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["7KZbJrVopwJhkdwbe1eFDBbex4dkY63MxjTNjqXtrzj1", wavesUsdnWithdraw], nil)
1040+                                        if ((unstakeWavesUsdn == unstakeWavesUsdn))
1041+                                            then {
1042+                                                let wavesUsndFee = ScriptTransfer(Address(tw), fee, wavesUsdnLP)
1043+                                                let wavesUsdnTransfer = ScriptTransfer(i.caller, (wavesUsdnWithdraw - fee), wavesUsdnLP)
1044+                                                let updateWavesUsdnLPStaked = IntegerEntry(keyWAVESUSDN, (wavesUsdnStaked - wavesUsdnWithdraw))
1045+                                                let burnWavesUsdnTCI = Burn(wavesUsdnLPTCI, am)
1046+[wavesUsndFee, wavesUsdnTransfer, updateWavesUsdnLPStaked, burnWavesUsdnTCI]
1047+                                                }
1048+                                            else throw("Strict value is not equal to itself.")
1049+                                        }
1050+                                    else if ((id == ennoUsdnLPTCI))
1051+                                        then {
1052+                                            let ennoUsdnTCI =                                             match assetInfo(ennoUsdnLPTCI) {
1053+                                                case q: Asset => 
1054+                                                    q.quantity
1055+                                                case _ => 
1056+                                                    0
1057+                                            }
1058+                                            let ennoUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
1059+                                            let singleEnnoUsdn = fraction(ennoUsdnStaked, def, ennoUsdnTCI)
1060+                                            let ennoUsdnWithdraw = fraction(singleEnnoUsdn, am, def)
1061+                                            let fee = fraction(ennoUsdnWithdraw, def, feePerc)
1062+                                            let unstakeEnnoUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["HnW33dcEaeUTcgMLd8vHoJR5iAFZ2ngHDAa9E9496kDX", ennoUsdnWithdraw], nil)
1063+                                            if ((unstakeEnnoUsdn == unstakeEnnoUsdn))
1064+                                                then {
1065+                                                    let ennoUsdnFee = ScriptTransfer(Address(tw), fee, ennoUsdnLP)
1066+                                                    let ennoUsdnTransfer = ScriptTransfer(i.caller, (ennoUsdnWithdraw - fee), ennoUsdnLP)
1067+                                                    let updateEnnoUsdnLPStaked = IntegerEntry(keyENNOUSDN, (ennoUsdnStaked - ennoUsdnWithdraw))
1068+                                                    let burnEnnoUsdnTCI = Burn(ennoUsdnLPTCI, am)
1069+[ennoUsdnFee, ennoUsdnTransfer, updateEnnoUsdnLPStaked, burnEnnoUsdnTCI]
1070+                                                    }
1071+                                                else throw("Strict value is not equal to itself.")
1072+                                            }
1073+                                        else if ((id == nsbtUsdnLPTCI))
1074+                                            then {
1075+                                                let nsbtUsdnTCI =                                                 match assetInfo(nsbtUsdnLPTCI) {
1076+                                                    case q: Asset => 
1077+                                                        q.quantity
1078+                                                    case _ => 
1079+                                                        0
1080+                                                }
1081+                                                let nsbtUsdnStaked = valueOrElse(getInteger(this, keyENNOUSDN), 0)
1082+                                                let singleNsbtUsdn = fraction(nsbtUsdnStaked, def, nsbtUsdnTCI)
1083+                                                let nsbtUsdnWithdraw = fraction(singleNsbtUsdn, am, def)
1084+                                                let fee = fraction(nsbtUsdnWithdraw, def, feePerc)
1085+                                                let unstakeNsbtUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["AGo49HCtQUghfxHSpUXub3KBaMXyunJmTxQ4azgU5Ax5", nsbtUsdnWithdraw], nil)
1086+                                                if ((unstakeNsbtUsdn == unstakeNsbtUsdn))
1087+                                                    then {
1088+                                                        let nsbtUsdnFee = ScriptTransfer(Address(tw), fee, nsbtUsdnLP)
1089+                                                        let nsbtUsdnTransfer = ScriptTransfer(i.caller, (nsbtUsdnWithdraw - fee), nsbtUsdnLP)
1090+                                                        let updateNsbtUsdnStaked = IntegerEntry(keyNSBTUSDN, (nsbtUsdnStaked - nsbtUsdnWithdraw))
1091+                                                        let burnNsbtUsdnTCI = Burn(nsbtUsdnLPTCI, am)
1092+[nsbtUsdnFee, nsbtUsdnTransfer, updateNsbtUsdnStaked, burnNsbtUsdnTCI]
1093+                                                        }
1094+                                                    else throw("Strict value is not equal to itself.")
1095+                                                }
1096+                                            else if ((id == ltcUsdnLPTCI))
1097+                                                then {
1098+                                                    let ltcUsdnTCI =                                                     match assetInfo(ltcUsdnLPTCI) {
1099+                                                        case q: Asset => 
1100+                                                            q.quantity
1101+                                                        case _ => 
1102+                                                            0
1103+                                                    }
1104+                                                    let ltcUsdnStaked = valueOrElse(getInteger(this, keyLTCUSDN), 0)
1105+                                                    let singleLtcUsdn = fraction(ltcUsdnStaked, def, ltcUsdnTCI)
1106+                                                    let ltcUsdnWithdraw = fraction(singleLtcUsdn, am, def)
1107+                                                    let fee = fraction(ltcUsdnWithdraw, def, feePerc)
1108+                                                    let unstakeLtcUsdn = invoke(Address(base58'3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV'), "unstake", ["CNkqC6GPi888WdJ1EuVtu9JGZ9VHpAn8eTHwR8YZxXbv", ltcUsdnWithdraw], nil)
1109+                                                    if ((unstakeLtcUsdn == unstakeLtcUsdn))
1110+                                                        then {
1111+                                                            let ltcUsdnFee = ScriptTransfer(Address(tw), fee, ltcUsdnLP)
1112+                                                            let ltcUsdnTransfer = ScriptTransfer(i.caller, (ltcUsdnWithdraw - fee), ltcUsdnLP)
1113+                                                            let updateLtcUsdnStaked = IntegerEntry(keyLTCUSDN, (ltcUsdnStaked - ltcUsdnWithdraw))
1114+                                                            let burnLtcUsdnTCI = Burn(ltcUsdnLPTCI, am)
1115+[ltcUsdnFee, ltcUsdnTransfer, updateLtcUsdnStaked, burnLtcUsdnTCI]
1116+                                                            }
1117+                                                        else throw("Strict value is not equal to itself.")
1118+                                                    }
1119+                                                else throw("Invalid asset")
9371120     }
9381121 
9391122 
9401123 @Verifier(tx)
9411124 func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
9421125 
github/deemru/w8io/3ef1775 
110.19 ms ◑