tx · CXxydS2qDgd9Z24Wc53E2YMQHKWz6dnqWCzU7X9yr9J2

3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV:  -0.02900000 Waves

2023.05.12 10:06 [2574391] smart account 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "CXxydS2qDgd9Z24Wc53E2YMQHKWz6dnqWCzU7X9yr9J2",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1683875249791,
    "version": 2,
    "chainId": 84,
    "sender": "3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV",
    "senderPublicKey": "F4oaTkX67vt2MEsXLJJ8a7gaURGjW7x8fkvGfdEiH5oy",
    "proofs": [
        "5gMoJCwS8Rnh4EERyJMaVkYhhEy4yYs8i8RBXboP48B62NFv8gbPETSixQkEW6zZS6BQeurBBB54eLj6c5DVjWf4"
    ],
    "script": "base64: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",
    "height": 2574391,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EnuRAfmbkpQis4qRRLEvD8NgGJJso2JoB9EH2cfsfBVM
Next: none

Diff: 

OldNewDifferences
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 
125-func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", toUtf8String(value(baseAssetId)), operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
125+func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", toBase58String(value(baseAssetId)), operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
126126 
127127 
128128 func keyManagerPublicKey () = "%s__managerPublicKey"
313313         else throwErr("invalid asset")]
314314     if ((checks == checks))
315315         then {
316-            let $t01112711230 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
317-            let poolAddress = $t01112711230._1
318-            let lpAssetId = $t01112711230._2
316+            let $t01112911232 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
317+            let poolAddress = $t01112911232._1
318+            let lpAssetId = $t01112911232._2
319319             let period = value(getInteger(keyPeriod(baseAssetId)))
320320             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
321321             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
405405             if ((baseAssetId == baseAssetId))
406406                 then {
407407                     let userAddress = i.caller
408-                    let $t01564015829 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
409-                    let poolAddress = $t01564015829._1
410-                    let lpAssetId = $t01564015829._2
408+                    let $t01564215831 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
409+                    let poolAddress = $t01564215831._1
410+                    let lpAssetId = $t01564215831._2
411411                     let period = value(getInteger(keyPeriod(baseAssetId)))
412412                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
413413                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
504504                                     }
505505                             if ((checkDelay == checkDelay))
506506                                 then {
507-                                    let $t02127021451 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
508-                                    let poolAddress = $t02127021451._1
509-                                    let lpAssetId = $t02127021451._2
507+                                    let $t02127221453 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
508+                                    let poolAddress = $t02127221453._1
509+                                    let lpAssetId = $t02127221453._2
510510                                     let stakingReward = valueOrErrorMessage({
511511                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
512512                                         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 
125-func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", toUtf8String(value(baseAssetId)), operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
125+func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", toBase58String(value(baseAssetId)), operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
126126 
127127 
128128 func keyManagerPublicKey () = "%s__managerPublicKey"
129129 
130130 
131131 func keyManagerVaultAddress () = "%s__managerVaultAddress"
132132 
133133 
134134 func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
135135     case s: String => 
136136         addressFromStringValue(s)
137137     case _ => 
138138         this
139139 }
140140 
141141 
142142 func managerPublicKeyOrUnit () = {
143143     let managerVaultAddress = getManagerVaultAddressOrThis()
144144     match getString(managerVaultAddress, keyManagerPublicKey()) {
145145         case s: String => 
146146             fromBase58String(s)
147147         case _: Unit => 
148148             unit
149149         case _ => 
150150             throw("Match error")
151151     }
152152     }
153153 
154154 
155155 let permissionDeniedError = throw("Permission denied")
156156 
157157 func mustThis (i) = if ((i.caller == this))
158158     then true
159159     else permissionDeniedError
160160 
161161 
162162 func mustManager (i) = match managerPublicKeyOrUnit() {
163163     case pk: ByteVector => 
164164         if ((i.callerPublicKey == pk))
165165             then true
166166             else permissionDeniedError
167167     case _: Unit => 
168168         mustThis(i)
169169     case _ => 
170170         throw("Match error")
171171 }
172172 
173173 
174174 let shutdown = valueOrElse(getBoolean(keyShutdown()), false)
175175 
176176 func shutdownCheck (i) = if (if (!(shutdown))
177177     then true
178178     else mustManager(i))
179179     then true
180180     else throw("operation is disabled")
181181 
182182 
183183 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract()))
184184 
185185 let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract()))
186186 
187187 let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract()))
188188 
189189 let boostingContract = addressFromStringValue(getStrOrFail(this, keyBoostingContract()))
190190 
191191 let swapContract = addressFromStringValue(getStrOrFail(this, keySwapContract()))
192192 
193193 let assetsStoreContract = addressFromStringValue(getStrOrFail(this, keyAssetsStoreContract()))
194194 
195195 let usdtAssetId = parseAssetId(getStrOrFail(this, keyUsdtAssetId()))
196196 
197197 let wxAssetId = parseAssetId(getStrOrFail(this, keyWxAssetId()))
198198 
199199 let minDelayDefault = 1440
200200 
201201 let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault)
202202 
203203 let lockFractionMultiplier = 100000000
204204 
205205 let lockFractionDefault = fraction(1, lockFractionMultiplier, 2)
206206 
207207 let lockFraction = valueOrElse(getInteger(this, keyLockFraction()), lockFractionDefault)
208208 
209209 func getPoolInfo (amountAssetId) = {
210210     let amountAssetIdStr = assetIdToString(amountAssetId)
211211     let priceAssetIdStr = assetIdToString(usdtAssetId)
212212     let poolInfoOption = {
213213         let @ = invoke(factoryContract, "poolInfoREADONLY", [amountAssetIdStr, priceAssetIdStr], nil)
214214         if ($isInstanceOf(@, "(Address, ByteVector)"))
215215             then @
216216             else unit
217217         }
218218     poolInfoOption
219219     }
220220 
221221 
222222 func calcPrice (lpAssetId,shareAssetId) = {
223223     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
224224     let shareAssetEmission = shareAssetInfo.quantity
225225     let stakedAmount = ensurePositive(valueOrErrorMessage({
226226         let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
227227         if ($isInstanceOf(@, "Int"))
228228             then @
229229             else unit
230230         }, wrapErr("invalid stakedByUserREADONLY result")))
231231     let price = if ((shareAssetEmission == 0))
232232         then scale18BigInt
233233         else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
234234     price
235235     }
236236 
237237 
238238 @Callable(i)
239239 func emit (assetId,amount) = {
240240     let checkCaller = mustThis(i)
241241     if ((checkCaller == checkCaller))
242242         then {
243243             let isReissuable = true
244244             $Tuple2([Reissue(assetId, amount, isReissuable)], amount)
245245             }
246246         else throw("Strict value is not equal to itself.")
247247     }
248248 
249249 
250250 
251251 @Callable(i)
252252 func burn (assetId,amount) = {
253253     let checkCaller = mustThis(i)
254254     if ((checkCaller == checkCaller))
255255         then $Tuple2([Burn(assetId, amount)], amount)
256256         else throw("Strict value is not equal to itself.")
257257     }
258258 
259259 
260260 
261261 @Callable(i)
262262 func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
263263     let shareAssetLabel = "STAKING_LP"
264264     let baseAssetId = parseAssetId(baseAssetIdStr)
265265     let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId)))
266266         then true
267267         else throwErr("invalid base asset")]
268268     if ((checks == checks))
269269         then {
270270             let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)]
271271             if ((shareAssetIdStr == ""))
272272                 then {
273273                     let shareAssetIssueAmount = 1
274274                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true)
275275                     let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction)
276276                     let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount)
277277                     let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId)
278278                     let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil)
279279                     if ((createOrUpdate == createOrUpdate))
280280                         then {
281281                             let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil)
282282                             if ((addLabel == addLabel))
283283                                 then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr)
284284                                 else throw("Strict value is not equal to itself.")
285285                             }
286286                         else throw("Strict value is not equal to itself.")
287287                     }
288288                 else {
289289                     let shareAssetId = fromBase58String(shareAssetIdStr)
290290                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
291291                     let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract))
292292                         then true
293293                         else throwErr("invalid share asset id issuer")
294294                     if ((checkIssuer == checkIssuer))
295295                         then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyBaseAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr)
296296                         else throw("Strict value is not equal to itself.")
297297                     }
298298             }
299299         else throw("Strict value is not equal to itself.")
300300     }
301301 
302302 
303303 
304304 @Callable(i)
305305 func put () = {
306306     let pmt = if ((size(i.payments) == 1))
307307         then i.payments[0]
308308         else throwErr("exactly 1 payment is expected")
309309     let baseAssetId = pmt.assetId
310310     let userAddress = i.caller
311311     let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
312312         then true
313313         else throwErr("invalid asset")]
314314     if ((checks == checks))
315315         then {
316-            let $t01112711230 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
317-            let poolAddress = $t01112711230._1
318-            let lpAssetId = $t01112711230._2
316+            let $t01112911232 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
317+            let poolAddress = $t01112911232._1
318+            let lpAssetId = $t01112911232._2
319319             let period = value(getInteger(keyPeriod(baseAssetId)))
320320             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
321321             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
322322                 then unit
323323                 else {
324324                     let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption)
325325                     if ((userBaseAssetAmountToConvertPeriod == period))
326326                         then unit
327327                         else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
328328                     }
329329             if ((claimShareAssetInvocation == claimShareAssetInvocation))
330330                 then {
331331                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
332332                     let userBaseAssetAmountToConvert = value(parseInt(split(valueOrElse(getString(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), "%d%d%d__0__0"), separator)[1]))
333333                     $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)
334334                     }
335335                 else throw("Strict value is not equal to itself.")
336336             }
337337         else throw("Strict value is not equal to itself.")
338338     }
339339 
340340 
341341 
342342 @Callable(i)
343343 func claimShareAsset (baseAssetIdStr,userAddressStr) = {
344344     let checks = [shutdownCheck(i)]
345345     if ((checks == checks))
346346         then {
347347             let userAddress = if ((userAddressStr == ""))
348348                 then i.caller
349349                 else {
350350                     let checkCaller = mustThis(i)
351351                     if ((checkCaller == checkCaller))
352352                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
353353                         else throw("Strict value is not equal to itself.")
354354                     }
355355             if ((userAddress == userAddress))
356356                 then {
357357                     let baseAssetId = parseAssetId(baseAssetIdStr)
358358                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
359359                     if ((shareAssetId == shareAssetId))
360360                         then {
361361                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
362362                             if ((period == period))
363363                                 then {
364364                                     let userBaseAssetAmountToConvert = value(parseInt(split(valueOrElse(getString(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), "%d%d%d__0__0"), separator)[1]))
365365                                     let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
366366                                         then true
367367                                         else throwErr("nothing to claim")
368368                                     if ((checkAmountToConvert == checkAmountToConvert))
369369                                         then {
370370                                             let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
371371                                             let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
372372                                                 then true
373373                                                 else throwErr("invalid period")
374374                                             if ((checkPeriod == checkPeriod))
375375                                                 then {
376376                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
377377                                                     let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
378378                                                     $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)
379379                                                     }
380380                                                 else throw("Strict value is not equal to itself.")
381381                                             }
382382                                         else throw("Strict value is not equal to itself.")
383383                                     }
384384                                 else throw("Strict value is not equal to itself.")
385385                             }
386386                         else throw("Strict value is not equal to itself.")
387387                     }
388388                 else throw("Strict value is not equal to itself.")
389389             }
390390         else throw("Strict value is not equal to itself.")
391391     }
392392 
393393 
394394 
395395 @Callable(i)
396396 func get () = {
397397     let checks = [shutdownCheck(i)]
398398     if ((checks == checks))
399399         then {
400400             let pmt = if ((size(i.payments) == 1))
401401                 then i.payments[0]
402402                 else throwErr("exactly 1 payment is expected")
403403             let shareAssetId = pmt.assetId
404404             let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
405405             if ((baseAssetId == baseAssetId))
406406                 then {
407407                     let userAddress = i.caller
408-                    let $t01564015829 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
409-                    let poolAddress = $t01564015829._1
410-                    let lpAssetId = $t01564015829._2
408+                    let $t01564215831 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
409+                    let poolAddress = $t01564215831._1
410+                    let lpAssetId = $t01564215831._2
411411                     let period = value(getInteger(keyPeriod(baseAssetId)))
412412                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
413413                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
414414                         then unit
415415                         else {
416416                             let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
417417                             if ((userShareAssetAmountToConvertPeriod == period))
418418                                 then unit
419419                                 else invoke(this, "claimBaseAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
420420                             }
421421                     if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
422422                         then {
423423                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
424424                             let userShareAssetAmountToConvert = value(parseInt(split(valueOrElse(getString(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), "%d%d%d__0__0"), separator)[1]))
425425                             $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)
426426                             }
427427                         else throw("Strict value is not equal to itself.")
428428                     }
429429                 else throw("Strict value is not equal to itself.")
430430             }
431431         else throw("Strict value is not equal to itself.")
432432     }
433433 
434434 
435435 
436436 @Callable(i)
437437 func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
438438     let checks = [shutdownCheck(i)]
439439     if ((checks == checks))
440440         then {
441441             let userAddress = if ((userAddressStr == ""))
442442                 then i.caller
443443                 else {
444444                     let checkCaller = mustThis(i)
445445                     if ((checkCaller == checkCaller))
446446                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
447447                         else throw("Strict value is not equal to itself.")
448448                     }
449449             if ((userAddress == userAddress))
450450                 then {
451451                     let baseAssetId = parseAssetId(baseAssetIdStr)
452452                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
453453                     if ((shareAssetId == shareAssetId))
454454                         then {
455455                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
456456                             if ((period == period))
457457                                 then {
458458                                     let userShareAssetAmountToConvert = value(parseInt(split(valueOrElse(getString(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), "%d%d%d__0__0"), separator)[1]))
459459                                     let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
460460                                     let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
461461                                         then true
462462                                         else throwErr("invalid period")
463463                                     if ((checkPeriod == checkPeriod))
464464                                         then {
465465                                             let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
466466                                             let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
467467                                             $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)
468468                                             }
469469                                         else throw("Strict value is not equal to itself.")
470470                                     }
471471                                 else throw("Strict value is not equal to itself.")
472472                             }
473473                         else throw("Strict value is not equal to itself.")
474474                     }
475475                 else throw("Strict value is not equal to itself.")
476476             }
477477         else throw("Strict value is not equal to itself.")
478478     }
479479 
480480 
481481 
482482 @Callable(i)
483483 func finalize (baseAssetIdStr) = {
484484     let checks = [shutdownCheck(i)]
485485     if ((checks == checks))
486486         then {
487487             let baseAssetId = parseAssetId(baseAssetIdStr)
488488             let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
489489             if ((shareAssetId == shareAssetId))
490490                 then {
491491                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
492492                     let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
493493                     if ((period == period))
494494                         then {
495495                             let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
496496                             let checkDelay = if ((periodStartHeightOption == unit))
497497                                 then unit
498498                                 else {
499499                                     let delay = (height - value(periodStartHeightOption))
500500                                     let blocksToWait = max([0, (minDelay - delay)])
501501                                     if ((blocksToWait == 0))
502502                                         then unit
503503                                         else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
504504                                     }
505505                             if ((checkDelay == checkDelay))
506506                                 then {
507-                                    let $t02127021451 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
508-                                    let poolAddress = $t02127021451._1
509-                                    let lpAssetId = $t02127021451._2
507+                                    let $t02127221453 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
508+                                    let poolAddress = $t02127221453._1
509+                                    let lpAssetId = $t02127221453._2
510510                                     let stakingReward = valueOrErrorMessage({
511511                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
512512                                         if ($isInstanceOf(@, "Int"))
513513                                             then @
514514                                             else unit
515515                                         }, wrapErr("invalid claimWx result"))
516516                                     if ((stakingReward == stakingReward))
517517                                         then {
518518                                             let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
519519                                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
520520                                             let checkFinalizationIsRequired = {
521521                                                 let isFinalizationRequired = if (if ((stakingReward > 0))
522522                                                     then true
523523                                                     else (baseAssetAmountToConvert > 0))
524524                                                     then true
525525                                                     else (shareAssetAmountToConvert > 0)
526526                                                 if (isFinalizationRequired)
527527                                                     then true
528528                                                     else throwErr("nothing to finalize")
529529                                                 }
530530                                             if ((checkFinalizationIsRequired == checkFinalizationIsRequired))
531531                                                 then {
532532                                                     let useStakingReward = if ((stakingReward > 0))
533533                                                         then {
534534                                                             let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier)
535535                                                             let convertPart = (stakingReward - lockPart)
536536                                                             let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
537537                                                             let lock = if ((lockPart > 0))
538538                                                                 then                                                                 match r {
539539                                                                     case _ => 
540540                                                                         if (if (if ($isInstanceOf($match0._1, "String"))
541541                                                                             then $isInstanceOf($match0._2, "Int")
542542                                                                             else false)
543543                                                                             then $isInstanceOf($match0, "(String, Int)")
544544                                                                             else false)
545545                                                                             then {
546546                                                                                 let function = $match0._1
547547                                                                                 let duration = $match0._2
548548                                                                                 if ((lockPart > 0))
549549                                                                                     then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
550550                                                                                     else unit
551551                                                                                 }
552552                                                                             else throwErr("invalid lock params")
553553                                                                 }
554554                                                                 else unit
555555                                                             if ((lock == lock))
556556                                                                 then {
557557                                                                     let convertedAmount = if ((convertPart > 0))
558558                                                                         then {
559559                                                                             let inAssetId = wxAssetId
560560                                                                             let minimumToReceive = 0
561561                                                                             let outAssetIdStr = assetIdToString(usdtAssetId)
562562                                                                             let targetAddress = toString(this)
563563                                                                             valueOrErrorMessage({
564564                                                                                 let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
565565                                                                                 if ($isInstanceOf(@, "Int"))
566566                                                                                     then @
567567                                                                                     else unit
568568                                                                                 }, wrapErr("invalid swap result"))
569569                                                                             }
570570                                                                         else 0
571571                                                                     if ((convertedAmount == convertedAmount))
572572                                                                         then {
573573                                                                             let lpAssetAmount = if ((convertedAmount > 0))
574574                                                                                 then {
575575                                                                                     let minOutAmount = 0
576576                                                                                     let autoStake = true
577577                                                                                     valueOrErrorMessage({
578578                                                                                         let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdtAssetId, convertedAmount)])
579579                                                                                         if ($isInstanceOf(@, "Int"))
580580                                                                                             then @
581581                                                                                             else unit
582582                                                                                         }, wrapErr("invalid putOneTknV2 result"))
583583                                                                                     }
584584                                                                                 else 0
585585                                                                             if ((lpAssetAmount == lpAssetAmount))
586586                                                                                 then lpAssetAmount
587587                                                                                 else throw("Strict value is not equal to itself.")
588588                                                                             }
589589                                                                         else throw("Strict value is not equal to itself.")
590590                                                                     }
591591                                                                 else throw("Strict value is not equal to itself.")
592592                                                             }
593593                                                         else unit
594594                                                     if ((useStakingReward == useStakingReward))
595595                                                         then {
596596                                                             let getActions = if ((shareAssetAmountToConvert > 0))
597597                                                                 then {
598598                                                                     let price = calcPrice(lpAssetId, shareAssetId)
599599                                                                     if ((price == price))
600600                                                                         then {
601601                                                                             let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
602602                                                                             let baseAssetAmount = {
603603                                                                                 let outAssetId = baseAssetId
604604                                                                                 let minOutAmount = 0
605605                                                                                 valueOrErrorMessage({
606606                                                                                     let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
607607                                                                                     if ($isInstanceOf(@, "Int"))
608608                                                                                         then @
609609                                                                                         else unit
610610                                                                                     }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
611611                                                                                 }
612612                                                                             if ((baseAssetAmount == baseAssetAmount))
613613                                                                                 then {
614614                                                                                     let shareAssetBurn = if ((shareAssetInfo.issuer == this))
615615                                                                                         then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
616616                                                                                         else throwErr("invalid share asset issuer")
617617                                                                                     if ((shareAssetBurn == shareAssetBurn))
618618                                                                                         then {
619619                                                                                             let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
620620                                                                                             let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
621621                                                                                             priceGetUpdateActions
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 throw("Strict value is not equal to itself.")
628628                                                                     }
629629                                                                 else nil
630630                                                             if ((getActions == getActions))
631631                                                                 then {
632632                                                                     let putActions = if ((baseAssetAmountToConvert > 0))
633633                                                                         then {
634634                                                                             let lpAssetAmount = {
635635                                                                                 let minOutAmount = 0
636636                                                                                 let autoStake = true
637637                                                                                 valueOrErrorMessage({
638638                                                                                     let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
639639                                                                                     if ($isInstanceOf(@, "Int"))
640640                                                                                         then @
641641                                                                                         else unit
642642                                                                                     }, wrapErr("invalid putOneTknV2 result"))
643643                                                                                 }
644644                                                                             if ((lpAssetAmount == lpAssetAmount))
645645                                                                                 then {
646646                                                                                     let price = calcPrice(lpAssetId, shareAssetId)
647647                                                                                     if ((price == price))
648648                                                                                         then {
649649                                                                                             let checkPrice = if ((value(toInt(price)) != 0))
650650                                                                                                 then true
651651                                                                                                 else throw("price is ZERO")
652652                                                                                             if ((checkPrice == checkPrice))
653653                                                                                                 then {
654654                                                                                                     let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
655655                                                                                                     let checkShareAssetAmount = if ((value(toInt(price)) != 0))
656656                                                                                                         then true
657657                                                                                                         else throw("shareAssetAmount is ZERO")
658658                                                                                                     if ((checkShareAssetAmount == checkShareAssetAmount))
659659                                                                                                         then {
660660                                                                                                             let shareAssetReissue = if ((shareAssetInfo.issuer == this))
661661                                                                                                                 then invoke(this, "emit", [shareAssetId, shareAssetAmount], nil)
662662                                                                                                                 else throwErr("invalid share asset issuer")
663663                                                                                                             if ((shareAssetReissue == shareAssetReissue))
664664                                                                                                                 then {
665665                                                                                                                     let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
666666                                                                                                                     let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
667667                                                                                                                     pricePutUpdateActions
668668                                                                                                                     }
669669                                                                                                                 else throw("Strict value is not equal to itself.")
670670                                                                                                             }
671671                                                                                                         else throw("Strict value is not equal to itself.")
672672                                                                                                     }
673673                                                                                                 else throw("Strict value is not equal to itself.")
674674                                                                                             }
675675                                                                                         else throw("Strict value is not equal to itself.")
676676                                                                                     }
677677                                                                                 else throw("Strict value is not equal to itself.")
678678                                                                             }
679679                                                                         else nil
680680                                                                     if ((putActions == putActions))
681681                                                                         then {
682682                                                                             let newPeriod = (period + 1)
683683                                                                             let lastPrice = calcPrice(lpAssetId, shareAssetId)
684684                                                                             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)
685685                                                                             $Tuple2(actions, toBytes(lastPrice))
686686                                                                             }
687687                                                                         else throw("Strict value is not equal to itself.")
688688                                                                     }
689689                                                                 else throw("Strict value is not equal to itself.")
690690                                                             }
691691                                                         else throw("Strict value is not equal to itself.")
692692                                                     }
693693                                                 else throw("Strict value is not equal to itself.")
694694                                             }
695695                                         else throw("Strict value is not equal to itself.")
696696                                     }
697697                                 else throw("Strict value is not equal to itself.")
698698                             }
699699                         else throw("Strict value is not equal to itself.")
700700                     }
701701                 else throw("Strict value is not equal to itself.")
702702             }
703703         else throw("Strict value is not equal to itself.")
704704     }
705705 
706706 
707707 @Verifier(tx)
708708 func verify () = {
709709     let targetPublicKey =     match managerPublicKeyOrUnit() {
710710         case pk: ByteVector => 
711711             pk
712712         case _: Unit => 
713713             tx.senderPublicKey
714714         case _ => 
715715             throw("Match error")
716716     }
717717     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
718718     }
719719 
github/deemru/w8io/026f985 
82.66 ms ◑