tx · H69tGjR2Q2UBryiPWuzoZHjwSkaxQfsCsZFgbcFbZYCP

3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV:  -0.03000000 Waves

2023.04.25 14:24 [2550011] smart account 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "H69tGjR2Q2UBryiPWuzoZHjwSkaxQfsCsZFgbcFbZYCP",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1682421507251,
    "version": 2,
    "chainId": 84,
    "sender": "3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV",
    "senderPublicKey": "F4oaTkX67vt2MEsXLJJ8a7gaURGjW7x8fkvGfdEiH5oy",
    "proofs": [
        "2Qcz3tkfCEhXVd5toDQopCz4e8fLBxDe11AfGCQWDW83JwA7umU8t4vaz6iMLr83yav76WU8aitbVZg8R2iEKKv6"
    ],
    "script": "base64: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",
    "height": 2550011,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 13nvndpidaVj4athEixXFno8si8znqFKjMstsnzLK4YM
Next: FAoSi1SEpsswjSZZQaHGjhnBymC5a7Ba77XMpKfhuqPb

Diff: 

OldNewDifferences
364364                 then {
365365                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
366366                     let userBaseAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
367-                    $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString((userBaseAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp)], separator)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userBaseAssetAmountToConvert)], separator))], unit)
367+                    $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString((userBaseAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp), toString(period)], separator)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userBaseAssetAmountToConvert)], separator))], unit)
368368                     }
369369                 else throw("Strict value is not equal to itself.")
370370             }
409409                                                 then {
410410                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
411411                                                     let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
412-                                                    $Tuple2([StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString(0), toString(lastBlock.timestamp)], separator)), DeleteEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(shareAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userBaseAssetAmountToConvert)], separator))], unit)
412+                                                    $Tuple2([StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString(0), toString(lastBlock.timestamp), toString(period)], separator)), DeleteEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(shareAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userBaseAssetAmountToConvert)], separator))], unit)
413413                                                     }
414414                                                 else throw("Strict value is not equal to itself.")
415415                                             }
439439             if ((baseAssetId == baseAssetId))
440440                 then {
441441                     let userAddress = i.caller
442-                    let $t01612016309 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443-                    let poolAddress = $t01612016309._1
444-                    let lpAssetId = $t01612016309._2
442+                    let $t01616216351 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443+                    let poolAddress = $t01616216351._1
444+                    let lpAssetId = $t01616216351._2
445445                     let period = value(getInteger(keyPeriod(baseAssetId)))
446446                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
447447                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
456456                         then {
457457                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
458458                             let userShareAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserShareAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
459-                            $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString((userShareAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp)], separator)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userShareAssetAmountToConvert)], separator))], unit)
459+                            $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString((userShareAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp), toString(period)], separator)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userShareAssetAmountToConvert)], separator))], unit)
460460                             }
461461                         else throw("Strict value is not equal to itself.")
462462                     }
498498                                         then {
499499                                             let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
500500                                             let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
501-                                            $Tuple2([StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString(0), toString(lastBlock.timestamp)], separator)), DeleteEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(baseAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userShareAssetAmountToConvertPeriod)], separator))], unit)
501+                                            $Tuple2([StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString(0), toString(lastBlock.timestamp), toString(period)], separator)), DeleteEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(baseAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userShareAssetAmountToConvertPeriod)], separator))], unit)
502502                                             }
503503                                         else throw("Strict value is not equal to itself.")
504504                                     }
538538                                     }
539539                             if ((checkDelay == checkDelay))
540540                                 then {
541-                                    let $t02168021861 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
542-                                    let poolAddress = $t02168021861._1
543-                                    let lpAssetId = $t02168021861._2
541+                                    let $t02176421945 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
542+                                    let poolAddress = $t02176421945._1
543+                                    let lpAssetId = $t02176421945._2
544544                                     let stakingReward = valueOrErrorMessage({
545545                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
546546                                         if ($isInstanceOf(@, "Int"))

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 keyUsdtAssetId () = makeString(["%s", "usdtAssetId"], 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", toUtf8String(value(baseAssetId)), 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 usdtAssetId = parseAssetId(getStrOrFail(this, keyUsdtAssetId()))
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(usdtAssetId)
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)
273273 func emit (assetId,amount) = {
274274     let checkCaller = mustThis(i)
275275     if ((checkCaller == checkCaller))
276276         then {
277277             let isReissuable = true
278278             $Tuple2([Reissue(assetId, amount, isReissuable)], amount)
279279             }
280280         else throw("Strict value is not equal to itself.")
281281     }
282282 
283283 
284284 
285285 @Callable(i)
286286 func burn (assetId,amount) = {
287287     let checkCaller = mustThis(i)
288288     if ((checkCaller == checkCaller))
289289         then $Tuple2([Burn(assetId, amount)], amount)
290290         else throw("Strict value is not equal to itself.")
291291     }
292292 
293293 
294294 
295295 @Callable(i)
296296 func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
297297     let shareAssetLabel = "STAKING_LP"
298298     let baseAssetId = parseAssetId(baseAssetIdStr)
299299     let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId)))
300300         then true
301301         else throwErr("invalid base asset")]
302302     if ((checks == checks))
303303         then {
304304             let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)]
305305             if ((shareAssetIdStr == ""))
306306                 then {
307307                     let shareAssetIssueAmount = 1
308308                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true)
309309                     let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction)
310310                     let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount)
311311                     let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId)
312312                     let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil)
313313                     if ((createOrUpdate == createOrUpdate))
314314                         then {
315315                             let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil)
316316                             if ((addLabel == addLabel))
317317                                 then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr)
318318                                 else throw("Strict value is not equal to itself.")
319319                             }
320320                         else throw("Strict value is not equal to itself.")
321321                     }
322322                 else {
323323                     let shareAssetId = fromBase58String(shareAssetIdStr)
324324                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
325325                     let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract))
326326                         then true
327327                         else throwErr("invalid share asset id issuer")
328328                     if ((checkIssuer == checkIssuer))
329329                         then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyBaseAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr)
330330                         else throw("Strict value is not equal to itself.")
331331                     }
332332             }
333333         else throw("Strict value is not equal to itself.")
334334     }
335335 
336336 
337337 
338338 @Callable(i)
339339 func put () = {
340340     let pmt = if ((size(i.payments) == 1))
341341         then i.payments[0]
342342         else throwErr("exactly 1 payment is expected")
343343     let baseAssetId = pmt.assetId
344344     let userAddress = i.caller
345345     let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
346346         then true
347347         else throwErr("invalid asset")]
348348     if ((checks == checks))
349349         then {
350350             let $t01167511778 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
351351             let poolAddress = $t01167511778._1
352352             let lpAssetId = $t01167511778._2
353353             let period = value(getInteger(keyPeriod(baseAssetId)))
354354             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
355355             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
356356                 then unit
357357                 else {
358358                     let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption)
359359                     if ((userBaseAssetAmountToConvertPeriod == period))
360360                         then unit
361361                         else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
362362                     }
363363             if ((claimShareAssetInvocation == claimShareAssetInvocation))
364364                 then {
365365                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
366366                     let userBaseAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
367-                    $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString((userBaseAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp)], separator)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userBaseAssetAmountToConvert)], separator))], unit)
367+                    $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString((userBaseAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp), toString(period)], separator)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userBaseAssetAmountToConvert)], separator))], unit)
368368                     }
369369                 else throw("Strict value is not equal to itself.")
370370             }
371371         else throw("Strict value is not equal to itself.")
372372     }
373373 
374374 
375375 
376376 @Callable(i)
377377 func claimShareAsset (baseAssetIdStr,userAddressStr) = {
378378     let checks = [shutdownCheck(i)]
379379     if ((checks == checks))
380380         then {
381381             let userAddress = if ((userAddressStr == ""))
382382                 then i.caller
383383                 else {
384384                     let checkCaller = mustThis(i)
385385                     if ((checkCaller == checkCaller))
386386                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
387387                         else throw("Strict value is not equal to itself.")
388388                     }
389389             if ((userAddress == userAddress))
390390                 then {
391391                     let baseAssetId = parseAssetId(baseAssetIdStr)
392392                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
393393                     if ((shareAssetId == shareAssetId))
394394                         then {
395395                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
396396                             if ((period == period))
397397                                 then {
398398                                     let userBaseAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
399399                                     let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
400400                                         then true
401401                                         else throwErr("nothing to claim")
402402                                     if ((checkAmountToConvert == checkAmountToConvert))
403403                                         then {
404404                                             let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
405405                                             let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
406406                                                 then true
407407                                                 else throwErr("invalid period")
408408                                             if ((checkPeriod == checkPeriod))
409409                                                 then {
410410                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
411411                                                     let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
412-                                                    $Tuple2([StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString(0), toString(lastBlock.timestamp)], separator)), DeleteEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(shareAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userBaseAssetAmountToConvert)], separator))], unit)
412+                                                    $Tuple2([StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString(0), toString(lastBlock.timestamp), toString(period)], separator)), DeleteEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(shareAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userBaseAssetAmountToConvert)], separator))], unit)
413413                                                     }
414414                                                 else throw("Strict value is not equal to itself.")
415415                                             }
416416                                         else throw("Strict value is not equal to itself.")
417417                                     }
418418                                 else throw("Strict value is not equal to itself.")
419419                             }
420420                         else throw("Strict value is not equal to itself.")
421421                     }
422422                 else throw("Strict value is not equal to itself.")
423423             }
424424         else throw("Strict value is not equal to itself.")
425425     }
426426 
427427 
428428 
429429 @Callable(i)
430430 func get () = {
431431     let checks = [shutdownCheck(i)]
432432     if ((checks == checks))
433433         then {
434434             let pmt = if ((size(i.payments) == 1))
435435                 then i.payments[0]
436436                 else throwErr("exactly 1 payment is expected")
437437             let shareAssetId = pmt.assetId
438438             let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
439439             if ((baseAssetId == baseAssetId))
440440                 then {
441441                     let userAddress = i.caller
442-                    let $t01612016309 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443-                    let poolAddress = $t01612016309._1
444-                    let lpAssetId = $t01612016309._2
442+                    let $t01616216351 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443+                    let poolAddress = $t01616216351._1
444+                    let lpAssetId = $t01616216351._2
445445                     let period = value(getInteger(keyPeriod(baseAssetId)))
446446                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
447447                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
448448                         then unit
449449                         else {
450450                             let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
451451                             if ((userShareAssetAmountToConvertPeriod == period))
452452                                 then unit
453453                                 else invoke(this, "claimBaseAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
454454                             }
455455                     if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
456456                         then {
457457                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
458458                             let userShareAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserShareAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
459-                            $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString((userShareAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp)], separator)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userShareAssetAmountToConvert)], separator))], unit)
459+                            $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString((userShareAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp), toString(period)], separator)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userShareAssetAmountToConvert)], separator))], unit)
460460                             }
461461                         else throw("Strict value is not equal to itself.")
462462                     }
463463                 else throw("Strict value is not equal to itself.")
464464             }
465465         else throw("Strict value is not equal to itself.")
466466     }
467467 
468468 
469469 
470470 @Callable(i)
471471 func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
472472     let checks = [shutdownCheck(i)]
473473     if ((checks == checks))
474474         then {
475475             let userAddress = if ((userAddressStr == ""))
476476                 then i.caller
477477                 else {
478478                     let checkCaller = mustThis(i)
479479                     if ((checkCaller == checkCaller))
480480                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
481481                         else throw("Strict value is not equal to itself.")
482482                     }
483483             if ((userAddress == userAddress))
484484                 then {
485485                     let baseAssetId = parseAssetId(baseAssetIdStr)
486486                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
487487                     if ((shareAssetId == shareAssetId))
488488                         then {
489489                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
490490                             if ((period == period))
491491                                 then {
492492                                     let userShareAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserShareAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
493493                                     let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
494494                                     let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
495495                                         then true
496496                                         else throwErr("invalid period")
497497                                     if ((checkPeriod == checkPeriod))
498498                                         then {
499499                                             let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
500500                                             let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
501-                                            $Tuple2([StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString(0), toString(lastBlock.timestamp)], separator)), DeleteEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(baseAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userShareAssetAmountToConvertPeriod)], separator))], unit)
501+                                            $Tuple2([StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d%d", toString(0), toString(lastBlock.timestamp), toString(period)], separator)), DeleteEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(baseAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userShareAssetAmountToConvertPeriod)], separator))], unit)
502502                                             }
503503                                         else throw("Strict value is not equal to itself.")
504504                                     }
505505                                 else throw("Strict value is not equal to itself.")
506506                             }
507507                         else throw("Strict value is not equal to itself.")
508508                     }
509509                 else throw("Strict value is not equal to itself.")
510510             }
511511         else throw("Strict value is not equal to itself.")
512512     }
513513 
514514 
515515 
516516 @Callable(i)
517517 func finalize (baseAssetIdStr) = {
518518     let checks = [shutdownCheck(i)]
519519     if ((checks == checks))
520520         then {
521521             let baseAssetId = parseAssetId(baseAssetIdStr)
522522             let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
523523             if ((shareAssetId == shareAssetId))
524524                 then {
525525                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
526526                     let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
527527                     if ((period == period))
528528                         then {
529529                             let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
530530                             let checkDelay = if ((periodStartHeightOption == unit))
531531                                 then unit
532532                                 else {
533533                                     let delay = (height - value(periodStartHeightOption))
534534                                     let blocksToWait = max([0, (minDelay - delay)])
535535                                     if ((blocksToWait == 0))
536536                                         then unit
537537                                         else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
538538                                     }
539539                             if ((checkDelay == checkDelay))
540540                                 then {
541-                                    let $t02168021861 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
542-                                    let poolAddress = $t02168021861._1
543-                                    let lpAssetId = $t02168021861._2
541+                                    let $t02176421945 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
542+                                    let poolAddress = $t02176421945._1
543+                                    let lpAssetId = $t02176421945._2
544544                                     let stakingReward = valueOrErrorMessage({
545545                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
546546                                         if ($isInstanceOf(@, "Int"))
547547                                             then @
548548                                             else unit
549549                                         }, wrapErr("invalid claimWx result"))
550550                                     if ((stakingReward == stakingReward))
551551                                         then {
552552                                             let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
553553                                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
554554                                             let checkFinalizationIsRequired = {
555555                                                 let isFinalizationRequired = if (if ((stakingReward > 0))
556556                                                     then true
557557                                                     else (baseAssetAmountToConvert > 0))
558558                                                     then true
559559                                                     else (shareAssetAmountToConvert > 0)
560560                                                 if (isFinalizationRequired)
561561                                                     then true
562562                                                     else throwErr("nothing to finalize")
563563                                                 }
564564                                             if ((checkFinalizationIsRequired == checkFinalizationIsRequired))
565565                                                 then {
566566                                                     let useStakingReward = if ((stakingReward > 0))
567567                                                         then {
568568                                                             let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier)
569569                                                             let convertPart = (stakingReward - lockPart)
570570                                                             let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
571571                                                             let lock = if ((lockPart > 0))
572572                                                                 then                                                                 match r {
573573                                                                     case _ => 
574574                                                                         if (if (if ($isInstanceOf($match0._1, "String"))
575575                                                                             then $isInstanceOf($match0._2, "Int")
576576                                                                             else false)
577577                                                                             then $isInstanceOf($match0, "(String, Int)")
578578                                                                             else false)
579579                                                                             then {
580580                                                                                 let function = $match0._1
581581                                                                                 let duration = $match0._2
582582                                                                                 if ((lockPart > 0))
583583                                                                                     then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
584584                                                                                     else unit
585585                                                                                 }
586586                                                                             else throwErr("invalid lock params")
587587                                                                 }
588588                                                                 else unit
589589                                                             if ((lock == lock))
590590                                                                 then {
591591                                                                     let convertedAmount = if ((convertPart > 0))
592592                                                                         then {
593593                                                                             let inAssetId = wxAssetId
594594                                                                             let minimumToReceive = 0
595595                                                                             let outAssetIdStr = assetIdToString(usdtAssetId)
596596                                                                             let targetAddress = toString(this)
597597                                                                             valueOrErrorMessage({
598598                                                                                 let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
599599                                                                                 if ($isInstanceOf(@, "Int"))
600600                                                                                     then @
601601                                                                                     else unit
602602                                                                                 }, wrapErr("invalid swap result"))
603603                                                                             }
604604                                                                         else 0
605605                                                                     if ((convertedAmount == convertedAmount))
606606                                                                         then {
607607                                                                             let lpAssetAmount = if ((convertedAmount > 0))
608608                                                                                 then {
609609                                                                                     let minOutAmount = 0
610610                                                                                     let autoStake = true
611611                                                                                     valueOrErrorMessage({
612612                                                                                         let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdtAssetId, convertedAmount)])
613613                                                                                         if ($isInstanceOf(@, "Int"))
614614                                                                                             then @
615615                                                                                             else unit
616616                                                                                         }, wrapErr("invalid putOneTknV2 result"))
617617                                                                                     }
618618                                                                                 else 0
619619                                                                             if ((lpAssetAmount == lpAssetAmount))
620620                                                                                 then lpAssetAmount
621621                                                                                 else throw("Strict value is not equal to itself.")
622622                                                                             }
623623                                                                         else throw("Strict value is not equal to itself.")
624624                                                                     }
625625                                                                 else throw("Strict value is not equal to itself.")
626626                                                             }
627627                                                         else unit
628628                                                     if ((useStakingReward == useStakingReward))
629629                                                         then {
630630                                                             let getActions = if ((shareAssetAmountToConvert > 0))
631631                                                                 then {
632632                                                                     let price = calcPrice(lpAssetId, shareAssetId)
633633                                                                     if ((price == price))
634634                                                                         then {
635635                                                                             let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
636636                                                                             let baseAssetAmount = {
637637                                                                                 let outAssetId = baseAssetId
638638                                                                                 let minOutAmount = 0
639639                                                                                 valueOrErrorMessage({
640640                                                                                     let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
641641                                                                                     if ($isInstanceOf(@, "Int"))
642642                                                                                         then @
643643                                                                                         else unit
644644                                                                                     }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
645645                                                                                 }
646646                                                                             if ((baseAssetAmount == baseAssetAmount))
647647                                                                                 then {
648648                                                                                     let shareAssetBurn = if ((shareAssetInfo.issuer == this))
649649                                                                                         then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
650650                                                                                         else throwErr("invalid share asset issuer")
651651                                                                                     if ((shareAssetBurn == shareAssetBurn))
652652                                                                                         then {
653653                                                                                             let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
654654                                                                                             let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
655655                                                                                             priceGetUpdateActions
656656                                                                                             }
657657                                                                                         else throw("Strict value is not equal to itself.")
658658                                                                                     }
659659                                                                                 else throw("Strict value is not equal to itself.")
660660                                                                             }
661661                                                                         else throw("Strict value is not equal to itself.")
662662                                                                     }
663663                                                                 else nil
664664                                                             if ((getActions == getActions))
665665                                                                 then {
666666                                                                     let putActions = if ((baseAssetAmountToConvert > 0))
667667                                                                         then {
668668                                                                             let lpAssetAmount = {
669669                                                                                 let minOutAmount = 0
670670                                                                                 let autoStake = true
671671                                                                                 valueOrErrorMessage({
672672                                                                                     let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
673673                                                                                     if ($isInstanceOf(@, "Int"))
674674                                                                                         then @
675675                                                                                         else unit
676676                                                                                     }, wrapErr("invalid putOneTknV2 result"))
677677                                                                                 }
678678                                                                             if ((lpAssetAmount == lpAssetAmount))
679679                                                                                 then {
680680                                                                                     let price = calcPrice(lpAssetId, shareAssetId)
681681                                                                                     if ((price == price))
682682                                                                                         then {
683683                                                                                             let checkPrice = if ((value(toInt(price)) != 0))
684684                                                                                                 then true
685685                                                                                                 else throw("price is ZERO")
686686                                                                                             if ((checkPrice == checkPrice))
687687                                                                                                 then {
688688                                                                                                     let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
689689                                                                                                     let checkShareAssetAmount = if ((value(toInt(price)) != 0))
690690                                                                                                         then true
691691                                                                                                         else throw("shareAssetAmount is ZERO")
692692                                                                                                     if ((checkShareAssetAmount == checkShareAssetAmount))
693693                                                                                                         then {
694694                                                                                                             let shareAssetReissue = if ((shareAssetInfo.issuer == this))
695695                                                                                                                 then invoke(this, "emit", [shareAssetId, shareAssetAmount], nil)
696696                                                                                                                 else throwErr("invalid share asset issuer")
697697                                                                                                             if ((shareAssetReissue == shareAssetReissue))
698698                                                                                                                 then {
699699                                                                                                                     let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
700700                                                                                                                     let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
701701                                                                                                                     pricePutUpdateActions
702702                                                                                                                     }
703703                                                                                                                 else throw("Strict value is not equal to itself.")
704704                                                                                                             }
705705                                                                                                         else throw("Strict value is not equal to itself.")
706706                                                                                                     }
707707                                                                                                 else throw("Strict value is not equal to itself.")
708708                                                                                             }
709709                                                                                         else throw("Strict value is not equal to itself.")
710710                                                                                     }
711711                                                                                 else throw("Strict value is not equal to itself.")
712712                                                                             }
713713                                                                         else nil
714714                                                                     if ((putActions == putActions))
715715                                                                         then {
716716                                                                             let newPeriod = (period + 1)
717717                                                                             let lastPrice = calcPrice(lpAssetId, shareAssetId)
718718                                                                             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)
719719                                                                             $Tuple2(actions, toBytes(lastPrice))
720720                                                                             }
721721                                                                         else throw("Strict value is not equal to itself.")
722722                                                                     }
723723                                                                 else throw("Strict value is not equal to itself.")
724724                                                             }
725725                                                         else throw("Strict value is not equal to itself.")
726726                                                     }
727727                                                 else throw("Strict value is not equal to itself.")
728728                                             }
729729                                         else throw("Strict value is not equal to itself.")
730730                                     }
731731                                 else throw("Strict value is not equal to itself.")
732732                             }
733733                         else throw("Strict value is not equal to itself.")
734734                     }
735735                 else throw("Strict value is not equal to itself.")
736736             }
737737         else throw("Strict value is not equal to itself.")
738738     }
739739 
740740 
741741 @Verifier(tx)
742742 func verify () = {
743743     let targetPublicKey =     match managerPublicKeyOrUnit() {
744744         case pk: ByteVector => 
745745             pk
746746         case _: Unit => 
747747             tx.senderPublicKey
748748         case _ => 
749749             throw("Match error")
750750     }
751751     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
752752     }
753753 
github/deemru/w8io/fabc49c 
89.29 ms ◑