tx · GHCAn7JynJZEEaSwhguPyhVcaegkiEotn52o4cXeDtuM

3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV:  -0.02800000 Waves

2023.01.11 15:37 [2400301] smart account 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GHCAn7JynJZEEaSwhguPyhVcaegkiEotn52o4cXeDtuM",
    "fee": 2800000,
    "feeAssetId": null,
    "timestamp": 1673440682685,
    "version": 1,
    "sender": "3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV",
    "senderPublicKey": "F4oaTkX67vt2MEsXLJJ8a7gaURGjW7x8fkvGfdEiH5oy",
    "proofs": [
        "2wyyM16Co1oPSDB3xB5U2ENRMR82NkVQjoSxp54YRXZrniVYLXwqq76Qu7we6gUQW1kwWj8LoAv4C3BjGQ6kcQQL"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2400301,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 7exsjLKnvz3qfjpTcdYXggQh48K885hb37rmxzTqsySk
Next: 8eiEqTQeRiZvYGfAvy3xgZfWWzsvDfiU6dLUXYxoAjsh

Diff: 

OldNewDifferences
6969 
7070 
7171 func keyMinDelay () = makeString(["%s", "minDelay"], separator)
72+
73+
74+func keyLockFraction () = makeString(["%s", "lockFraction"], separator)
7275 
7376 
7477 func keyShareAssetId (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetId"], separator)
196199 
197200 let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault)
198201 
202+let lockFractionMultiplier = 100000000
203+
204+let lockFractionDefault = fraction(1, lockFractionMultiplier, 2)
205+
206+let lockFraction = valueOrElse(getInteger(this, keyLockFraction()), lockFractionDefault)
207+
199208 func getPoolInfo (amountAssetId) = {
200209     let amountAssetIdStr = assetIdToString(amountAssetId)
201210     let priceAssetIdStr = assetIdToString(usdnAssetId)
315324         else throwErr("invalid asset")]
316325     if ((checks == checks))
317326         then {
318-            let $t01103211135 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
319-            let poolAddress = $t01103211135._1
320-            let lpAssetId = $t01103211135._2
327+            let $t01131211415 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
328+            let poolAddress = $t01131211415._1
329+            let lpAssetId = $t01131211415._2
321330             let period = value(getInteger(keyPeriod(baseAssetId)))
322331             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
323332             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
407416             if ((baseAssetId == baseAssetId))
408417                 then {
409418                     let userAddress = i.caller
410-                    let $t01483614939 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
411-                    let poolAddress = $t01483614939._1
412-                    let lpAssetId = $t01483614939._2
419+                    let $t01511615219 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
420+                    let poolAddress = $t01511615219._1
421+                    let lpAssetId = $t01511615219._2
413422                     let period = value(getInteger(keyPeriod(baseAssetId)))
414423                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
415424                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
512521                                     }
513522                             if ((checkDelay == checkDelay))
514523                                 then {
515-                                    let $t01888119097 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
516-                                    let poolAddress = $t01888119097._1
517-                                    let lpAssetId = $t01888119097._2
524+                                    let $t01916119377 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
525+                                    let poolAddress = $t01916119377._1
526+                                    let lpAssetId = $t01916119377._2
518527                                     let stakingReward = valueOrErrorMessage({
519528                                         let @ = invoke(stakingContract, "claimWx", [assetIdToString(lpAssetId)], nil)
520529                                         if ($isInstanceOf(@, "Int"))
525534                                         then {
526535                                             let useStakingReward = if ((stakingReward > 0))
527536                                                 then {
528-                                                    let lockPart = (stakingReward / 2)
537+                                                    let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier)
529538                                                     let convertPart = (stakingReward - lockPart)
530539                                                     let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
531540                                                     let lock =                                                     match r {

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let separator = "__"
55 
66 let shareAssetDecimals = 8
77 
88 let wavesString = "WAVES"
99 
1010 let scale18 = 1000000000000000000
1111 
1212 let scale18BigInt = toBigInt(scale18)
1313 
1414 func wrapErr (msg) = makeString(["lp_staking_pools.ride:", msg], " ")
1515 
1616 
1717 func throwErr (msg) = throw(wrapErr(msg))
1818 
1919 
2020 func errKeyIsNotDefined (address,key) = wrapErr(makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
2121 
2222 
2323 func getStrOrFail (address,key) = valueOrErrorMessage(getString(address, key), errKeyIsNotDefined(address, key))
2424 
2525 
2626 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), errKeyIsNotDefined(address, key))
2727 
2828 
2929 func parseAssetId (input) = if ((input == wavesString))
3030     then unit
3131     else fromBase58String(input)
3232 
3333 
3434 func assetIdToString (input) = if ((input == unit))
3535     then wavesString
3636     else toBase58String(value(input))
3737 
3838 
3939 func ensurePositive (v) = if ((v >= 0))
4040     then v
4141     else throwErr("value should be positive")
4242 
4343 
4444 func keyFactoryContract () = makeString(["%s", "factoryContract"], separator)
4545 
4646 
4747 func keyLpStakingContract () = makeString(["%s", "lpStakingContract"], separator)
4848 
4949 
5050 func keyStakingContract () = makeString(["%s", "stakingContract"], separator)
5151 
5252 
5353 func keyBoostingContract () = makeString(["%s", "boostingContract"], separator)
5454 
5555 
5656 func keySwapContract () = makeString(["%s", "swapContract"], separator)
5757 
5858 
5959 func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], separator)
6060 
6161 
6262 func keyUsdnAssetId () = makeString(["%s", "usdnAssetId"], separator)
6363 
6464 
6565 func keyWxAssetId () = makeString(["%s", "wxAssetId"], separator)
6666 
6767 
6868 func keyShutdown () = makeString(["%s", "shutdown"], separator)
6969 
7070 
7171 func keyMinDelay () = makeString(["%s", "minDelay"], separator)
72+
73+
74+func keyLockFraction () = makeString(["%s", "lockFraction"], separator)
7275 
7376 
7477 func keyShareAssetId (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetId"], separator)
7578 
7679 
7780 func keyBaseAssetId (shareAssetId) = makeString(["%s%s", assetIdToString(shareAssetId), "baseAssetId"], separator)
7881 
7982 
8083 func keyPeriod (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "period"], separator)
8184 
8285 
8386 func keyPeriodStartHeight (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "periodStartHeight", toString(period)], separator)
8487 
8588 
8689 func keyBaseAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "baseAssetAmountToConvert"], separator)
8790 
8891 
8992 func keyShareAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetAmountToConvert"], separator)
9093 
9194 
9295 func keyUserBaseAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert"], separator)
9396 
9497 
9598 func keyUserBaseAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert", "period"], separator)
9699 
97100 
98101 func keyUserShareAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert"], separator)
99102 
100103 
101104 func keyUserShareAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert", "period"], separator)
102105 
103106 
104107 func keyPricePeriod (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "price", toString(period)], separator)
105108 
106109 
107110 func keyPriceHistory (baseAssetId) = makeString(["%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
108111 
109112 
110113 func keyPricePeriodPut (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "put"], separator)
111114 
112115 
113116 func keyPricePutHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "put", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
114117 
115118 
116119 func keyPricePeriodGet (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "get"], separator)
117120 
118121 
119122 func keyPriceGetHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "get", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
120123 
121124 
122125 func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
123126 
124127 
125128 func keyManagerPublicKey () = "%s__managerPublicKey"
126129 
127130 
128131 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
129132 
130133 
131134 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
132135     case s: String => 
133136         fromBase58String(s)
134137     case _: Unit => 
135138         unit
136139     case _ => 
137140         throw("Match error")
138141 }
139142 
140143 
141144 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
142145     case s: String => 
143146         fromBase58String(s)
144147     case _: Unit => 
145148         unit
146149     case _ => 
147150         throw("Match error")
148151 }
149152 
150153 
151154 let permissionDeniedError = throw("Permission denied")
152155 
153156 func mustThis (i) = if ((i.caller == this))
154157     then true
155158     else permissionDeniedError
156159 
157160 
158161 func mustManager (i) = match managerPublicKeyOrUnit() {
159162     case pk: ByteVector => 
160163         if ((i.callerPublicKey == pk))
161164             then true
162165             else permissionDeniedError
163166     case _: Unit => 
164167         mustThis(i)
165168     case _ => 
166169         throw("Match error")
167170 }
168171 
169172 
170173 let shutdown = valueOrElse(getBoolean(keyShutdown()), false)
171174 
172175 func shutdownCheck (i) = if (if (!(shutdown))
173176     then true
174177     else mustManager(i))
175178     then true
176179     else throw("operation is disabled")
177180 
178181 
179182 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract()))
180183 
181184 let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract()))
182185 
183186 let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract()))
184187 
185188 let boostingContract = addressFromStringValue(getStrOrFail(this, keyBoostingContract()))
186189 
187190 let swapContract = addressFromStringValue(getStrOrFail(this, keySwapContract()))
188191 
189192 let assetsStoreContract = addressFromStringValue(getStrOrFail(this, keyAssetsStoreContract()))
190193 
191194 let usdnAssetId = parseAssetId(getStrOrFail(this, keyUsdnAssetId()))
192195 
193196 let wxAssetId = parseAssetId(getStrOrFail(this, keyWxAssetId()))
194197 
195198 let minDelayDefault = 1440
196199 
197200 let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault)
198201 
202+let lockFractionMultiplier = 100000000
203+
204+let lockFractionDefault = fraction(1, lockFractionMultiplier, 2)
205+
206+let lockFraction = valueOrElse(getInteger(this, keyLockFraction()), lockFractionDefault)
207+
199208 func getPoolInfo (amountAssetId) = {
200209     let amountAssetIdStr = assetIdToString(amountAssetId)
201210     let priceAssetIdStr = assetIdToString(usdnAssetId)
202211     let poolInfoOption = {
203212         let @ = invoke(factoryContract, "poolInfoREADONLY", [amountAssetIdStr, priceAssetIdStr], nil)
204213         if ($isInstanceOf(@, "(Address, ByteVector)"))
205214             then @
206215             else unit
207216         }
208217     poolInfoOption
209218     }
210219 
211220 
212221 func calcPrice (lpAssetId,shareAssetId) = {
213222     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
214223     let shareAssetEmission = shareAssetInfo.quantity
215224     let stakedAmount = ensurePositive(valueOrErrorMessage({
216225         let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
217226         if ($isInstanceOf(@, "Int"))
218227             then @
219228             else unit
220229         }, wrapErr("invalid stakedByUserREADONLY result")))
221230     let price = if ((shareAssetEmission == 0))
222231         then scale18BigInt
223232         else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
224233     price
225234     }
226235 
227236 
228237 @Callable(i)
229238 func setManager (pendingManagerPublicKey) = {
230239     let checkCaller = mustManager(i)
231240     if ((checkCaller == checkCaller))
232241         then {
233242             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
234243             if ((checkManagerPublicKey == checkManagerPublicKey))
235244                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
236245                 else throw("Strict value is not equal to itself.")
237246             }
238247         else throw("Strict value is not equal to itself.")
239248     }
240249 
241250 
242251 
243252 @Callable(i)
244253 func confirmManager () = {
245254     let pm = pendingManagerPublicKeyOrUnit()
246255     let hasPM = if (isDefined(pm))
247256         then true
248257         else throwErr("no pending manager")
249258     if ((hasPM == hasPM))
250259         then {
251260             let checkPM = if ((i.callerPublicKey == value(pm)))
252261                 then true
253262                 else throwErr("you are not pending manager")
254263             if ((checkPM == checkPM))
255264                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
256265                 else throw("Strict value is not equal to itself.")
257266             }
258267         else throw("Strict value is not equal to itself.")
259268     }
260269 
261270 
262271 
263272 @Callable(i)
264273 func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
265274     let shareAssetLabel = "LP_STAKING_POOLS"
266275     let baseAssetId = parseAssetId(baseAssetIdStr)
267276     let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId)))
268277         then true
269278         else throwErr("invalid base asset")]
270279     if ((checks == checks))
271280         then {
272281             let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)]
273282             if ((shareAssetIdStr == ""))
274283                 then {
275284                     let shareAssetIssueAmount = 1
276285                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true)
277286                     let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction)
278287                     let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount)
279288                     let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId)
280289                     let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil)
281290                     if ((createOrUpdate == createOrUpdate))
282291                         then {
283292                             let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil)
284293                             if ((addLabel == addLabel))
285294                                 then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr)
286295                                 else throw("Strict value is not equal to itself.")
287296                             }
288297                         else throw("Strict value is not equal to itself.")
289298                     }
290299                 else {
291300                     let shareAssetId = fromBase58String(shareAssetIdStr)
292301                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
293302                     let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract))
294303                         then true
295304                         else throwErr("invalid share asset id issuer")
296305                     if ((checkIssuer == checkIssuer))
297306                         then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyShareAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr)
298307                         else throw("Strict value is not equal to itself.")
299308                     }
300309             }
301310         else throw("Strict value is not equal to itself.")
302311     }
303312 
304313 
305314 
306315 @Callable(i)
307316 func put () = {
308317     let pmt = if ((size(i.payments) == 1))
309318         then i.payments[0]
310319         else throwErr("exactly 1 payment is expected")
311320     let baseAssetId = pmt.assetId
312321     let userAddress = i.caller
313322     let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
314323         then true
315324         else throwErr("invalid asset")]
316325     if ((checks == checks))
317326         then {
318-            let $t01103211135 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
319-            let poolAddress = $t01103211135._1
320-            let lpAssetId = $t01103211135._2
327+            let $t01131211415 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
328+            let poolAddress = $t01131211415._1
329+            let lpAssetId = $t01131211415._2
321330             let period = value(getInteger(keyPeriod(baseAssetId)))
322331             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
323332             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
324333                 then unit
325334                 else {
326335                     let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption)
327336                     if ((userBaseAssetAmountToConvertPeriod == period))
328337                         then unit
329338                         else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
330339                     }
331340             if ((claimShareAssetInvocation == claimShareAssetInvocation))
332341                 then {
333342                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
334343                     let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
335344                     $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), (userBaseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), pmt.amount)], unit)
336345                     }
337346                 else throw("Strict value is not equal to itself.")
338347             }
339348         else throw("Strict value is not equal to itself.")
340349     }
341350 
342351 
343352 
344353 @Callable(i)
345354 func claimShareAsset (baseAssetIdStr,userAddressStr) = {
346355     let checks = [shutdownCheck(i)]
347356     if ((checks == checks))
348357         then {
349358             let userAddress = if ((userAddressStr == ""))
350359                 then i.caller
351360                 else {
352361                     let checkCaller = mustThis(i)
353362                     if ((checkCaller == checkCaller))
354363                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
355364                         else throw("Strict value is not equal to itself.")
356365                     }
357366             if ((userAddress == userAddress))
358367                 then {
359368                     let baseAssetId = parseAssetId(baseAssetIdStr)
360369                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
361370                     if ((shareAssetId == shareAssetId))
362371                         then {
363372                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
364373                             if ((period == period))
365374                                 then {
366375                                     let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
367376                                     let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
368377                                         then true
369378                                         else throwErr("nothing to claim")
370379                                     if ((checkAmountToConvert == checkAmountToConvert))
371380                                         then {
372381                                             let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
373382                                             let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
374383                                                 then true
375384                                                 else throwErr("invalid period")
376385                                             if ((checkPeriod == checkPeriod))
377386                                                 then {
378387                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
379388                                                     let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
380389                                                     $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), shareAssetAmount)], unit)
381390                                                     }
382391                                                 else throw("Strict value is not equal to itself.")
383392                                             }
384393                                         else throw("Strict value is not equal to itself.")
385394                                     }
386395                                 else throw("Strict value is not equal to itself.")
387396                             }
388397                         else throw("Strict value is not equal to itself.")
389398                     }
390399                 else throw("Strict value is not equal to itself.")
391400             }
392401         else throw("Strict value is not equal to itself.")
393402     }
394403 
395404 
396405 
397406 @Callable(i)
398407 func get () = {
399408     let checks = [shutdownCheck(i)]
400409     if ((checks == checks))
401410         then {
402411             let pmt = if ((size(i.payments) == 1))
403412                 then i.payments[0]
404413                 else throwErr("exactly 1 payment is expected")
405414             let shareAssetId = pmt.assetId
406415             let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
407416             if ((baseAssetId == baseAssetId))
408417                 then {
409418                     let userAddress = i.caller
410-                    let $t01483614939 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
411-                    let poolAddress = $t01483614939._1
412-                    let lpAssetId = $t01483614939._2
419+                    let $t01511615219 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
420+                    let poolAddress = $t01511615219._1
421+                    let lpAssetId = $t01511615219._2
413422                     let period = value(getInteger(keyPeriod(baseAssetId)))
414423                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
415424                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
416425                         then unit
417426                         else {
418427                             let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
419428                             if ((userShareAssetAmountToConvertPeriod == period))
420429                                 then unit
421430                                 else invoke(this, "claimBaseAsset", [userAddress], nil)
422431                             }
423432                     if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
424433                         then {
425434                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
426435                             let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
427436                             $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), pmt.amount)], unit)
428437                             }
429438                         else throw("Strict value is not equal to itself.")
430439                     }
431440                 else throw("Strict value is not equal to itself.")
432441             }
433442         else throw("Strict value is not equal to itself.")
434443     }
435444 
436445 
437446 
438447 @Callable(i)
439448 func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
440449     let checks = [shutdownCheck(i)]
441450     if ((checks == checks))
442451         then {
443452             let userAddress = if ((userAddressStr == ""))
444453                 then i.caller
445454                 else {
446455                     let checkCaller = mustThis(i)
447456                     if ((checkCaller == checkCaller))
448457                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
449458                         else throw("Strict value is not equal to itself.")
450459                     }
451460             if ((userAddress == userAddress))
452461                 then {
453462                     let baseAssetId = parseAssetId(baseAssetIdStr)
454463                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
455464                     if ((shareAssetId == shareAssetId))
456465                         then {
457466                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
458467                             if ((period == period))
459468                                 then {
460469                                     let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
461470                                     let checkAmountToConvert = if ((userShareAssetAmountToConvert > 0))
462471                                         then true
463472                                         else throwErr("nothing to claim")
464473                                     if ((checkAmountToConvert == checkAmountToConvert))
465474                                         then {
466475                                             let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
467476                                             let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
468477                                                 then true
469478                                                 else throwErr("invalid period")
470479                                             if ((checkPeriod == checkPeriod))
471480                                                 then {
472481                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
473482                                                     let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
474483                                                     $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), baseAssetAmount)], unit)
475484                                                     }
476485                                                 else throw("Strict value is not equal to itself.")
477486                                             }
478487                                         else throw("Strict value is not equal to itself.")
479488                                     }
480489                                 else throw("Strict value is not equal to itself.")
481490                             }
482491                         else throw("Strict value is not equal to itself.")
483492                     }
484493                 else throw("Strict value is not equal to itself.")
485494             }
486495         else throw("Strict value is not equal to itself.")
487496     }
488497 
489498 
490499 
491500 @Callable(i)
492501 func finalize (baseAssetIdStr) = {
493502     let checks = [shutdownCheck(i)]
494503     if ((checks == checks))
495504         then {
496505             let baseAssetId = parseAssetId(baseAssetIdStr)
497506             let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
498507             if ((shareAssetId == shareAssetId))
499508                 then {
500509                     let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
501510                     if ((period == period))
502511                         then {
503512                             let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
504513                             let checkDelay = if ((periodStartHeightOption == unit))
505514                                 then unit
506515                                 else {
507516                                     let delay = (height - value(periodStartHeightOption))
508517                                     let blocksToWait = min([0, (minDelay - delay)])
509518                                     if ((blocksToWait == 0))
510519                                         then unit
511520                                         else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
512521                                     }
513522                             if ((checkDelay == checkDelay))
514523                                 then {
515-                                    let $t01888119097 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
516-                                    let poolAddress = $t01888119097._1
517-                                    let lpAssetId = $t01888119097._2
524+                                    let $t01916119377 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
525+                                    let poolAddress = $t01916119377._1
526+                                    let lpAssetId = $t01916119377._2
518527                                     let stakingReward = valueOrErrorMessage({
519528                                         let @ = invoke(stakingContract, "claimWx", [assetIdToString(lpAssetId)], nil)
520529                                         if ($isInstanceOf(@, "Int"))
521530                                             then @
522531                                             else unit
523532                                         }, wrapErr("invalid claimWx result"))
524533                                     if ((stakingReward == stakingReward))
525534                                         then {
526535                                             let useStakingReward = if ((stakingReward > 0))
527536                                                 then {
528-                                                    let lockPart = (stakingReward / 2)
537+                                                    let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier)
529538                                                     let convertPart = (stakingReward - lockPart)
530539                                                     let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
531540                                                     let lock =                                                     match r {
532541                                                         case _ => 
533542                                                             if (if (if ($isInstanceOf($match0._1, "String"))
534543                                                                 then $isInstanceOf($match0._2, "Int")
535544                                                                 else false)
536545                                                                 then $isInstanceOf($match0, "(String, Int)")
537546                                                                 else false)
538547                                                                 then {
539548                                                                     let function = $match0._1
540549                                                                     let duration = $match0._2
541550                                                                     if ((lockPart > 0))
542551                                                                         then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
543552                                                                         else unit
544553                                                                     }
545554                                                                 else throwErr("invalid lock params")
546555                                                     }
547556                                                     if ((lock == lock))
548557                                                         then {
549558                                                             let convertedAmount = {
550559                                                                 let inAssetId = wxAssetId
551560                                                                 let minimumToReceive = 0
552561                                                                 let outAssetIdStr = assetIdToString(usdnAssetId)
553562                                                                 let targetAddress = ""
554563                                                                 valueOrErrorMessage({
555564                                                                     let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
556565                                                                     if ($isInstanceOf(@, "Int"))
557566                                                                         then @
558567                                                                         else unit
559568                                                                     }, wrapErr("invalid swap result"))
560569                                                                 }
561570                                                             if ((convertedAmount == convertedAmount))
562571                                                                 then {
563572                                                                     let lpAssetAmount = {
564573                                                                         let minOutAmount = 0
565574                                                                         let autoStake = true
566575                                                                         valueOrErrorMessage({
567576                                                                             let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdnAssetId, convertedAmount)])
568577                                                                             if ($isInstanceOf(@, "Int"))
569578                                                                                 then @
570579                                                                                 else unit
571580                                                                             }, wrapErr("invalid putOneTknV2 result"))
572581                                                                         }
573582                                                                     if ((lpAssetAmount == lpAssetAmount))
574583                                                                         then lpAssetAmount
575584                                                                         else throw("Strict value is not equal to itself.")
576585                                                                     }
577586                                                                 else throw("Strict value is not equal to itself.")
578587                                                             }
579588                                                         else throw("Strict value is not equal to itself.")
580589                                                     }
581590                                                 else unit
582591                                             if ((useStakingReward == useStakingReward))
583592                                                 then {
584593                                                     let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
585594                                                     let getActions = if ((shareAssetAmountToConvert > 0))
586595                                                         then {
587596                                                             let price = calcPrice(lpAssetId, shareAssetId)
588597                                                             if ((price == price))
589598                                                                 then {
590599                                                                     let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
591600                                                                     let baseAssetAmount = {
592601                                                                         let outAssetId = baseAssetId
593602                                                                         let minOutAmount = 0
594603                                                                         valueOrErrorMessage({
595604                                                                             let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
596605                                                                             if ($isInstanceOf(@, "Int"))
597606                                                                                 then @
598607                                                                                 else unit
599608                                                                             }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
600609                                                                         }
601610                                                                     if ((baseAssetAmount == baseAssetAmount))
602611                                                                         then {
603612                                                                             let shareAssetBurnActions = [Burn(shareAssetId, shareAssetAmountToConvert)]
604613                                                                             let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
605614                                                                             let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
606615                                                                             (shareAssetBurnActions ++ priceGetUpdateActions)
607616                                                                             }
608617                                                                         else throw("Strict value is not equal to itself.")
609618                                                                     }
610619                                                                 else throw("Strict value is not equal to itself.")
611620                                                             }
612621                                                         else nil
613622                                                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
614623                                                     let putActions = if ((baseAssetAmountToConvert > 0))
615624                                                         then {
616625                                                             let lpAssetAmount = {
617626                                                                 let minOutAmount = 0
618627                                                                 let autoStake = true
619628                                                                 valueOrErrorMessage({
620629                                                                     let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
621630                                                                     if ($isInstanceOf(@, "Int"))
622631                                                                         then @
623632                                                                         else unit
624633                                                                     }, wrapErr("invalid putOneTknV2 result"))
625634                                                                 }
626635                                                             if ((lpAssetAmount == lpAssetAmount))
627636                                                                 then {
628637                                                                     let price = calcPrice(lpAssetId, shareAssetId)
629638                                                                     if ((price == price))
630639                                                                         then {
631640                                                                             let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
632641                                                                             let isReissuable = true
633642                                                                             let shareAssetReissueActions = [Reissue(shareAssetId, shareAssetAmount, isReissuable)]
634643                                                                             let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
635644                                                                             let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
636645                                                                             (shareAssetReissueActions ++ pricePutUpdateActions)
637646                                                                             }
638647                                                                         else throw("Strict value is not equal to itself.")
639648                                                                     }
640649                                                                 else throw("Strict value is not equal to itself.")
641650                                                             }
642651                                                         else nil
643652                                                     let newPeriod = (period + 1)
644653                                                     let lastPrice = calcPrice(lpAssetId, shareAssetId)
645654                                                     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)
646655                                                     $Tuple2(actions, toBytes(lastPrice))
647656                                                     }
648657                                                 else throw("Strict value is not equal to itself.")
649658                                             }
650659                                         else throw("Strict value is not equal to itself.")
651660                                     }
652661                                 else throw("Strict value is not equal to itself.")
653662                             }
654663                         else throw("Strict value is not equal to itself.")
655664                     }
656665                 else throw("Strict value is not equal to itself.")
657666             }
658667         else throw("Strict value is not equal to itself.")
659668     }
660669 
661670 
662671 @Verifier(tx)
663672 func verify () = {
664673     let targetPublicKey =     match managerPublicKeyOrUnit() {
665674         case pk: ByteVector => 
666675             pk
667676         case _: Unit => 
668677             tx.senderPublicKey
669678         case _ => 
670679             throw("Match error")
671680     }
672681     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
673682     }
674683 
github/deemru/w8io/169f3d6 
81.15 ms ◑