tx · E55pebjKENxbPi7q4LKoGgR5TdNaFg7kkBwB5ggDxLC8

3Mx85sUMQFaaTcAjiQpd5sGUAdaCrNKxv7a:  -0.27000000 Waves

2023.04.25 14:07 [2549998] smart account 3Mx85sUMQFaaTcAjiQpd5sGUAdaCrNKxv7a > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "E55pebjKENxbPi7q4LKoGgR5TdNaFg7kkBwB5ggDxLC8",
    "fee": 27000000,
    "feeAssetId": null,
    "timestamp": 1682420834173,
    "version": 2,
    "chainId": 84,
    "sender": "3Mx85sUMQFaaTcAjiQpd5sGUAdaCrNKxv7a",
    "senderPublicKey": "6f5UpEaYxvWL2FTjo4b6CUu3VwSHJ9BvuodtSaSb5tJ8",
    "proofs": [
        "248xxPhBiKPnTznGk3am9H94DPs2Ra5spAMq6eaadXJothAN9MQ3vyAn8cXWj7u9xWpr1unFpDt3jLmFfhWfnr3d"
    ],
    "script": "base64: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",
    "height": 2549998,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 2SEzJRmshq3ZAwwXwNDk4XD7jhWDUXABeVqgpxXvd6eQ

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let separator = "__"
5+
6+let shareAssetDecimals = 8
7+
8+let wavesString = "WAVES"
9+
10+let scale18 = 1000000000000000000
11+
12+let scale18BigInt = toBigInt(scale18)
13+
14+func wrapErr (msg) = makeString(["lp_staking_pools.ride:", msg], " ")
15+
16+
17+func throwErr (msg) = throw(wrapErr(msg))
18+
19+
20+func errKeyIsNotDefined (address,key) = wrapErr(makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
21+
22+
23+func getStrOrFail (address,key) = valueOrErrorMessage(getString(address, key), errKeyIsNotDefined(address, key))
24+
25+
26+func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), errKeyIsNotDefined(address, key))
27+
28+
29+func parseAssetId (input) = if ((input == wavesString))
30+    then unit
31+    else fromBase58String(input)
32+
33+
34+func assetIdToString (input) = if ((input == unit))
35+    then wavesString
36+    else toBase58String(value(input))
37+
38+
39+func ensurePositive (v) = if ((v >= 0))
40+    then v
41+    else throwErr("value should be positive")
42+
43+
44+func keyFactoryContract () = makeString(["%s", "factoryContract"], separator)
45+
46+
47+func keyLpStakingContract () = makeString(["%s", "lpStakingContract"], separator)
48+
49+
50+func keyStakingContract () = makeString(["%s", "stakingContract"], separator)
51+
52+
53+func keyBoostingContract () = makeString(["%s", "boostingContract"], separator)
54+
55+
56+func keySwapContract () = makeString(["%s", "swapContract"], separator)
57+
58+
59+func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], separator)
60+
61+
62+func keyUsdtAssetId () = makeString(["%s", "usdtAssetId"], separator)
63+
64+
65+func keyWxAssetId () = makeString(["%s", "wxAssetId"], separator)
66+
67+
68+func keyShutdown () = makeString(["%s", "shutdown"], separator)
69+
70+
71+func keyMinDelay () = makeString(["%s", "minDelay"], separator)
72+
73+
74+func keyLockFraction () = makeString(["%s", "lockFraction"], separator)
75+
76+
77+func keyShareAssetId (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetId"], separator)
78+
79+
80+func keyBaseAssetId (shareAssetId) = makeString(["%s%s", assetIdToString(shareAssetId), "baseAssetId"], separator)
81+
82+
83+func keyPeriod (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "period"], separator)
84+
85+
86+func keyPeriodStartHeight (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "periodStartHeight", toString(period)], separator)
87+
88+
89+func keyBaseAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "baseAssetAmountToConvert"], separator)
90+
91+
92+func keyShareAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetAmountToConvert"], separator)
93+
94+
95+func keyUserBaseAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert"], separator)
96+
97+
98+func keyUserBaseAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert", "period"], separator)
99+
100+
101+func keyUserShareAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert"], separator)
102+
103+
104+func keyUserShareAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert", "period"], separator)
105+
106+
107+func keyPricePeriod (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "price", toString(period)], separator)
108+
109+
110+func keyPriceHistory (baseAssetId) = makeString(["%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
111+
112+
113+func keyPricePeriodPut (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "put"], separator)
114+
115+
116+func keyPricePutHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "put", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
117+
118+
119+func keyPricePeriodGet (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "get"], separator)
120+
121+
122+func keyPriceGetHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "get", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
123+
124+
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)
126+
127+
128+func keyManagerPublicKey () = "%s__managerPublicKey"
129+
130+
131+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
132+
133+
134+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
135+    case s: String => 
136+        fromBase58String(s)
137+    case _: Unit => 
138+        unit
139+    case _ => 
140+        throw("Match error")
141+}
142+
143+
144+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
145+    case s: String => 
146+        fromBase58String(s)
147+    case _: Unit => 
148+        unit
149+    case _ => 
150+        throw("Match error")
151+}
152+
153+
154+let permissionDeniedError = throw("Permission denied")
155+
156+func mustThis (i) = if ((i.caller == this))
157+    then true
158+    else permissionDeniedError
159+
160+
161+func mustManager (i) = match managerPublicKeyOrUnit() {
162+    case pk: ByteVector => 
163+        if ((i.callerPublicKey == pk))
164+            then true
165+            else permissionDeniedError
166+    case _: Unit => 
167+        mustThis(i)
168+    case _ => 
169+        throw("Match error")
170+}
171+
172+
173+let shutdown = valueOrElse(getBoolean(keyShutdown()), false)
174+
175+func shutdownCheck (i) = if (if (!(shutdown))
176+    then true
177+    else mustManager(i))
178+    then true
179+    else throw("operation is disabled")
180+
181+
182+let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract()))
183+
184+let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract()))
185+
186+let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract()))
187+
188+let boostingContract = addressFromStringValue(getStrOrFail(this, keyBoostingContract()))
189+
190+let swapContract = addressFromStringValue(getStrOrFail(this, keySwapContract()))
191+
192+let assetsStoreContract = addressFromStringValue(getStrOrFail(this, keyAssetsStoreContract()))
193+
194+let usdtAssetId = parseAssetId(getStrOrFail(this, keyUsdtAssetId()))
195+
196+let wxAssetId = parseAssetId(getStrOrFail(this, keyWxAssetId()))
197+
198+let minDelayDefault = 1440
199+
200+let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault)
201+
202+let lockFractionMultiplier = 100000000
203+
204+let lockFractionDefault = fraction(1, lockFractionMultiplier, 2)
205+
206+let lockFraction = valueOrElse(getInteger(this, keyLockFraction()), lockFractionDefault)
207+
208+func getPoolInfo (amountAssetId) = {
209+    let amountAssetIdStr = assetIdToString(amountAssetId)
210+    let priceAssetIdStr = assetIdToString(usdtAssetId)
211+    let poolInfoOption = {
212+        let @ = invoke(factoryContract, "poolInfoREADONLY", [amountAssetIdStr, priceAssetIdStr], nil)
213+        if ($isInstanceOf(@, "(Address, ByteVector)"))
214+            then @
215+            else unit
216+        }
217+    poolInfoOption
218+    }
219+
220+
221+func calcPrice (lpAssetId,shareAssetId) = {
222+    let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
223+    let shareAssetEmission = shareAssetInfo.quantity
224+    let stakedAmount = ensurePositive(valueOrErrorMessage({
225+        let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
226+        if ($isInstanceOf(@, "Int"))
227+            then @
228+            else unit
229+        }, wrapErr("invalid stakedByUserREADONLY result")))
230+    let price = if ((shareAssetEmission == 0))
231+        then scale18BigInt
232+        else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
233+    price
234+    }
235+
236+
237+@Callable(i)
238+func setManager (pendingManagerPublicKey) = {
239+    let checkCaller = mustManager(i)
240+    if ((checkCaller == checkCaller))
241+        then {
242+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
243+            if ((checkManagerPublicKey == checkManagerPublicKey))
244+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
245+                else throw("Strict value is not equal to itself.")
246+            }
247+        else throw("Strict value is not equal to itself.")
248+    }
249+
250+
251+
252+@Callable(i)
253+func confirmManager () = {
254+    let pm = pendingManagerPublicKeyOrUnit()
255+    let hasPM = if (isDefined(pm))
256+        then true
257+        else throwErr("no pending manager")
258+    if ((hasPM == hasPM))
259+        then {
260+            let checkPM = if ((i.callerPublicKey == value(pm)))
261+                then true
262+                else throwErr("you are not pending manager")
263+            if ((checkPM == checkPM))
264+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
265+                else throw("Strict value is not equal to itself.")
266+            }
267+        else throw("Strict value is not equal to itself.")
268+    }
269+
270+
271+
272+@Callable(i)
273+func emit (assetId,amount) = {
274+    let checkCaller = mustThis(i)
275+    if ((checkCaller == checkCaller))
276+        then {
277+            let isReissuable = true
278+            $Tuple2([Reissue(assetId, amount, isReissuable)], amount)
279+            }
280+        else throw("Strict value is not equal to itself.")
281+    }
282+
283+
284+
285+@Callable(i)
286+func burn (assetId,amount) = {
287+    let checkCaller = mustThis(i)
288+    if ((checkCaller == checkCaller))
289+        then $Tuple2([Burn(assetId, amount)], amount)
290+        else throw("Strict value is not equal to itself.")
291+    }
292+
293+
294+
295+@Callable(i)
296+func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
297+    let shareAssetLabel = "STAKING_LP"
298+    let baseAssetId = parseAssetId(baseAssetIdStr)
299+    let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId)))
300+        then true
301+        else throwErr("invalid base asset")]
302+    if ((checks == checks))
303+        then {
304+            let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)]
305+            if ((shareAssetIdStr == ""))
306+                then {
307+                    let shareAssetIssueAmount = 1
308+                    let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true)
309+                    let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction)
310+                    let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount)
311+                    let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId)
312+                    let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil)
313+                    if ((createOrUpdate == createOrUpdate))
314+                        then {
315+                            let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil)
316+                            if ((addLabel == addLabel))
317+                                then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr)
318+                                else throw("Strict value is not equal to itself.")
319+                            }
320+                        else throw("Strict value is not equal to itself.")
321+                    }
322+                else {
323+                    let shareAssetId = fromBase58String(shareAssetIdStr)
324+                    let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
325+                    let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract))
326+                        then true
327+                        else throwErr("invalid share asset id issuer")
328+                    if ((checkIssuer == checkIssuer))
329+                        then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyBaseAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr)
330+                        else throw("Strict value is not equal to itself.")
331+                    }
332+            }
333+        else throw("Strict value is not equal to itself.")
334+    }
335+
336+
337+
338+@Callable(i)
339+func put () = {
340+    let pmt = if ((size(i.payments) == 1))
341+        then i.payments[0]
342+        else throwErr("exactly 1 payment is expected")
343+    let baseAssetId = pmt.assetId
344+    let userAddress = i.caller
345+    let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
346+        then true
347+        else throwErr("invalid asset")]
348+    if ((checks == checks))
349+        then {
350+            let $t01167511778 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
351+            let poolAddress = $t01167511778._1
352+            let lpAssetId = $t01167511778._2
353+            let period = value(getInteger(keyPeriod(baseAssetId)))
354+            let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
355+            let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
356+                then unit
357+                else {
358+                    let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption)
359+                    if ((userBaseAssetAmountToConvertPeriod == period))
360+                        then unit
361+                        else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
362+                    }
363+            if ((claimShareAssetInvocation == claimShareAssetInvocation))
364+                then {
365+                    let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
366+                    let userBaseAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
367+                    $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString((userBaseAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp)], separator)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userBaseAssetAmountToConvert)], separator))], unit)
368+                    }
369+                else throw("Strict value is not equal to itself.")
370+            }
371+        else throw("Strict value is not equal to itself.")
372+    }
373+
374+
375+
376+@Callable(i)
377+func claimShareAsset (baseAssetIdStr,userAddressStr) = {
378+    let checks = [shutdownCheck(i)]
379+    if ((checks == checks))
380+        then {
381+            let userAddress = if ((userAddressStr == ""))
382+                then i.caller
383+                else {
384+                    let checkCaller = mustThis(i)
385+                    if ((checkCaller == checkCaller))
386+                        then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
387+                        else throw("Strict value is not equal to itself.")
388+                    }
389+            if ((userAddress == userAddress))
390+                then {
391+                    let baseAssetId = parseAssetId(baseAssetIdStr)
392+                    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
393+                    if ((shareAssetId == shareAssetId))
394+                        then {
395+                            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
396+                            if ((period == period))
397+                                then {
398+                                    let userBaseAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
399+                                    let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
400+                                        then true
401+                                        else throwErr("nothing to claim")
402+                                    if ((checkAmountToConvert == checkAmountToConvert))
403+                                        then {
404+                                            let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
405+                                            let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
406+                                                then true
407+                                                else throwErr("invalid period")
408+                                            if ((checkPeriod == checkPeriod))
409+                                                then {
410+                                                    let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
411+                                                    let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
412+                                                    $Tuple2([StringEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString(0), toString(lastBlock.timestamp)], separator)), DeleteEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(shareAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userBaseAssetAmountToConvert)], separator))], unit)
413+                                                    }
414+                                                else throw("Strict value is not equal to itself.")
415+                                            }
416+                                        else throw("Strict value is not equal to itself.")
417+                                    }
418+                                else throw("Strict value is not equal to itself.")
419+                            }
420+                        else throw("Strict value is not equal to itself.")
421+                    }
422+                else throw("Strict value is not equal to itself.")
423+            }
424+        else throw("Strict value is not equal to itself.")
425+    }
426+
427+
428+
429+@Callable(i)
430+func get () = {
431+    let checks = [shutdownCheck(i)]
432+    if ((checks == checks))
433+        then {
434+            let pmt = if ((size(i.payments) == 1))
435+                then i.payments[0]
436+                else throwErr("exactly 1 payment is expected")
437+            let shareAssetId = pmt.assetId
438+            let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
439+            if ((baseAssetId == baseAssetId))
440+                then {
441+                    let userAddress = i.caller
442+                    let $t01612016309 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443+                    let poolAddress = $t01612016309._1
444+                    let lpAssetId = $t01612016309._2
445+                    let period = value(getInteger(keyPeriod(baseAssetId)))
446+                    let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
447+                    let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
448+                        then unit
449+                        else {
450+                            let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
451+                            if ((userShareAssetAmountToConvertPeriod == period))
452+                                then unit
453+                                else invoke(this, "claimBaseAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
454+                            }
455+                    if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
456+                        then {
457+                            let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
458+                            let userShareAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserShareAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
459+                            $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString((userShareAssetAmountToConvert + pmt.amount)), toString(lastBlock.timestamp)], separator)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), makeString(["%d%d%d", toString(pmt.amount), toString(lastBlock.timestamp), toString(userShareAssetAmountToConvert)], separator))], unit)
460+                            }
461+                        else throw("Strict value is not equal to itself.")
462+                    }
463+                else throw("Strict value is not equal to itself.")
464+            }
465+        else throw("Strict value is not equal to itself.")
466+    }
467+
468+
469+
470+@Callable(i)
471+func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
472+    let checks = [shutdownCheck(i)]
473+    if ((checks == checks))
474+        then {
475+            let userAddress = if ((userAddressStr == ""))
476+                then i.caller
477+                else {
478+                    let checkCaller = mustThis(i)
479+                    if ((checkCaller == checkCaller))
480+                        then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
481+                        else throw("Strict value is not equal to itself.")
482+                    }
483+            if ((userAddress == userAddress))
484+                then {
485+                    let baseAssetId = parseAssetId(baseAssetIdStr)
486+                    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
487+                    if ((shareAssetId == shareAssetId))
488+                        then {
489+                            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
490+                            if ((period == period))
491+                                then {
492+                                    let userShareAssetAmountToConvert = valueOrElse(parseInt(split(value(getString(keyUserShareAssetAmountToConvert(baseAssetId, userAddress))), separator)[1]), 0)
493+                                    let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
494+                                    let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
495+                                        then true
496+                                        else throwErr("invalid period")
497+                                    if ((checkPeriod == checkPeriod))
498+                                        then {
499+                                            let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
500+                                            let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
501+                                            $Tuple2([StringEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), makeString(["%d%d", toString(0), toString(lastBlock.timestamp)], separator)), DeleteEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), makeString(["%d%d%d%d", toString(baseAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userShareAssetAmountToConvertPeriod)], separator))], unit)
502+                                            }
503+                                        else throw("Strict value is not equal to itself.")
504+                                    }
505+                                else throw("Strict value is not equal to itself.")
506+                            }
507+                        else throw("Strict value is not equal to itself.")
508+                    }
509+                else throw("Strict value is not equal to itself.")
510+            }
511+        else throw("Strict value is not equal to itself.")
512+    }
513+
514+
515+
516+@Callable(i)
517+func finalize (baseAssetIdStr) = {
518+    let checks = [shutdownCheck(i)]
519+    if ((checks == checks))
520+        then {
521+            let baseAssetId = parseAssetId(baseAssetIdStr)
522+            let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
523+            if ((shareAssetId == shareAssetId))
524+                then {
525+                    let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
526+                    let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
527+                    if ((period == period))
528+                        then {
529+                            let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
530+                            let checkDelay = if ((periodStartHeightOption == unit))
531+                                then unit
532+                                else {
533+                                    let delay = (height - value(periodStartHeightOption))
534+                                    let blocksToWait = max([0, (minDelay - delay)])
535+                                    if ((blocksToWait == 0))
536+                                        then unit
537+                                        else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
538+                                    }
539+                            if ((checkDelay == checkDelay))
540+                                then {
541+                                    let $t02168021861 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
542+                                    let poolAddress = $t02168021861._1
543+                                    let lpAssetId = $t02168021861._2
544+                                    let stakingReward = valueOrErrorMessage({
545+                                        let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
546+                                        if ($isInstanceOf(@, "Int"))
547+                                            then @
548+                                            else unit
549+                                        }, wrapErr("invalid claimWx result"))
550+                                    if ((stakingReward == stakingReward))
551+                                        then {
552+                                            let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
553+                                            let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
554+                                            let checkFinalizationIsRequired = {
555+                                                let isFinalizationRequired = if (if ((stakingReward > 0))
556+                                                    then true
557+                                                    else (baseAssetAmountToConvert > 0))
558+                                                    then true
559+                                                    else (shareAssetAmountToConvert > 0)
560+                                                if (isFinalizationRequired)
561+                                                    then true
562+                                                    else throwErr("nothing to finalize")
563+                                                }
564+                                            if ((checkFinalizationIsRequired == checkFinalizationIsRequired))
565+                                                then {
566+                                                    let useStakingReward = if ((stakingReward > 0))
567+                                                        then {
568+                                                            let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier)
569+                                                            let convertPart = (stakingReward - lockPart)
570+                                                            let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
571+                                                            let lock = if ((lockPart > 0))
572+                                                                then                                                                 match r {
573+                                                                    case _ => 
574+                                                                        if (if (if ($isInstanceOf($match0._1, "String"))
575+                                                                            then $isInstanceOf($match0._2, "Int")
576+                                                                            else false)
577+                                                                            then $isInstanceOf($match0, "(String, Int)")
578+                                                                            else false)
579+                                                                            then {
580+                                                                                let function = $match0._1
581+                                                                                let duration = $match0._2
582+                                                                                if ((lockPart > 0))
583+                                                                                    then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
584+                                                                                    else unit
585+                                                                                }
586+                                                                            else throwErr("invalid lock params")
587+                                                                }
588+                                                                else unit
589+                                                            if ((lock == lock))
590+                                                                then {
591+                                                                    let convertedAmount = if ((convertPart > 0))
592+                                                                        then {
593+                                                                            let inAssetId = wxAssetId
594+                                                                            let minimumToReceive = 0
595+                                                                            let outAssetIdStr = assetIdToString(usdtAssetId)
596+                                                                            let targetAddress = toString(this)
597+                                                                            valueOrErrorMessage({
598+                                                                                let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
599+                                                                                if ($isInstanceOf(@, "Int"))
600+                                                                                    then @
601+                                                                                    else unit
602+                                                                                }, wrapErr("invalid swap result"))
603+                                                                            }
604+                                                                        else 0
605+                                                                    if ((convertedAmount == convertedAmount))
606+                                                                        then {
607+                                                                            let lpAssetAmount = if ((convertedAmount > 0))
608+                                                                                then {
609+                                                                                    let minOutAmount = 0
610+                                                                                    let autoStake = true
611+                                                                                    valueOrErrorMessage({
612+                                                                                        let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdtAssetId, convertedAmount)])
613+                                                                                        if ($isInstanceOf(@, "Int"))
614+                                                                                            then @
615+                                                                                            else unit
616+                                                                                        }, wrapErr("invalid putOneTknV2 result"))
617+                                                                                    }
618+                                                                                else 0
619+                                                                            if ((lpAssetAmount == lpAssetAmount))
620+                                                                                then lpAssetAmount
621+                                                                                else throw("Strict value is not equal to itself.")
622+                                                                            }
623+                                                                        else throw("Strict value is not equal to itself.")
624+                                                                    }
625+                                                                else throw("Strict value is not equal to itself.")
626+                                                            }
627+                                                        else unit
628+                                                    if ((useStakingReward == useStakingReward))
629+                                                        then {
630+                                                            let getActions = if ((shareAssetAmountToConvert > 0))
631+                                                                then {
632+                                                                    let price = calcPrice(lpAssetId, shareAssetId)
633+                                                                    if ((price == price))
634+                                                                        then {
635+                                                                            let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
636+                                                                            let baseAssetAmount = {
637+                                                                                let outAssetId = baseAssetId
638+                                                                                let minOutAmount = 0
639+                                                                                valueOrErrorMessage({
640+                                                                                    let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
641+                                                                                    if ($isInstanceOf(@, "Int"))
642+                                                                                        then @
643+                                                                                        else unit
644+                                                                                    }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
645+                                                                                }
646+                                                                            if ((baseAssetAmount == baseAssetAmount))
647+                                                                                then {
648+                                                                                    let shareAssetBurn = if ((shareAssetInfo.issuer == this))
649+                                                                                        then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
650+                                                                                        else throwErr("invalid share asset issuer")
651+                                                                                    if ((shareAssetBurn == shareAssetBurn))
652+                                                                                        then {
653+                                                                                            let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
654+                                                                                            let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
655+                                                                                            priceGetUpdateActions
656+                                                                                            }
657+                                                                                        else throw("Strict value is not equal to itself.")
658+                                                                                    }
659+                                                                                else throw("Strict value is not equal to itself.")
660+                                                                            }
661+                                                                        else throw("Strict value is not equal to itself.")
662+                                                                    }
663+                                                                else nil
664+                                                            if ((getActions == getActions))
665+                                                                then {
666+                                                                    let putActions = if ((baseAssetAmountToConvert > 0))
667+                                                                        then {
668+                                                                            let lpAssetAmount = {
669+                                                                                let minOutAmount = 0
670+                                                                                let autoStake = true
671+                                                                                valueOrErrorMessage({
672+                                                                                    let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
673+                                                                                    if ($isInstanceOf(@, "Int"))
674+                                                                                        then @
675+                                                                                        else unit
676+                                                                                    }, wrapErr("invalid putOneTknV2 result"))
677+                                                                                }
678+                                                                            if ((lpAssetAmount == lpAssetAmount))
679+                                                                                then {
680+                                                                                    let price = calcPrice(lpAssetId, shareAssetId)
681+                                                                                    if ((price == price))
682+                                                                                        then {
683+                                                                                            let checkPrice = if ((value(toInt(price)) != 0))
684+                                                                                                then true
685+                                                                                                else throw("price is ZERO")
686+                                                                                            if ((checkPrice == checkPrice))
687+                                                                                                then {
688+                                                                                                    let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
689+                                                                                                    let checkShareAssetAmount = if ((value(toInt(price)) != 0))
690+                                                                                                        then true
691+                                                                                                        else throw("shareAssetAmount is ZERO")
692+                                                                                                    if ((checkShareAssetAmount == checkShareAssetAmount))
693+                                                                                                        then {
694+                                                                                                            let shareAssetReissue = if ((shareAssetInfo.issuer == this))
695+                                                                                                                then invoke(this, "emit", [shareAssetId, shareAssetAmount], nil)
696+                                                                                                                else throwErr("invalid share asset issuer")
697+                                                                                                            if ((shareAssetReissue == shareAssetReissue))
698+                                                                                                                then {
699+                                                                                                                    let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
700+                                                                                                                    let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
701+                                                                                                                    pricePutUpdateActions
702+                                                                                                                    }
703+                                                                                                                else throw("Strict value is not equal to itself.")
704+                                                                                                            }
705+                                                                                                        else throw("Strict value is not equal to itself.")
706+                                                                                                    }
707+                                                                                                else throw("Strict value is not equal to itself.")
708+                                                                                            }
709+                                                                                        else throw("Strict value is not equal to itself.")
710+                                                                                    }
711+                                                                                else throw("Strict value is not equal to itself.")
712+                                                                            }
713+                                                                        else nil
714+                                                                    if ((putActions == putActions))
715+                                                                        then {
716+                                                                            let newPeriod = (period + 1)
717+                                                                            let lastPrice = calcPrice(lpAssetId, shareAssetId)
718+                                                                            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)
719+                                                                            $Tuple2(actions, toBytes(lastPrice))
720+                                                                            }
721+                                                                        else throw("Strict value is not equal to itself.")
722+                                                                    }
723+                                                                else throw("Strict value is not equal to itself.")
724+                                                            }
725+                                                        else throw("Strict value is not equal to itself.")
726+                                                    }
727+                                                else throw("Strict value is not equal to itself.")
728+                                            }
729+                                        else throw("Strict value is not equal to itself.")
730+                                    }
731+                                else throw("Strict value is not equal to itself.")
732+                            }
733+                        else throw("Strict value is not equal to itself.")
734+                    }
735+                else throw("Strict value is not equal to itself.")
736+            }
737+        else throw("Strict value is not equal to itself.")
738+    }
739+
740+
741+@Verifier(tx)
742+func verify () = {
743+    let targetPublicKey =     match managerPublicKeyOrUnit() {
744+        case pk: ByteVector => 
745+            pk
746+        case _: Unit => 
747+            tx.senderPublicKey
748+        case _ => 
749+            throw("Match error")
750+    }
751+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
752+    }
753+
github/deemru/w8io/873ac7e 
65.50 ms ◑