tx · u3QfzGcSiuSLUtyPhQfcq1cf9JvaoQHBLWwyAs8Foqh

3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV:  -0.02900000 Waves

2023.05.10 13:15 [2571654] smart account 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV > SELF 0.00000000 Waves

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

View: original | compacted
Prev: HyCJVY3ypdnWdQx4jtDX5JhGoWP5hZbGyNvvCo3kLktw
Next: EnuRAfmbkpQis4qRRLEvD8NgGJJso2JoB9EH2cfsfBVM

Diff: 

OldNewDifferences
128128 func keyManagerPublicKey () = "%s__managerPublicKey"
129129 
130130 
131-func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
131+func keyManagerVaultAddress () = "%s__managerVaultAddress"
132132 
133133 
134-func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
134+func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
135135     case s: String => 
136-        fromBase58String(s)
137-    case _: Unit => 
138-        unit
136+        addressFromStringValue(s)
139137     case _ => 
140-        throw("Match error")
138+        this
141139 }
142140 
143141 
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-}
142+func managerPublicKeyOrUnit () = {
143+    let managerVaultAddress = getManagerVaultAddressOrThis()
144+    match getString(managerVaultAddress, keyManagerPublicKey()) {
145+        case s: String => 
146+            fromBase58String(s)
147+        case _: Unit => 
148+            unit
149+        case _ => 
150+            throw("Match error")
151+    }
152+    }
152153 
153154 
154155 let permissionDeniedError = throw("Permission denied")
235236 
236237 
237238 @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)
273239 func emit (assetId,amount) = {
274240     let checkCaller = mustThis(i)
275241     if ((checkCaller == checkCaller))
347313         else throwErr("invalid asset")]
348314     if ((checks == checks))
349315         then {
350-            let $t01164011743 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
351-            let poolAddress = $t01164011743._1
352-            let lpAssetId = $t01164011743._2
316+            let $t01109211195 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
317+            let poolAddress = $t01109211195._1
318+            let lpAssetId = $t01109211195._2
353319             let period = value(getInteger(keyPeriod(baseAssetId)))
354320             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
355321             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
439405             if ((baseAssetId == baseAssetId))
440406                 then {
441407                     let userAddress = i.caller
442-                    let $t01582016009 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443-                    let poolAddress = $t01582016009._1
444-                    let lpAssetId = $t01582016009._2
408+                    let $t01527215461 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
409+                    let poolAddress = $t01527215461._1
410+                    let lpAssetId = $t01527215461._2
445411                     let period = value(getInteger(keyPeriod(baseAssetId)))
446412                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
447413                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
538504                                     }
539505                             if ((checkDelay == checkDelay))
540506                                 then {
541-                                    let $t02111321294 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
542-                                    let poolAddress = $t02111321294._1
543-                                    let lpAssetId = $t02111321294._2
507+                                    let $t02056520746 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
508+                                    let poolAddress = $t02056520746._1
509+                                    let lpAssetId = $t02056520746._2
544510                                     let stakingReward = valueOrErrorMessage({
545511                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
546512                                         if ($isInstanceOf(@, "Int"))

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let separator = "__"
55 
66 let shareAssetDecimals = 8
77 
88 let wavesString = "WAVES"
99 
1010 let scale18 = 1000000000000000000
1111 
1212 let scale18BigInt = toBigInt(scale18)
1313 
1414 func wrapErr (msg) = makeString(["lp_staking_pools.ride:", msg], " ")
1515 
1616 
1717 func throwErr (msg) = throw(wrapErr(msg))
1818 
1919 
2020 func errKeyIsNotDefined (address,key) = wrapErr(makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
2121 
2222 
2323 func getStrOrFail (address,key) = valueOrErrorMessage(getString(address, key), errKeyIsNotDefined(address, key))
2424 
2525 
2626 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), errKeyIsNotDefined(address, key))
2727 
2828 
2929 func parseAssetId (input) = if ((input == wavesString))
3030     then unit
3131     else fromBase58String(input)
3232 
3333 
3434 func assetIdToString (input) = if ((input == unit))
3535     then wavesString
3636     else toBase58String(value(input))
3737 
3838 
3939 func ensurePositive (v) = if ((v >= 0))
4040     then v
4141     else throwErr("value should be positive")
4242 
4343 
4444 func keyFactoryContract () = makeString(["%s", "factoryContract"], separator)
4545 
4646 
4747 func keyLpStakingContract () = makeString(["%s", "lpStakingContract"], separator)
4848 
4949 
5050 func keyStakingContract () = makeString(["%s", "stakingContract"], separator)
5151 
5252 
5353 func keyBoostingContract () = makeString(["%s", "boostingContract"], separator)
5454 
5555 
5656 func keySwapContract () = makeString(["%s", "swapContract"], separator)
5757 
5858 
5959 func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], separator)
6060 
6161 
6262 func keyUsdtAssetId () = makeString(["%s", "usdtAssetId"], separator)
6363 
6464 
6565 func keyWxAssetId () = makeString(["%s", "wxAssetId"], separator)
6666 
6767 
6868 func keyShutdown () = makeString(["%s", "shutdown"], separator)
6969 
7070 
7171 func keyMinDelay () = makeString(["%s", "minDelay"], separator)
7272 
7373 
7474 func keyLockFraction () = makeString(["%s", "lockFraction"], separator)
7575 
7676 
7777 func keyShareAssetId (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetId"], separator)
7878 
7979 
8080 func keyBaseAssetId (shareAssetId) = makeString(["%s%s", assetIdToString(shareAssetId), "baseAssetId"], separator)
8181 
8282 
8383 func keyPeriod (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "period"], separator)
8484 
8585 
8686 func keyPeriodStartHeight (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "periodStartHeight", toString(period)], separator)
8787 
8888 
8989 func keyBaseAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "baseAssetAmountToConvert"], separator)
9090 
9191 
9292 func keyShareAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetAmountToConvert"], separator)
9393 
9494 
9595 func keyUserBaseAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert"], separator)
9696 
9797 
9898 func keyUserBaseAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert", "period"], separator)
9999 
100100 
101101 func keyUserShareAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert"], separator)
102102 
103103 
104104 func keyUserShareAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert", "period"], separator)
105105 
106106 
107107 func keyPricePeriod (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "price", toString(period)], separator)
108108 
109109 
110110 func keyPriceHistory (baseAssetId) = makeString(["%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
111111 
112112 
113113 func keyPricePeriodPut (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "put"], separator)
114114 
115115 
116116 func keyPricePutHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "put", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
117117 
118118 
119119 func keyPricePeriodGet (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "get"], separator)
120120 
121121 
122122 func keyPriceGetHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "get", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
123123 
124124 
125125 func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
126126 
127127 
128128 func keyManagerPublicKey () = "%s__managerPublicKey"
129129 
130130 
131-func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
131+func keyManagerVaultAddress () = "%s__managerVaultAddress"
132132 
133133 
134-func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
134+func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
135135     case s: String => 
136-        fromBase58String(s)
137-    case _: Unit => 
138-        unit
136+        addressFromStringValue(s)
139137     case _ => 
140-        throw("Match error")
138+        this
141139 }
142140 
143141 
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-}
142+func managerPublicKeyOrUnit () = {
143+    let managerVaultAddress = getManagerVaultAddressOrThis()
144+    match getString(managerVaultAddress, keyManagerPublicKey()) {
145+        case s: String => 
146+            fromBase58String(s)
147+        case _: Unit => 
148+            unit
149+        case _ => 
150+            throw("Match error")
151+    }
152+    }
152153 
153154 
154155 let permissionDeniedError = throw("Permission denied")
155156 
156157 func mustThis (i) = if ((i.caller == this))
157158     then true
158159     else permissionDeniedError
159160 
160161 
161162 func mustManager (i) = match managerPublicKeyOrUnit() {
162163     case pk: ByteVector => 
163164         if ((i.callerPublicKey == pk))
164165             then true
165166             else permissionDeniedError
166167     case _: Unit => 
167168         mustThis(i)
168169     case _ => 
169170         throw("Match error")
170171 }
171172 
172173 
173174 let shutdown = valueOrElse(getBoolean(keyShutdown()), false)
174175 
175176 func shutdownCheck (i) = if (if (!(shutdown))
176177     then true
177178     else mustManager(i))
178179     then true
179180     else throw("operation is disabled")
180181 
181182 
182183 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract()))
183184 
184185 let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract()))
185186 
186187 let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract()))
187188 
188189 let boostingContract = addressFromStringValue(getStrOrFail(this, keyBoostingContract()))
189190 
190191 let swapContract = addressFromStringValue(getStrOrFail(this, keySwapContract()))
191192 
192193 let assetsStoreContract = addressFromStringValue(getStrOrFail(this, keyAssetsStoreContract()))
193194 
194195 let usdtAssetId = parseAssetId(getStrOrFail(this, keyUsdtAssetId()))
195196 
196197 let wxAssetId = parseAssetId(getStrOrFail(this, keyWxAssetId()))
197198 
198199 let minDelayDefault = 1440
199200 
200201 let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault)
201202 
202203 let lockFractionMultiplier = 100000000
203204 
204205 let lockFractionDefault = fraction(1, lockFractionMultiplier, 2)
205206 
206207 let lockFraction = valueOrElse(getInteger(this, keyLockFraction()), lockFractionDefault)
207208 
208209 func getPoolInfo (amountAssetId) = {
209210     let amountAssetIdStr = assetIdToString(amountAssetId)
210211     let priceAssetIdStr = assetIdToString(usdtAssetId)
211212     let poolInfoOption = {
212213         let @ = invoke(factoryContract, "poolInfoREADONLY", [amountAssetIdStr, priceAssetIdStr], nil)
213214         if ($isInstanceOf(@, "(Address, ByteVector)"))
214215             then @
215216             else unit
216217         }
217218     poolInfoOption
218219     }
219220 
220221 
221222 func calcPrice (lpAssetId,shareAssetId) = {
222223     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
223224     let shareAssetEmission = shareAssetInfo.quantity
224225     let stakedAmount = ensurePositive(valueOrErrorMessage({
225226         let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
226227         if ($isInstanceOf(@, "Int"))
227228             then @
228229             else unit
229230         }, wrapErr("invalid stakedByUserREADONLY result")))
230231     let price = if ((shareAssetEmission == 0))
231232         then scale18BigInt
232233         else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
233234     price
234235     }
235236 
236237 
237238 @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)
273239 func emit (assetId,amount) = {
274240     let checkCaller = mustThis(i)
275241     if ((checkCaller == checkCaller))
276242         then {
277243             let isReissuable = true
278244             $Tuple2([Reissue(assetId, amount, isReissuable)], amount)
279245             }
280246         else throw("Strict value is not equal to itself.")
281247     }
282248 
283249 
284250 
285251 @Callable(i)
286252 func burn (assetId,amount) = {
287253     let checkCaller = mustThis(i)
288254     if ((checkCaller == checkCaller))
289255         then $Tuple2([Burn(assetId, amount)], amount)
290256         else throw("Strict value is not equal to itself.")
291257     }
292258 
293259 
294260 
295261 @Callable(i)
296262 func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
297263     let shareAssetLabel = "STAKING_LP"
298264     let baseAssetId = parseAssetId(baseAssetIdStr)
299265     let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId)))
300266         then true
301267         else throwErr("invalid base asset")]
302268     if ((checks == checks))
303269         then {
304270             let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)]
305271             if ((shareAssetIdStr == ""))
306272                 then {
307273                     let shareAssetIssueAmount = 1
308274                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true)
309275                     let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction)
310276                     let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount)
311277                     let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId)
312278                     let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil)
313279                     if ((createOrUpdate == createOrUpdate))
314280                         then {
315281                             let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil)
316282                             if ((addLabel == addLabel))
317283                                 then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr)
318284                                 else throw("Strict value is not equal to itself.")
319285                             }
320286                         else throw("Strict value is not equal to itself.")
321287                     }
322288                 else {
323289                     let shareAssetId = fromBase58String(shareAssetIdStr)
324290                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
325291                     let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract))
326292                         then true
327293                         else throwErr("invalid share asset id issuer")
328294                     if ((checkIssuer == checkIssuer))
329295                         then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyBaseAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr)
330296                         else throw("Strict value is not equal to itself.")
331297                     }
332298             }
333299         else throw("Strict value is not equal to itself.")
334300     }
335301 
336302 
337303 
338304 @Callable(i)
339305 func put () = {
340306     let pmt = if ((size(i.payments) == 1))
341307         then i.payments[0]
342308         else throwErr("exactly 1 payment is expected")
343309     let baseAssetId = pmt.assetId
344310     let userAddress = i.caller
345311     let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
346312         then true
347313         else throwErr("invalid asset")]
348314     if ((checks == checks))
349315         then {
350-            let $t01164011743 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
351-            let poolAddress = $t01164011743._1
352-            let lpAssetId = $t01164011743._2
316+            let $t01109211195 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
317+            let poolAddress = $t01109211195._1
318+            let lpAssetId = $t01109211195._2
353319             let period = value(getInteger(keyPeriod(baseAssetId)))
354320             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
355321             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
356322                 then unit
357323                 else {
358324                     let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption)
359325                     if ((userBaseAssetAmountToConvertPeriod == period))
360326                         then unit
361327                         else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
362328                     }
363329             if ((claimShareAssetInvocation == claimShareAssetInvocation))
364330                 then {
365331                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
366332                     let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
367333                     $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), (userBaseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), makeString([toString(pmt.amount), toString(lastBlock.timestamp), toString(userBaseAssetAmountToConvert)], separator))], unit)
368334                     }
369335                 else throw("Strict value is not equal to itself.")
370336             }
371337         else throw("Strict value is not equal to itself.")
372338     }
373339 
374340 
375341 
376342 @Callable(i)
377343 func claimShareAsset (baseAssetIdStr,userAddressStr) = {
378344     let checks = [shutdownCheck(i)]
379345     if ((checks == checks))
380346         then {
381347             let userAddress = if ((userAddressStr == ""))
382348                 then i.caller
383349                 else {
384350                     let checkCaller = mustThis(i)
385351                     if ((checkCaller == checkCaller))
386352                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
387353                         else throw("Strict value is not equal to itself.")
388354                     }
389355             if ((userAddress == userAddress))
390356                 then {
391357                     let baseAssetId = parseAssetId(baseAssetIdStr)
392358                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
393359                     if ((shareAssetId == shareAssetId))
394360                         then {
395361                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
396362                             if ((period == period))
397363                                 then {
398364                                     let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
399365                                     let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
400366                                         then true
401367                                         else throwErr("nothing to claim")
402368                                     if ((checkAmountToConvert == checkAmountToConvert))
403369                                         then {
404370                                             let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
405371                                             let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
406372                                                 then true
407373                                                 else throwErr("invalid period")
408374                                             if ((checkPeriod == checkPeriod))
409375                                                 then {
410376                                                     let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
411377                                                     let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
412378                                                     $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), DeleteEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), makeString([toString(shareAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userBaseAssetAmountToConvert)], separator))], unit)
413379                                                     }
414380                                                 else throw("Strict value is not equal to itself.")
415381                                             }
416382                                         else throw("Strict value is not equal to itself.")
417383                                     }
418384                                 else throw("Strict value is not equal to itself.")
419385                             }
420386                         else throw("Strict value is not equal to itself.")
421387                     }
422388                 else throw("Strict value is not equal to itself.")
423389             }
424390         else throw("Strict value is not equal to itself.")
425391     }
426392 
427393 
428394 
429395 @Callable(i)
430396 func get () = {
431397     let checks = [shutdownCheck(i)]
432398     if ((checks == checks))
433399         then {
434400             let pmt = if ((size(i.payments) == 1))
435401                 then i.payments[0]
436402                 else throwErr("exactly 1 payment is expected")
437403             let shareAssetId = pmt.assetId
438404             let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
439405             if ((baseAssetId == baseAssetId))
440406                 then {
441407                     let userAddress = i.caller
442-                    let $t01582016009 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
443-                    let poolAddress = $t01582016009._1
444-                    let lpAssetId = $t01582016009._2
408+                    let $t01527215461 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
409+                    let poolAddress = $t01527215461._1
410+                    let lpAssetId = $t01527215461._2
445411                     let period = value(getInteger(keyPeriod(baseAssetId)))
446412                     let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
447413                     let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
448414                         then unit
449415                         else {
450416                             let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
451417                             if ((userShareAssetAmountToConvertPeriod == period))
452418                                 then unit
453419                                 else invoke(this, "claimBaseAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
454420                             }
455421                     if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
456422                         then {
457423                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
458424                             let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
459425                             $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), StringEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), makeString([toString(pmt.amount), toString(lastBlock.timestamp), toString(userShareAssetAmountToConvert)], separator))], unit)
460426                             }
461427                         else throw("Strict value is not equal to itself.")
462428                     }
463429                 else throw("Strict value is not equal to itself.")
464430             }
465431         else throw("Strict value is not equal to itself.")
466432     }
467433 
468434 
469435 
470436 @Callable(i)
471437 func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
472438     let checks = [shutdownCheck(i)]
473439     if ((checks == checks))
474440         then {
475441             let userAddress = if ((userAddressStr == ""))
476442                 then i.caller
477443                 else {
478444                     let checkCaller = mustThis(i)
479445                     if ((checkCaller == checkCaller))
480446                         then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
481447                         else throw("Strict value is not equal to itself.")
482448                     }
483449             if ((userAddress == userAddress))
484450                 then {
485451                     let baseAssetId = parseAssetId(baseAssetIdStr)
486452                     let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
487453                     if ((shareAssetId == shareAssetId))
488454                         then {
489455                             let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
490456                             if ((period == period))
491457                                 then {
492458                                     let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
493459                                     let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
494460                                     let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
495461                                         then true
496462                                         else throwErr("invalid period")
497463                                     if ((checkPeriod == checkPeriod))
498464                                         then {
499465                                             let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
500466                                             let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
501467                                             $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), DeleteEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), StringEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), makeString([toString(baseAssetAmount), toString(lastBlock.timestamp), toString(price), toString(userShareAssetAmountToConvertPeriod)], separator))], unit)
502468                                             }
503469                                         else throw("Strict value is not equal to itself.")
504470                                     }
505471                                 else throw("Strict value is not equal to itself.")
506472                             }
507473                         else throw("Strict value is not equal to itself.")
508474                     }
509475                 else throw("Strict value is not equal to itself.")
510476             }
511477         else throw("Strict value is not equal to itself.")
512478     }
513479 
514480 
515481 
516482 @Callable(i)
517483 func finalize (baseAssetIdStr) = {
518484     let checks = [shutdownCheck(i)]
519485     if ((checks == checks))
520486         then {
521487             let baseAssetId = parseAssetId(baseAssetIdStr)
522488             let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
523489             if ((shareAssetId == shareAssetId))
524490                 then {
525491                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
526492                     let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
527493                     if ((period == period))
528494                         then {
529495                             let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
530496                             let checkDelay = if ((periodStartHeightOption == unit))
531497                                 then unit
532498                                 else {
533499                                     let delay = (height - value(periodStartHeightOption))
534500                                     let blocksToWait = max([0, (minDelay - delay)])
535501                                     if ((blocksToWait == 0))
536502                                         then unit
537503                                         else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
538504                                     }
539505                             if ((checkDelay == checkDelay))
540506                                 then {
541-                                    let $t02111321294 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
542-                                    let poolAddress = $t02111321294._1
543-                                    let lpAssetId = $t02111321294._2
507+                                    let $t02056520746 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
508+                                    let poolAddress = $t02056520746._1
509+                                    let lpAssetId = $t02056520746._2
544510                                     let stakingReward = valueOrErrorMessage({
545511                                         let @ = invoke(stakingContract, "claimWxDoNotThrow", [assetIdToString(lpAssetId)], nil)
546512                                         if ($isInstanceOf(@, "Int"))
547513                                             then @
548514                                             else unit
549515                                         }, wrapErr("invalid claimWx result"))
550516                                     if ((stakingReward == stakingReward))
551517                                         then {
552518                                             let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
553519                                             let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
554520                                             let checkFinalizationIsRequired = {
555521                                                 let isFinalizationRequired = if (if ((stakingReward > 0))
556522                                                     then true
557523                                                     else (baseAssetAmountToConvert > 0))
558524                                                     then true
559525                                                     else (shareAssetAmountToConvert > 0)
560526                                                 if (isFinalizationRequired)
561527                                                     then true
562528                                                     else throwErr("nothing to finalize")
563529                                                 }
564530                                             if ((checkFinalizationIsRequired == checkFinalizationIsRequired))
565531                                                 then {
566532                                                     let useStakingReward = if ((stakingReward > 0))
567533                                                         then {
568534                                                             let lockPart = fraction(stakingReward, lockFraction, lockFractionMultiplier)
569535                                                             let convertPart = (stakingReward - lockPart)
570536                                                             let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
571537                                                             let lock = if ((lockPart > 0))
572538                                                                 then                                                                 match r {
573539                                                                     case _ => 
574540                                                                         if (if (if ($isInstanceOf($match0._1, "String"))
575541                                                                             then $isInstanceOf($match0._2, "Int")
576542                                                                             else false)
577543                                                                             then $isInstanceOf($match0, "(String, Int)")
578544                                                                             else false)
579545                                                                             then {
580546                                                                                 let function = $match0._1
581547                                                                                 let duration = $match0._2
582548                                                                                 if ((lockPart > 0))
583549                                                                                     then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
584550                                                                                     else unit
585551                                                                                 }
586552                                                                             else throwErr("invalid lock params")
587553                                                                 }
588554                                                                 else unit
589555                                                             if ((lock == lock))
590556                                                                 then {
591557                                                                     let convertedAmount = if ((convertPart > 0))
592558                                                                         then {
593559                                                                             let inAssetId = wxAssetId
594560                                                                             let minimumToReceive = 0
595561                                                                             let outAssetIdStr = assetIdToString(usdtAssetId)
596562                                                                             let targetAddress = toString(this)
597563                                                                             valueOrErrorMessage({
598564                                                                                 let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
599565                                                                                 if ($isInstanceOf(@, "Int"))
600566                                                                                     then @
601567                                                                                     else unit
602568                                                                                 }, wrapErr("invalid swap result"))
603569                                                                             }
604570                                                                         else 0
605571                                                                     if ((convertedAmount == convertedAmount))
606572                                                                         then {
607573                                                                             let lpAssetAmount = if ((convertedAmount > 0))
608574                                                                                 then {
609575                                                                                     let minOutAmount = 0
610576                                                                                     let autoStake = true
611577                                                                                     valueOrErrorMessage({
612578                                                                                         let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdtAssetId, convertedAmount)])
613579                                                                                         if ($isInstanceOf(@, "Int"))
614580                                                                                             then @
615581                                                                                             else unit
616582                                                                                         }, wrapErr("invalid putOneTknV2 result"))
617583                                                                                     }
618584                                                                                 else 0
619585                                                                             if ((lpAssetAmount == lpAssetAmount))
620586                                                                                 then lpAssetAmount
621587                                                                                 else throw("Strict value is not equal to itself.")
622588                                                                             }
623589                                                                         else throw("Strict value is not equal to itself.")
624590                                                                     }
625591                                                                 else throw("Strict value is not equal to itself.")
626592                                                             }
627593                                                         else unit
628594                                                     if ((useStakingReward == useStakingReward))
629595                                                         then {
630596                                                             let getActions = if ((shareAssetAmountToConvert > 0))
631597                                                                 then {
632598                                                                     let price = calcPrice(lpAssetId, shareAssetId)
633599                                                                     if ((price == price))
634600                                                                         then {
635601                                                                             let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
636602                                                                             let baseAssetAmount = {
637603                                                                                 let outAssetId = baseAssetId
638604                                                                                 let minOutAmount = 0
639605                                                                                 valueOrErrorMessage({
640606                                                                                     let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
641607                                                                                     if ($isInstanceOf(@, "Int"))
642608                                                                                         then @
643609                                                                                         else unit
644610                                                                                     }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
645611                                                                                 }
646612                                                                             if ((baseAssetAmount == baseAssetAmount))
647613                                                                                 then {
648614                                                                                     let shareAssetBurn = if ((shareAssetInfo.issuer == this))
649615                                                                                         then invoke(this, "burn", [shareAssetId, shareAssetAmountToConvert], nil)
650616                                                                                         else throwErr("invalid share asset issuer")
651617                                                                                     if ((shareAssetBurn == shareAssetBurn))
652618                                                                                         then {
653619                                                                                             let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
654620                                                                                             let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
655621                                                                                             priceGetUpdateActions
656622                                                                                             }
657623                                                                                         else throw("Strict value is not equal to itself.")
658624                                                                                     }
659625                                                                                 else throw("Strict value is not equal to itself.")
660626                                                                             }
661627                                                                         else throw("Strict value is not equal to itself.")
662628                                                                     }
663629                                                                 else nil
664630                                                             if ((getActions == getActions))
665631                                                                 then {
666632                                                                     let putActions = if ((baseAssetAmountToConvert > 0))
667633                                                                         then {
668634                                                                             let lpAssetAmount = {
669635                                                                                 let minOutAmount = 0
670636                                                                                 let autoStake = true
671637                                                                                 valueOrErrorMessage({
672638                                                                                     let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
673639                                                                                     if ($isInstanceOf(@, "Int"))
674640                                                                                         then @
675641                                                                                         else unit
676642                                                                                     }, wrapErr("invalid putOneTknV2 result"))
677643                                                                                 }
678644                                                                             if ((lpAssetAmount == lpAssetAmount))
679645                                                                                 then {
680646                                                                                     let price = calcPrice(lpAssetId, shareAssetId)
681647                                                                                     if ((price == price))
682648                                                                                         then {
683649                                                                                             let checkPrice = if ((value(toInt(price)) != 0))
684650                                                                                                 then true
685651                                                                                                 else throw("price is ZERO")
686652                                                                                             if ((checkPrice == checkPrice))
687653                                                                                                 then {
688654                                                                                                     let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
689655                                                                                                     let checkShareAssetAmount = if ((value(toInt(price)) != 0))
690656                                                                                                         then true
691657                                                                                                         else throw("shareAssetAmount is ZERO")
692658                                                                                                     if ((checkShareAssetAmount == checkShareAssetAmount))
693659                                                                                                         then {
694660                                                                                                             let shareAssetReissue = if ((shareAssetInfo.issuer == this))
695661                                                                                                                 then invoke(this, "emit", [shareAssetId, shareAssetAmount], nil)
696662                                                                                                                 else throwErr("invalid share asset issuer")
697663                                                                                                             if ((shareAssetReissue == shareAssetReissue))
698664                                                                                                                 then {
699665                                                                                                                     let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
700666                                                                                                                     let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
701667                                                                                                                     pricePutUpdateActions
702668                                                                                                                     }
703669                                                                                                                 else throw("Strict value is not equal to itself.")
704670                                                                                                             }
705671                                                                                                         else throw("Strict value is not equal to itself.")
706672                                                                                                     }
707673                                                                                                 else throw("Strict value is not equal to itself.")
708674                                                                                             }
709675                                                                                         else throw("Strict value is not equal to itself.")
710676                                                                                     }
711677                                                                                 else throw("Strict value is not equal to itself.")
712678                                                                             }
713679                                                                         else nil
714680                                                                     if ((putActions == putActions))
715681                                                                         then {
716682                                                                             let newPeriod = (period + 1)
717683                                                                             let lastPrice = calcPrice(lpAssetId, shareAssetId)
718684                                                                             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)
719685                                                                             $Tuple2(actions, toBytes(lastPrice))
720686                                                                             }
721687                                                                         else throw("Strict value is not equal to itself.")
722688                                                                     }
723689                                                                 else throw("Strict value is not equal to itself.")
724690                                                             }
725691                                                         else throw("Strict value is not equal to itself.")
726692                                                     }
727693                                                 else throw("Strict value is not equal to itself.")
728694                                             }
729695                                         else throw("Strict value is not equal to itself.")
730696                                     }
731697                                 else throw("Strict value is not equal to itself.")
732698                             }
733699                         else throw("Strict value is not equal to itself.")
734700                     }
735701                 else throw("Strict value is not equal to itself.")
736702             }
737703         else throw("Strict value is not equal to itself.")
738704     }
739705 
740706 
741707 @Verifier(tx)
742708 func verify () = {
743709     let targetPublicKey =     match managerPublicKeyOrUnit() {
744710         case pk: ByteVector => 
745711             pk
746712         case _: Unit => 
747713             tx.senderPublicKey
748714         case _ => 
749715             throw("Match error")
750716     }
751717     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
752718     }
753719 
github/deemru/w8io/3ef1775 
116.95 ms ◑