tx · EJyzmvU9wyzKFvUzVAr2ZNteMXwdKA3JepBmaqovpSBm

3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV:  -0.02900000 Waves

2023.01.13 12:52 [2403024] smart account 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EJyzmvU9wyzKFvUzVAr2ZNteMXwdKA3JepBmaqovpSBm",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1673603573026,
    "version": 1,
    "sender": "3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV",
    "senderPublicKey": "F4oaTkX67vt2MEsXLJJ8a7gaURGjW7x8fkvGfdEiH5oy",
    "proofs": [
        "gXUFMjLpsqjBKVEXZcmLfuqjxa7fguc4tNDu8WFDsfrMpxa1yKXaZXFRJVAcegXreQxTuyFk4RwNPWdY35hrGdV"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2403024,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 7BdaSHDCRUgc7XzSuat1P1rDJWjVzZCNdvVY9DkzqanA
Next: GRmwVoE47idkiEzX845B8XUnpK2vGHmmYvKx1CJ25ovy

Diff: 

OldNewDifferences
270270 
271271 
272272 @Callable(i)
273+func emit (assetId,amount) = {
274+    let checkCaller = mustThis(i)
275+    if ((checkCaller == checkCaller))
276+        then {
277+            let isReissuable = true
278+            $Tuple2([Reissue(assetId, amount, isReissuable)], amount)
279+            }
280+        else throw("Strict value is not equal to itself.")
281+    }
282+
283+
284+
285+@Callable(i)
286+func burn (assetId,amount) = {
287+    let checkCaller = mustThis(i)
288+    if ((checkCaller == checkCaller))
289+        then $Tuple2([Burn(assetId, amount)], amount)
290+        else throw("Strict value is not equal to itself.")
291+    }
292+
293+
294+
295+@Callable(i)
273296 func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
274297     let shareAssetLabel = "LP_STAKING_POOLS"
275298     let baseAssetId = parseAssetId(baseAssetIdStr)
324347         else throwErr("invalid asset")]
325348     if ((checks == checks))
326349         then {
327-            let $t01131211415 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
328-            let poolAddress = $t01131211415._1
329-            let lpAssetId = $t01131211415._2
350+            let $t01164611749 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
351+            let poolAddress = $t01164611749._1
352+            let lpAssetId = $t01164611749._2
330353             let period = value(getInteger(keyPeriod(baseAssetId)))
331354             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
332355             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
416439             if ((baseAssetId == baseAssetId))
417440                 then {
418441                     let userAddress = i.caller
419-                    let $t01511615219 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
420-                    let poolAddress = $t01511615219._1
421-                    let lpAssetId = $t01511615219._2
442+                    let $t01545015553 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443+                    let poolAddress = $t01545015553._1
444+                    let lpAssetId = $t01545015553._2
422445                     let period = value(getInteger(keyPeriod(baseAssetId)))
423446                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
424447                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
506529             let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
507530             if ((shareAssetId == shareAssetId))
508531                 then {
532+                    let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
509533                     let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
510534                     if ((period == period))
511535                         then {
521545                                     }
522546                             if ((checkDelay == checkDelay))
523547                                 then {
524-                                    let $t01916119342 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
525-                                    let poolAddress = $t01916119342._1
526-                                    let lpAssetId = $t01916119342._2
548+                                    let $t01959919780 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
549+                                    let poolAddress = $t01959919780._1
550+                                    let lpAssetId = $t01959919780._2
527551                                     let stakingReward = valueOrErrorMessage({
528552                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
529553                                         if ($isInstanceOf(@, "Int"))
628652                                                                                 }
629653                                                                             if ((baseAssetAmount == baseAssetAmount))
630654                                                                                 then {
631-                                                                                    let shareAssetBurnActions = [Burn(shareAssetId, shareAssetAmountToConvert)]
632-                                                                                    let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
633-                                                                                    let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
634-                                                                                    (shareAssetBurnActions ++ priceGetUpdateActions)
655+                                                                                    let shareAssetBurn = if ((shareAssetInfo.issuer == this))
656+                                                                                        then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
657+                                                                                        else if ((shareAssetInfo.issuer == lpStakingContract))
658+                                                                                            then invoke(lpStakingContract, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
659+                                                                                            else throwErr("invalid share asset issuer")
660+                                                                                    if ((shareAssetBurn == shareAssetBurn))
661+                                                                                        then {
662+                                                                                            let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
663+                                                                                            let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
664+                                                                                            priceGetUpdateActions
665+                                                                                            }
666+                                                                                        else throw("Strict value is not equal to itself.")
635667                                                                                     }
636668                                                                                 else throw("Strict value is not equal to itself.")
637669                                                                             }
638670                                                                         else throw("Strict value is not equal to itself.")
639671                                                                     }
640672                                                                 else nil
641-                                                            let putActions = if ((baseAssetAmountToConvert > 0))
673+                                                            if ((getActions == getActions))
642674                                                                 then {
643-                                                                    let lpAssetAmount = {
644-                                                                        let minOutAmount = 0
645-                                                                        let autoStake = true
646-                                                                        valueOrErrorMessage({
647-                                                                            let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
648-                                                                            if ($isInstanceOf(@, "Int"))
649-                                                                                then @
650-                                                                                else unit
651-                                                                            }, wrapErr("invalid putOneTknV2 result"))
652-                                                                        }
653-                                                                    if ((lpAssetAmount == lpAssetAmount))
675+                                                                    let putActions = if ((baseAssetAmountToConvert > 0))
654676                                                                         then {
655-                                                                            let price = calcPrice(lpAssetId, shareAssetId)
656-                                                                            if ((price == price))
677+                                                                            let lpAssetAmount = {
678+                                                                                let minOutAmount = 0
679+                                                                                let autoStake = true
680+                                                                                valueOrErrorMessage({
681+                                                                                    let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
682+                                                                                    if ($isInstanceOf(@, "Int"))
683+                                                                                        then @
684+                                                                                        else unit
685+                                                                                    }, wrapErr("invalid putOneTknV2 result"))
686+                                                                                }
687+                                                                            if ((lpAssetAmount == lpAssetAmount))
657688                                                                                 then {
658-                                                                                    let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
659-                                                                                    let isReissuable = true
660-                                                                                    let shareAssetReissueActions = [Reissue(shareAssetId, shareAssetAmount, isReissuable)]
661-                                                                                    let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
662-                                                                                    let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
663-                                                                                    (shareAssetReissueActions ++ pricePutUpdateActions)
689+                                                                                    let price = calcPrice(lpAssetId, shareAssetId)
690+                                                                                    if ((price == price))
691+                                                                                        then {
692+                                                                                            let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
693+                                                                                            let shareAssetReissue = if ((shareAssetInfo.issuer == this))
694+                                                                                                then invoke(this, "emit", [shareAssetId, shareAssetAmount], nil)
695+                                                                                                else if ((shareAssetInfo.issuer == lpStakingContract))
696+                                                                                                    then invoke(lpStakingContract, "emit", [shareAssetId, shareAssetAmount], nil)
697+                                                                                                    else throwErr("invalid share asset issuer")
698+                                                                                            if ((shareAssetReissue == shareAssetReissue))
699+                                                                                                then {
700+                                                                                                    let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
701+                                                                                                    let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
702+                                                                                                    pricePutUpdateActions
703+                                                                                                    }
704+                                                                                                else throw("Strict value is not equal to itself.")
705+                                                                                            }
706+                                                                                        else throw("Strict value is not equal to itself.")
664707                                                                                     }
665708                                                                                 else throw("Strict value is not equal to itself.")
666709                                                                             }
710+                                                                        else nil
711+                                                                    if ((putActions == putActions))
712+                                                                        then {
713+                                                                            let newPeriod = (period + 1)
714+                                                                            let lastPrice = calcPrice(lpAssetId, shareAssetId)
715+                                                                            let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(lastPrice)), StringEntry(keyPriceHistory(baseAssetId), toString(lastPrice))] ++ putActions) ++ getActions)
716+                                                                            $Tuple2(actions, toBytes(lastPrice))
717+                                                                            }
667718                                                                         else throw("Strict value is not equal to itself.")
668719                                                                     }
669-                                                                else nil
670-                                                            let newPeriod = (period + 1)
671-                                                            let lastPrice = calcPrice(lpAssetId, shareAssetId)
672-                                                            let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(lastPrice)), StringEntry(keyPriceHistory(baseAssetId), toString(lastPrice))] ++ putActions) ++ getActions)
673-                                                            $Tuple2(actions, toBytes(lastPrice))
720+                                                                else throw("Strict value is not equal to itself.")
674721                                                             }
675722                                                         else throw("Strict value is not equal to itself.")
676723                                                     }

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let separator = "__"
55 
66 let shareAssetDecimals = 8
77 
88 let wavesString = "WAVES"
99 
1010 let scale18 = 1000000000000000000
1111 
1212 let scale18BigInt = toBigInt(scale18)
1313 
1414 func wrapErr (msg) = makeString(["lp_staking_pools.ride:", msg], " ")
1515 
1616 
1717 func throwErr (msg) = throw(wrapErr(msg))
1818 
1919 
2020 func errKeyIsNotDefined (address,key) = wrapErr(makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
2121 
2222 
2323 func getStrOrFail (address,key) = valueOrErrorMessage(getString(address, key), errKeyIsNotDefined(address, key))
2424 
2525 
2626 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), errKeyIsNotDefined(address, key))
2727 
2828 
2929 func parseAssetId (input) = if ((input == wavesString))
3030     then unit
3131     else fromBase58String(input)
3232 
3333 
3434 func assetIdToString (input) = if ((input == unit))
3535     then wavesString
3636     else toBase58String(value(input))
3737 
3838 
3939 func ensurePositive (v) = if ((v >= 0))
4040     then v
4141     else throwErr("value should be positive")
4242 
4343 
4444 func keyFactoryContract () = makeString(["%s", "factoryContract"], separator)
4545 
4646 
4747 func keyLpStakingContract () = makeString(["%s", "lpStakingContract"], separator)
4848 
4949 
5050 func keyStakingContract () = makeString(["%s", "stakingContract"], separator)
5151 
5252 
5353 func keyBoostingContract () = makeString(["%s", "boostingContract"], separator)
5454 
5555 
5656 func keySwapContract () = makeString(["%s", "swapContract"], separator)
5757 
5858 
5959 func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], separator)
6060 
6161 
6262 func keyUsdnAssetId () = makeString(["%s", "usdnAssetId"], separator)
6363 
6464 
6565 func keyWxAssetId () = makeString(["%s", "wxAssetId"], separator)
6666 
6767 
6868 func keyShutdown () = makeString(["%s", "shutdown"], separator)
6969 
7070 
7171 func keyMinDelay () = makeString(["%s", "minDelay"], separator)
7272 
7373 
7474 func keyLockFraction () = makeString(["%s", "lockFraction"], separator)
7575 
7676 
7777 func keyShareAssetId (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetId"], separator)
7878 
7979 
8080 func keyBaseAssetId (shareAssetId) = makeString(["%s%s", assetIdToString(shareAssetId), "baseAssetId"], separator)
8181 
8282 
8383 func keyPeriod (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "period"], separator)
8484 
8585 
8686 func keyPeriodStartHeight (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "periodStartHeight", toString(period)], separator)
8787 
8888 
8989 func keyBaseAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "baseAssetAmountToConvert"], separator)
9090 
9191 
9292 func keyShareAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetAmountToConvert"], separator)
9393 
9494 
9595 func keyUserBaseAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert"], separator)
9696 
9797 
9898 func keyUserBaseAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert", "period"], separator)
9999 
100100 
101101 func keyUserShareAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert"], separator)
102102 
103103 
104104 func keyUserShareAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert", "period"], separator)
105105 
106106 
107107 func keyPricePeriod (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "price", toString(period)], separator)
108108 
109109 
110110 func keyPriceHistory (baseAssetId) = makeString(["%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
111111 
112112 
113113 func keyPricePeriodPut (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "put"], separator)
114114 
115115 
116116 func keyPricePutHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "put", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
117117 
118118 
119119 func keyPricePeriodGet (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "get"], separator)
120120 
121121 
122122 func keyPriceGetHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "get", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
123123 
124124 
125125 func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
126126 
127127 
128128 func keyManagerPublicKey () = "%s__managerPublicKey"
129129 
130130 
131131 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
132132 
133133 
134134 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
135135     case s: String => 
136136         fromBase58String(s)
137137     case _: Unit => 
138138         unit
139139     case _ => 
140140         throw("Match error")
141141 }
142142 
143143 
144144 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
145145     case s: String => 
146146         fromBase58String(s)
147147     case _: Unit => 
148148         unit
149149     case _ => 
150150         throw("Match error")
151151 }
152152 
153153 
154154 let permissionDeniedError = throw("Permission denied")
155155 
156156 func mustThis (i) = if ((i.caller == this))
157157     then true
158158     else permissionDeniedError
159159 
160160 
161161 func mustManager (i) = match managerPublicKeyOrUnit() {
162162     case pk: ByteVector => 
163163         if ((i.callerPublicKey == pk))
164164             then true
165165             else permissionDeniedError
166166     case _: Unit => 
167167         mustThis(i)
168168     case _ => 
169169         throw("Match error")
170170 }
171171 
172172 
173173 let shutdown = valueOrElse(getBoolean(keyShutdown()), false)
174174 
175175 func shutdownCheck (i) = if (if (!(shutdown))
176176     then true
177177     else mustManager(i))
178178     then true
179179     else throw("operation is disabled")
180180 
181181 
182182 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract()))
183183 
184184 let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract()))
185185 
186186 let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract()))
187187 
188188 let boostingContract = addressFromStringValue(getStrOrFail(this, keyBoostingContract()))
189189 
190190 let swapContract = addressFromStringValue(getStrOrFail(this, keySwapContract()))
191191 
192192 let assetsStoreContract = addressFromStringValue(getStrOrFail(this, keyAssetsStoreContract()))
193193 
194194 let usdnAssetId = parseAssetId(getStrOrFail(this, keyUsdnAssetId()))
195195 
196196 let wxAssetId = parseAssetId(getStrOrFail(this, keyWxAssetId()))
197197 
198198 let minDelayDefault = 1440
199199 
200200 let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault)
201201 
202202 let lockFractionMultiplier = 100000000
203203 
204204 let lockFractionDefault = fraction(1, lockFractionMultiplier, 2)
205205 
206206 let lockFraction = valueOrElse(getInteger(this, keyLockFraction()), lockFractionDefault)
207207 
208208 func getPoolInfo (amountAssetId) = {
209209     let amountAssetIdStr = assetIdToString(amountAssetId)
210210     let priceAssetIdStr = assetIdToString(usdnAssetId)
211211     let poolInfoOption = {
212212         let @ = invoke(factoryContract, "poolInfoREADONLY", [amountAssetIdStr, priceAssetIdStr], nil)
213213         if ($isInstanceOf(@, "(Address, ByteVector)"))
214214             then @
215215             else unit
216216         }
217217     poolInfoOption
218218     }
219219 
220220 
221221 func calcPrice (lpAssetId,shareAssetId) = {
222222     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
223223     let shareAssetEmission = shareAssetInfo.quantity
224224     let stakedAmount = ensurePositive(valueOrErrorMessage({
225225         let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
226226         if ($isInstanceOf(@, "Int"))
227227             then @
228228             else unit
229229         }, wrapErr("invalid stakedByUserREADONLY result")))
230230     let price = if ((shareAssetEmission == 0))
231231         then scale18BigInt
232232         else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
233233     price
234234     }
235235 
236236 
237237 @Callable(i)
238238 func setManager (pendingManagerPublicKey) = {
239239     let checkCaller = mustManager(i)
240240     if ((checkCaller == checkCaller))
241241         then {
242242             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
243243             if ((checkManagerPublicKey == checkManagerPublicKey))
244244                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
245245                 else throw("Strict value is not equal to itself.")
246246             }
247247         else throw("Strict value is not equal to itself.")
248248     }
249249 
250250 
251251 
252252 @Callable(i)
253253 func confirmManager () = {
254254     let pm = pendingManagerPublicKeyOrUnit()
255255     let hasPM = if (isDefined(pm))
256256         then true
257257         else throwErr("no pending manager")
258258     if ((hasPM == hasPM))
259259         then {
260260             let checkPM = if ((i.callerPublicKey == value(pm)))
261261                 then true
262262                 else throwErr("you are not pending manager")
263263             if ((checkPM == checkPM))
264264                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
265265                 else throw("Strict value is not equal to itself.")
266266             }
267267         else throw("Strict value is not equal to itself.")
268268     }
269269 
270270 
271271 
272272 @Callable(i)
273+func emit (assetId,amount) = {
274+    let checkCaller = mustThis(i)
275+    if ((checkCaller == checkCaller))
276+        then {
277+            let isReissuable = true
278+            $Tuple2([Reissue(assetId, amount, isReissuable)], amount)
279+            }
280+        else throw("Strict value is not equal to itself.")
281+    }
282+
283+
284+
285+@Callable(i)
286+func burn (assetId,amount) = {
287+    let checkCaller = mustThis(i)
288+    if ((checkCaller == checkCaller))
289+        then $Tuple2([Burn(assetId, amount)], amount)
290+        else throw("Strict value is not equal to itself.")
291+    }
292+
293+
294+
295+@Callable(i)
273296 func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
274297     let shareAssetLabel = "LP_STAKING_POOLS"
275298     let baseAssetId = parseAssetId(baseAssetIdStr)
276299     let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId)))
277300         then true
278301         else throwErr("invalid base asset")]
279302     if ((checks == checks))
280303         then {
281304             let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)]
282305             if ((shareAssetIdStr == ""))
283306                 then {
284307                     let shareAssetIssueAmount = 1
285308                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true)
286309                     let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction)
287310                     let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount)
288311                     let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId)
289312                     let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil)
290313                     if ((createOrUpdate == createOrUpdate))
291314                         then {
292315                             let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil)
293316                             if ((addLabel == addLabel))
294317                                 then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr)
295318                                 else throw("Strict value is not equal to itself.")
296319                             }
297320                         else throw("Strict value is not equal to itself.")
298321                     }
299322                 else {
300323                     let shareAssetId = fromBase58String(shareAssetIdStr)
301324                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
302325                     let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract))
303326                         then true
304327                         else throwErr("invalid share asset id issuer")
305328                     if ((checkIssuer == checkIssuer))
306329                         then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyShareAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr)
307330                         else throw("Strict value is not equal to itself.")
308331                     }
309332             }
310333         else throw("Strict value is not equal to itself.")
311334     }
312335 
313336 
314337 
315338 @Callable(i)
316339 func put () = {
317340     let pmt = if ((size(i.payments) == 1))
318341         then i.payments[0]
319342         else throwErr("exactly 1 payment is expected")
320343     let baseAssetId = pmt.assetId
321344     let userAddress = i.caller
322345     let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
323346         then true
324347         else throwErr("invalid asset")]
325348     if ((checks == checks))
326349         then {
327-            let $t01131211415 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
328-            let poolAddress = $t01131211415._1
329-            let lpAssetId = $t01131211415._2
350+            let $t01164611749 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
351+            let poolAddress = $t01164611749._1
352+            let lpAssetId = $t01164611749._2
330353             let period = value(getInteger(keyPeriod(baseAssetId)))
331354             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
332355             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
333356                 then unit
334357                 else {
335358                     let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption)
336359                     if ((userBaseAssetAmountToConvertPeriod == period))
337360                         then unit
338361                         else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
339362                     }
340363             if ((claimShareAssetInvocation == claimShareAssetInvocation))
341364                 then {
342365                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
343366                     let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
344367                     $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), (userBaseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), pmt.amount)], unit)
345368                     }
346369                 else throw("Strict value is not equal to itself.")
347370             }
348371         else throw("Strict value is not equal to itself.")
349372     }
350373 
351374 
352375 
353376 @Callable(i)
354377 func claimShareAsset (baseAssetIdStr,userAddressStr) = {
355378     let checks = [shutdownCheck(i)]
356379     if ((checks == checks))
357380         then {
358381             let userAddress = if ((userAddressStr == ""))
359382                 then i.caller
360383                 else {
361384                     let checkCaller = mustThis(i)
362385                     if ((checkCaller == checkCaller))
363386                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
364387                         else throw("Strict value is not equal to itself.")
365388                     }
366389             if ((userAddress == userAddress))
367390                 then {
368391                     let baseAssetId = parseAssetId(baseAssetIdStr)
369392                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
370393                     if ((shareAssetId == shareAssetId))
371394                         then {
372395                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
373396                             if ((period == period))
374397                                 then {
375398                                     let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
376399                                     let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
377400                                         then true
378401                                         else throwErr("nothing to claim")
379402                                     if ((checkAmountToConvert == checkAmountToConvert))
380403                                         then {
381404                                             let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
382405                                             let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
383406                                                 then true
384407                                                 else throwErr("invalid period")
385408                                             if ((checkPeriod == checkPeriod))
386409                                                 then {
387410                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
388411                                                     let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
389412                                                     $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), shareAssetAmount)], unit)
390413                                                     }
391414                                                 else throw("Strict value is not equal to itself.")
392415                                             }
393416                                         else throw("Strict value is not equal to itself.")
394417                                     }
395418                                 else throw("Strict value is not equal to itself.")
396419                             }
397420                         else throw("Strict value is not equal to itself.")
398421                     }
399422                 else throw("Strict value is not equal to itself.")
400423             }
401424         else throw("Strict value is not equal to itself.")
402425     }
403426 
404427 
405428 
406429 @Callable(i)
407430 func get () = {
408431     let checks = [shutdownCheck(i)]
409432     if ((checks == checks))
410433         then {
411434             let pmt = if ((size(i.payments) == 1))
412435                 then i.payments[0]
413436                 else throwErr("exactly 1 payment is expected")
414437             let shareAssetId = pmt.assetId
415438             let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
416439             if ((baseAssetId == baseAssetId))
417440                 then {
418441                     let userAddress = i.caller
419-                    let $t01511615219 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
420-                    let poolAddress = $t01511615219._1
421-                    let lpAssetId = $t01511615219._2
442+                    let $t01545015553 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443+                    let poolAddress = $t01545015553._1
444+                    let lpAssetId = $t01545015553._2
422445                     let period = value(getInteger(keyPeriod(baseAssetId)))
423446                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
424447                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
425448                         then unit
426449                         else {
427450                             let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
428451                             if ((userShareAssetAmountToConvertPeriod == period))
429452                                 then unit
430453                                 else invoke(this, "claimBaseAsset", [userAddress], nil)
431454                             }
432455                     if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
433456                         then {
434457                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
435458                             let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
436459                             $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), pmt.amount)], unit)
437460                             }
438461                         else throw("Strict value is not equal to itself.")
439462                     }
440463                 else throw("Strict value is not equal to itself.")
441464             }
442465         else throw("Strict value is not equal to itself.")
443466     }
444467 
445468 
446469 
447470 @Callable(i)
448471 func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
449472     let checks = [shutdownCheck(i)]
450473     if ((checks == checks))
451474         then {
452475             let userAddress = if ((userAddressStr == ""))
453476                 then i.caller
454477                 else {
455478                     let checkCaller = mustThis(i)
456479                     if ((checkCaller == checkCaller))
457480                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
458481                         else throw("Strict value is not equal to itself.")
459482                     }
460483             if ((userAddress == userAddress))
461484                 then {
462485                     let baseAssetId = parseAssetId(baseAssetIdStr)
463486                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
464487                     if ((shareAssetId == shareAssetId))
465488                         then {
466489                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
467490                             if ((period == period))
468491                                 then {
469492                                     let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
470493                                     let checkAmountToConvert = if ((userShareAssetAmountToConvert > 0))
471494                                         then true
472495                                         else throwErr("nothing to claim")
473496                                     if ((checkAmountToConvert == checkAmountToConvert))
474497                                         then {
475498                                             let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
476499                                             let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
477500                                                 then true
478501                                                 else throwErr("invalid period")
479502                                             if ((checkPeriod == checkPeriod))
480503                                                 then {
481504                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
482505                                                     let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
483506                                                     $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), baseAssetAmount)], unit)
484507                                                     }
485508                                                 else throw("Strict value is not equal to itself.")
486509                                             }
487510                                         else throw("Strict value is not equal to itself.")
488511                                     }
489512                                 else throw("Strict value is not equal to itself.")
490513                             }
491514                         else throw("Strict value is not equal to itself.")
492515                     }
493516                 else throw("Strict value is not equal to itself.")
494517             }
495518         else throw("Strict value is not equal to itself.")
496519     }
497520 
498521 
499522 
500523 @Callable(i)
501524 func finalize (baseAssetIdStr) = {
502525     let checks = [shutdownCheck(i)]
503526     if ((checks == checks))
504527         then {
505528             let baseAssetId = parseAssetId(baseAssetIdStr)
506529             let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
507530             if ((shareAssetId == shareAssetId))
508531                 then {
532+                    let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
509533                     let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
510534                     if ((period == period))
511535                         then {
512536                             let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
513537                             let checkDelay = if ((periodStartHeightOption == unit))
514538                                 then unit
515539                                 else {
516540                                     let delay = (height - value(periodStartHeightOption))
517541                                     let blocksToWait = max([0, (minDelay - delay)])
518542                                     if ((blocksToWait == 0))
519543                                         then unit
520544                                         else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
521545                                     }
522546                             if ((checkDelay == checkDelay))
523547                                 then {
524-                                    let $t01916119342 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
525-                                    let poolAddress = $t01916119342._1
526-                                    let lpAssetId = $t01916119342._2
548+                                    let $t01959919780 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
549+                                    let poolAddress = $t01959919780._1
550+                                    let lpAssetId = $t01959919780._2
527551                                     let stakingReward = valueOrErrorMessage({
528552                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
529553                                         if ($isInstanceOf(@, "Int"))
530554                                             then @
531555                                             else unit
532556                                         }, wrapErr("invalid claimWx result"))
533557                                     if ((stakingReward == stakingReward))
534558                                         then {
535559                                             let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
536560                                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
537561                                             let checkFinalizationIsRequired = {
538562                                                 let isFinalizationRequired = if (if ((stakingReward > 0))
539563                                                     then true
540564                                                     else (baseAssetAmountToConvert > 0))
541565                                                     then true
542566                                                     else (shareAssetAmountToConvert > 0)
543567                                                 if (isFinalizationRequired)
544568                                                     then true
545569                                                     else throwErr("nothing to finalize")
546570                                                 }
547571                                             if ((checkFinalizationIsRequired == checkFinalizationIsRequired))
548572                                                 then {
549573                                                     let useStakingReward = if ((stakingReward > 0))
550574                                                         then {
551575                                                             let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier)
552576                                                             let convertPart = (stakingReward - lockPart)
553577                                                             let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
554578                                                             let lock = if ((lockPart > 0))
555579                                                                 then                                                                 match r {
556580                                                                     case _ => 
557581                                                                         if (if (if ($isInstanceOf($match0._1, "String"))
558582                                                                             then $isInstanceOf($match0._2, "Int")
559583                                                                             else false)
560584                                                                             then $isInstanceOf($match0, "(String, Int)")
561585                                                                             else false)
562586                                                                             then {
563587                                                                                 let function = $match0._1
564588                                                                                 let duration = $match0._2
565589                                                                                 if ((lockPart > 0))
566590                                                                                     then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
567591                                                                                     else unit
568592                                                                                 }
569593                                                                             else throwErr("invalid lock params")
570594                                                                 }
571595                                                                 else unit
572596                                                             if ((lock == lock))
573597                                                                 then {
574598                                                                     let convertedAmount = if ((convertPart > 0))
575599                                                                         then {
576600                                                                             let inAssetId = wxAssetId
577601                                                                             let minimumToReceive = 0
578602                                                                             let outAssetIdStr = assetIdToString(usdnAssetId)
579603                                                                             let targetAddress = ""
580604                                                                             valueOrErrorMessage({
581605                                                                                 let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
582606                                                                                 if ($isInstanceOf(@, "Int"))
583607                                                                                     then @
584608                                                                                     else unit
585609                                                                                 }, wrapErr("invalid swap result"))
586610                                                                             }
587611                                                                         else 0
588612                                                                     if ((convertedAmount == convertedAmount))
589613                                                                         then {
590614                                                                             let lpAssetAmount = if ((convertedAmount > 0))
591615                                                                                 then {
592616                                                                                     let minOutAmount = 0
593617                                                                                     let autoStake = true
594618                                                                                     valueOrErrorMessage({
595619                                                                                         let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdnAssetId, convertedAmount)])
596620                                                                                         if ($isInstanceOf(@, "Int"))
597621                                                                                             then @
598622                                                                                             else unit
599623                                                                                         }, wrapErr("invalid putOneTknV2 result"))
600624                                                                                     }
601625                                                                                 else 0
602626                                                                             if ((lpAssetAmount == lpAssetAmount))
603627                                                                                 then lpAssetAmount
604628                                                                                 else throw("Strict value is not equal to itself.")
605629                                                                             }
606630                                                                         else throw("Strict value is not equal to itself.")
607631                                                                     }
608632                                                                 else throw("Strict value is not equal to itself.")
609633                                                             }
610634                                                         else unit
611635                                                     if ((useStakingReward == useStakingReward))
612636                                                         then {
613637                                                             let getActions = if ((shareAssetAmountToConvert > 0))
614638                                                                 then {
615639                                                                     let price = calcPrice(lpAssetId, shareAssetId)
616640                                                                     if ((price == price))
617641                                                                         then {
618642                                                                             let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
619643                                                                             let baseAssetAmount = {
620644                                                                                 let outAssetId = baseAssetId
621645                                                                                 let minOutAmount = 0
622646                                                                                 valueOrErrorMessage({
623647                                                                                     let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
624648                                                                                     if ($isInstanceOf(@, "Int"))
625649                                                                                         then @
626650                                                                                         else unit
627651                                                                                     }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
628652                                                                                 }
629653                                                                             if ((baseAssetAmount == baseAssetAmount))
630654                                                                                 then {
631-                                                                                    let shareAssetBurnActions = [Burn(shareAssetId, shareAssetAmountToConvert)]
632-                                                                                    let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
633-                                                                                    let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
634-                                                                                    (shareAssetBurnActions ++ priceGetUpdateActions)
655+                                                                                    let shareAssetBurn = if ((shareAssetInfo.issuer == this))
656+                                                                                        then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
657+                                                                                        else if ((shareAssetInfo.issuer == lpStakingContract))
658+                                                                                            then invoke(lpStakingContract, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
659+                                                                                            else throwErr("invalid share asset issuer")
660+                                                                                    if ((shareAssetBurn == shareAssetBurn))
661+                                                                                        then {
662+                                                                                            let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
663+                                                                                            let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
664+                                                                                            priceGetUpdateActions
665+                                                                                            }
666+                                                                                        else throw("Strict value is not equal to itself.")
635667                                                                                     }
636668                                                                                 else throw("Strict value is not equal to itself.")
637669                                                                             }
638670                                                                         else throw("Strict value is not equal to itself.")
639671                                                                     }
640672                                                                 else nil
641-                                                            let putActions = if ((baseAssetAmountToConvert > 0))
673+                                                            if ((getActions == getActions))
642674                                                                 then {
643-                                                                    let lpAssetAmount = {
644-                                                                        let minOutAmount = 0
645-                                                                        let autoStake = true
646-                                                                        valueOrErrorMessage({
647-                                                                            let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
648-                                                                            if ($isInstanceOf(@, "Int"))
649-                                                                                then @
650-                                                                                else unit
651-                                                                            }, wrapErr("invalid putOneTknV2 result"))
652-                                                                        }
653-                                                                    if ((lpAssetAmount == lpAssetAmount))
675+                                                                    let putActions = if ((baseAssetAmountToConvert > 0))
654676                                                                         then {
655-                                                                            let price = calcPrice(lpAssetId, shareAssetId)
656-                                                                            if ((price == price))
677+                                                                            let lpAssetAmount = {
678+                                                                                let minOutAmount = 0
679+                                                                                let autoStake = true
680+                                                                                valueOrErrorMessage({
681+                                                                                    let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
682+                                                                                    if ($isInstanceOf(@, "Int"))
683+                                                                                        then @
684+                                                                                        else unit
685+                                                                                    }, wrapErr("invalid putOneTknV2 result"))
686+                                                                                }
687+                                                                            if ((lpAssetAmount == lpAssetAmount))
657688                                                                                 then {
658-                                                                                    let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
659-                                                                                    let isReissuable = true
660-                                                                                    let shareAssetReissueActions = [Reissue(shareAssetId, shareAssetAmount, isReissuable)]
661-                                                                                    let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
662-                                                                                    let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
663-                                                                                    (shareAssetReissueActions ++ pricePutUpdateActions)
689+                                                                                    let price = calcPrice(lpAssetId, shareAssetId)
690+                                                                                    if ((price == price))
691+                                                                                        then {
692+                                                                                            let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
693+                                                                                            let shareAssetReissue = if ((shareAssetInfo.issuer == this))
694+                                                                                                then invoke(this, "emit", [shareAssetId, shareAssetAmount], nil)
695+                                                                                                else if ((shareAssetInfo.issuer == lpStakingContract))
696+                                                                                                    then invoke(lpStakingContract, "emit", [shareAssetId, shareAssetAmount], nil)
697+                                                                                                    else throwErr("invalid share asset issuer")
698+                                                                                            if ((shareAssetReissue == shareAssetReissue))
699+                                                                                                then {
700+                                                                                                    let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
701+                                                                                                    let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
702+                                                                                                    pricePutUpdateActions
703+                                                                                                    }
704+                                                                                                else throw("Strict value is not equal to itself.")
705+                                                                                            }
706+                                                                                        else throw("Strict value is not equal to itself.")
664707                                                                                     }
665708                                                                                 else throw("Strict value is not equal to itself.")
666709                                                                             }
710+                                                                        else nil
711+                                                                    if ((putActions == putActions))
712+                                                                        then {
713+                                                                            let newPeriod = (period + 1)
714+                                                                            let lastPrice = calcPrice(lpAssetId, shareAssetId)
715+                                                                            let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(lastPrice)), StringEntry(keyPriceHistory(baseAssetId), toString(lastPrice))] ++ putActions) ++ getActions)
716+                                                                            $Tuple2(actions, toBytes(lastPrice))
717+                                                                            }
667718                                                                         else throw("Strict value is not equal to itself.")
668719                                                                     }
669-                                                                else nil
670-                                                            let newPeriod = (period + 1)
671-                                                            let lastPrice = calcPrice(lpAssetId, shareAssetId)
672-                                                            let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(lastPrice)), StringEntry(keyPriceHistory(baseAssetId), toString(lastPrice))] ++ putActions) ++ getActions)
673-                                                            $Tuple2(actions, toBytes(lastPrice))
720+                                                                else throw("Strict value is not equal to itself.")
674721                                                             }
675722                                                         else throw("Strict value is not equal to itself.")
676723                                                     }
677724                                                 else throw("Strict value is not equal to itself.")
678725                                             }
679726                                         else throw("Strict value is not equal to itself.")
680727                                     }
681728                                 else throw("Strict value is not equal to itself.")
682729                             }
683730                         else throw("Strict value is not equal to itself.")
684731                     }
685732                 else throw("Strict value is not equal to itself.")
686733             }
687734         else throw("Strict value is not equal to itself.")
688735     }
689736 
690737 
691738 @Verifier(tx)
692739 func verify () = {
693740     let targetPublicKey =     match managerPublicKeyOrUnit() {
694741         case pk: ByteVector => 
695742             pk
696743         case _: Unit => 
697744             tx.senderPublicKey
698745         case _ => 
699746             throw("Match error")
700747     }
701748     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
702749     }
703750 
github/deemru/w8io/fabc49c 
72.40 ms ◑