tx · 46dKdHSxZHcrD88CEobzHgCg2WYXTWUBMCFM8K2CwZxi

3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3:  -0.03400000 Waves

2023.07.19 14:44 [2672693] smart account 3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "46dKdHSxZHcrD88CEobzHgCg2WYXTWUBMCFM8K2CwZxi",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1689767064016,
    "version": 2,
    "chainId": 84,
    "sender": "3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3",
    "senderPublicKey": "7GvzKupc5EwAeuw6BXayiGswG3LEmw6artCvXaZzaGKp",
    "proofs": [
        "3TCwYZgLBbYm6tJ2TnjFzkjai8eAmjJGHbeQ6wmKRd8kKeQRhckJegeb1rv7C4SHAKP2WoJ51RXdfp9YaakULoDB"
    ],
    "script": "base64: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",
    "height": 2672693,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GREoUiztZu1cjmLjvssmYUBdRkwga58j37QTkEQdByUJ
Next: none

Diff: 

OldNewDifferences
117117 func keyManagerPublicKey () = "%s__managerPublicKey"
118118 
119119 
120-func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
120+func keyManagerVaultAddress () = "%s__managerVaultAddress"
121121 
122122 
123123 func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
145145 
146146 
147147 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
148+
149+
150+func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
151+    case s: String => 
152+        addressFromStringValue(s)
153+    case _ => 
154+        this
155+}
148156 
149157 
150158 func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
359367 
360368 
361369 func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
362-    let $t01472314845 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
363-    let wxPerLpIntegralNew = $t01472314845._1
364-    let poolIntegralSTATE = $t01472314845._2
365-    let poolDEBUG = $t01472314845._3
370+    let $t01487514997 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
371+    let wxPerLpIntegralNew = $t01487514997._1
372+    let poolIntegralSTATE = $t01487514997._2
373+    let poolDEBUG = $t01487514997._3
366374     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
367375     let stakedByUser = readStaked(stakedByUserKEY)
368376     let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
380388     }
381389 
382390 
383-func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
384-    case s: String => 
385-        fromBase58String(s)
386-    case _: Unit => 
387-        unit
388-    case _ => 
389-        throw("Match error")
390-}
391-
392-
393-func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
394-    case s: String => 
395-        fromBase58String(s)
396-    case _: Unit => 
397-        unit
398-    case _ => 
399-        throw("Match error")
400-}
391+func managerPublicKeyOrUnit () = {
392+    let managerVaultAddress = getManagerVaultAddressOrThis()
393+    match getString(managerVaultAddress, keyManagerPublicKey()) {
394+        case s: String => 
395+            fromBase58String(s)
396+        case _: Unit => 
397+            unit
398+        case _ => 
399+            throw("Match error")
400+    }
401+    }
401402 
402403 
403404 let permissionDeniedError = throwErr("Permission denied")
421422 }
422423 
423424 
425+func ensureVotingEmissionIsFinalized () = {
426+    let votingEmissionContract = addressFromStringValue(getStringValue(this, keyVotingEmissionContract()))
427+    let votingEmissionFinalizationInProgress = {
428+        let @ = invoke(votingEmissionContract, "isFinalizationInProgress", nil, nil)
429+        if ($isInstanceOf(@, "Boolean"))
430+            then @
431+            else throw(($getType(@) + " couldn't be cast to Boolean"))
432+        }
433+    if (!(votingEmissionFinalizationInProgress))
434+        then true
435+        else throwErr("voting emission should be finalized")
436+    }
437+
438+
424439 func stakeActions (i,lpAssetId,poolAddress,userAddress,amount) = {
425-    let userAddressStr = toString(userAddress)
426-    let lpAssetIdStr = toBase58String(lpAssetId)
427-    let poolAddressStr = toString(poolAddress)
428-    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
429-    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
430-    let stakedByUser = readStaked(stakedByUserKEY)
431-    let refreshStakedVote = if ((stakedByUser == 0))
432-        then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
433-        else unit
434-    if ((refreshStakedVote == refreshStakedVote))
440+    let checkVotingEmissionFinalization = ensureVotingEmissionIsFinalized()
441+    if ((checkVotingEmissionFinalization == checkVotingEmissionFinalization))
435442         then {
436-            let stakedTotal = readStaked(stakedTotalKEY)
437-            let $t01806418181 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
438-            let wxToClaimUserNew = $t01806418181._1
439-            let integralSTATE = $t01806418181._2
440-            let debug = $t01806418181._3
441-            let listName = getUsersListName(lpAssetIdStr)
442-            let listActions = if (containsNode(listName, userAddressStr))
443-                then nil
444-                else insertNodeActions(listName, userAddressStr)
445-            (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
443+            let userAddressStr = toString(userAddress)
444+            let lpAssetIdStr = toBase58String(lpAssetId)
445+            let poolAddressStr = toString(poolAddress)
446+            let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
447+            let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
448+            let stakedByUser = readStaked(stakedByUserKEY)
449+            let refreshStakedVote = if ((stakedByUser == 0))
450+                then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
451+                else unit
452+            if ((refreshStakedVote == refreshStakedVote))
453+                then {
454+                    let stakedTotal = readStaked(stakedTotalKEY)
455+                    let $t01859918716 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
456+                    let wxToClaimUserNew = $t01859918716._1
457+                    let integralSTATE = $t01859918716._2
458+                    let debug = $t01859918716._3
459+                    let listName = getUsersListName(lpAssetIdStr)
460+                    let listActions = if (containsNode(listName, userAddressStr))
461+                        then nil
462+                        else insertNodeActions(listName, userAddressStr)
463+                    (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
464+                    }
465+                else throw("Strict value is not equal to itself.")
446466             }
447467         else throw("Strict value is not equal to itself.")
448468     }
449469 
450470 
451471 func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
452-    let userAddressStr = toString(userAddress)
453-    let lpAssetIdStr = toBase58String(lpAssetId)
454-    let poolAddressStr = toString(poolAddress)
455-    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
456-    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
457-    let stakedByUser = readStaked(stakedByUserKEY)
458-    let stakedTotal = readStaked(stakedTotalKEY)
459-    let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
460-    let listName = getUsersListName(lpAssetIdStr)
461-    let listActions = if (if (containsNode(listName, userAddressStr))
462-        then (amount == stakedByUser)
463-        else false)
464-        then deleteNodeActions(listName, userAddressStr)
465-        else nil
466-    let refreshStakedVote = if ((amount == stakedByUser))
467-        then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
468-        else unit
469-    if ((refreshStakedVote == refreshStakedVote))
472+    let checkVotingEmissionFinalization = ensureVotingEmissionIsFinalized()
473+    if ((checkVotingEmissionFinalization == checkVotingEmissionFinalization))
470474         then {
471-            let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
472-            let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
473-            let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
474-            let throwIfNothingToClaim = true
475-            let r = if ((availableToClaim > zeroBigInt))
476-                then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
475+            let userAddressStr = toString(userAddress)
476+            let lpAssetIdStr = toBase58String(lpAssetId)
477+            let poolAddressStr = toString(poolAddress)
478+            let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
479+            let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
480+            let stakedByUser = readStaked(stakedByUserKEY)
481+            let stakedTotal = readStaked(stakedTotalKEY)
482+            let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
483+            let listName = getUsersListName(lpAssetIdStr)
484+            let listActions = if (if (containsNode(listName, userAddressStr))
485+                then (amount == stakedByUser)
486+                else false)
487+                then deleteNodeActions(listName, userAddressStr)
488+                else nil
489+            let refreshStakedVote = if ((amount == stakedByUser))
490+                then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
477491                 else unit
478-            if ((r == r))
479-                then if ((amount > stakedByUser))
480-                    then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
481-                    else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
492+            if ((refreshStakedVote == refreshStakedVote))
493+                then {
494+                    let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
495+                    let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
496+                    let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
497+                    let throwIfNothingToClaim = true
498+                    let r = if ((availableToClaim > zeroBigInt))
499+                        then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
500+                        else unit
501+                    if ((r == r))
502+                        then if ((amount > stakedByUser))
503+                            then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
504+                            else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
505+                        else throw("Strict value is not equal to itself.")
506+                    }
482507                 else throw("Strict value is not equal to itself.")
483508             }
484509         else throw("Strict value is not equal to itself.")
502527         else "invalid voting emission contract address"]
503528     if ((cheks == cheks))
504529         then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
505-        else throw("Strict value is not equal to itself.")
506-    }
507-
508-
509-
510-@Callable(i)
511-func setManager (pendingManagerPublicKey) = {
512-    let checkCaller = mustManager(i)
513-    if ((checkCaller == checkCaller))
514-        then {
515-            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
516-            if ((checkManagerPublicKey == checkManagerPublicKey))
517-                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
518-                else throw("Strict value is not equal to itself.")
519-            }
520-        else throw("Strict value is not equal to itself.")
521-    }
522-
523-
524-
525-@Callable(i)
526-func confirmManager () = {
527-    let pm = pendingManagerPublicKeyOrUnit()
528-    let hasPM = if (isDefined(pm))
529-        then true
530-        else throwErr("No pending manager")
531-    if ((hasPM == hasPM))
532-        then {
533-            let checkPM = if ((i.callerPublicKey == value(pm)))
534-                then true
535-                else throwErr("You are not pending manager")
536-            if ((checkPM == checkPM))
537-                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
538-                else throw("Strict value is not equal to itself.")
539-            }
540530         else throw("Strict value is not equal to itself.")
541531     }
542532 
640630             let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
641631             let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
642632             let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
643-            let $t02599726109 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
644-            let wxToClaimUserNew = $t02599726109._1
645-            let integralSTATE = $t02599726109._2
646-            let debug = $t02599726109._3
633+            let $t02598426096 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
634+            let wxToClaimUserNew = $t02598426096._1
635+            let integralSTATE = $t02598426096._2
636+            let debug = $t02598426096._3
647637             let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
648638             if ((zeroBigInt >= availableToClaim))
649639                 then if (throwIfNothingToClaim)
732722         else (height - emissionStartBlock)
733723     let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
734724     let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
735-    let $t03016030272 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
736-    let wxToClaimUserNew = $t03016030272._1
737-    let integralSTATE = $t03016030272._2
738-    let debug = $t03016030272._3
725+    let $t03014730259 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
726+    let wxToClaimUserNew = $t03014730259._1
727+    let integralSTATE = $t03014730259._2
728+    let debug = $t03014730259._3
739729     let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
740730     let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
741731     let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
819809 func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
820810     then throwErr("permissions denied")
821811     else {
822-        let $t03306233172 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
823-        let wxPerLpIntegralNew = $t03306233172._1
824-        let poolIntegralSTATE = $t03306233172._2
825-        let poolDEBUG = $t03306233172._3
812+        let $t03304933159 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
813+        let wxPerLpIntegralNew = $t03304933159._1
814+        let poolIntegralSTATE = $t03304933159._2
815+        let poolDEBUG = $t03304933159._3
826816         poolIntegralSTATE
827817         }
828818 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SCALE8 = 8
55 
66 let MULT3 = 1000
77 
88 let MULT8 = 100000000
99 
1010 let SCALE18 = 18
1111 
1212 let MULT18 = toBigInt(1000000000000000000)
1313 
1414 let SEP = "__"
1515 
1616 let POOLWEIGHTMULT = MULT8
1717 
1818 let zeroBigInt = toBigInt(0)
1919 
2020 let oneBigInt = toBigInt(1)
2121 
2222 func wrapErr (msg) = makeString(["staking.ride:", toString(this), msg], " ")
2323 
2424 
2525 func throwErr (msg) = throw(wrapErr(msg))
2626 
2727 
2828 func asAnyList (val) = match val {
2929     case valAnyLyst: List[Any] => 
3030         valAnyLyst
3131     case _ => 
3232         throwErr("fail to cast into List[Any]")
3333 }
3434 
3535 
3636 func asInt (val) = match val {
3737     case valInt: Int => 
3838         valInt
3939     case _ => 
4040         throwErr("fail to cast into Int")
4141 }
4242 
4343 
4444 func asString (val) = match val {
4545     case valStr: String => 
4646         valStr
4747     case _ => 
4848         throwErr("fail to cast into Int")
4949 }
5050 
5151 
5252 func asByteVector (val) = match val {
5353     case valBin: ByteVector => 
5454         valBin
5555     case _ => 
5656         throwErr("fail to cast into Int")
5757 }
5858 
5959 
6060 func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
6161 
6262 
6363 func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
6464 
6565 
6666 func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
6767 
6868 
6969 func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
7070 
7171 
7272 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
7373 
7474 
7575 func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
7676 
7777 
7878 func getBigIntFromStringOrDefault (address,key,defaultVal) = match getString(address, key) {
7979     case s: String => 
8080         value(parseBigInt(s))
8181     case _: Unit => 
8282         defaultVal
8383     case _ => 
8484         throw("Match error")
8585 }
8686 
8787 
8888 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), MULT18, toBigInt(origScaleMult))
8989 
9090 
9191 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), MULT18))
9292 
9393 
9494 func keyFactoryAddress () = "%s%s__config__factoryAddress"
9595 
9696 
9797 func keyVotingEmissionContract () = "%s__votingEmissionContract"
9898 
9999 
100100 let IdxFactoryCfgStakingDapp = 1
101101 
102102 let IdxFactoryCfgBoostingDapp = 2
103103 
104104 let IdxFactoryCfgIdoDapp = 3
105105 
106106 let IdxFactoryCfgTeamDapp = 4
107107 
108108 let IdxFactoryCfgEmissionDapp = 5
109109 
110110 let IdxFactoryCfgRestDapp = 6
111111 
112112 let IdxFactoryCfgSlippageDapp = 7
113113 
114114 func keyFactoryCfg () = "%s__factoryConfig"
115115 
116116 
117117 func keyManagerPublicKey () = "%s__managerPublicKey"
118118 
119119 
120-func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
120+func keyManagerVaultAddress () = "%s__managerVaultAddress"
121121 
122122 
123123 func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
124124 
125125 
126126 func keyFactoryLpList () = "%s__lpTokensList"
127127 
128128 
129129 func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
130130 
131131 
132132 func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
133133 
134134 
135135 func readLpList (factory) = split(valueOrElse(getString(factory, keyFactoryLpList()), ""), SEP)
136136 
137137 
138138 func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
139139 
140140 
141141 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
142142 
143143 
144144 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
145145 
146146 
147147 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
148+
149+
150+func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
151+    case s: String => 
152+        addressFromStringValue(s)
153+    case _ => 
154+        this
155+}
148156 
149157 
150158 func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
151159 
152160 
153161 func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
154162 
155163 
156164 func keyEmissionStartBlock () = "%s%s__emission__startBlock"
157165 
158166 
159167 func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
160168 
161169 
162170 func keyEmissionEndBlock () = "%s%s__emission__endBlock"
163171 
164172 
165173 func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
166174 
167175 
168176 func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
169177 
170178 
171179 func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
172180 
173181 
174182 func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
175183 
176184 
177185 func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
178186 
179187 
180188 func keyClaimedTotal (lpAssetIdStr) = makeString(["%s%s%s__claimed__total", lpAssetIdStr], SEP)
181189 
182190 
183191 func readStaked (key) = valueOrElse(getInteger(this, key), 0)
184192 
185193 
186194 func keyLastTotalLpBalance (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "bal"], SEP)
187195 
188196 
189197 func keyLastUserLpBalance (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "bal"], SEP)
190198 
191199 
192200 func keyTotalLpBalanceIntegral (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "balINT"], SEP)
193201 
194202 
195203 func keyUserLpBalanceIntegral (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "balINT"], SEP)
196204 
197205 
198206 func keyTotalLpBalanceIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "lastUpd"], SEP)
199207 
200208 
201209 func keyUserLpBalanceIntegralLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "lastUpd"], SEP)
202210 
203211 
204212 func keyWxPerLpIntegral (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpInt"], SEP)
205213 
206214 
207215 func keyWxPerLpIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpIntH"], SEP)
208216 
209217 
210218 func keyWxToClaimUser (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpInt"], SEP)
211219 
212220 
213221 func keyWxPerLpIntegralUserLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpIntH"], SEP)
214222 
215223 
216224 func keyWxPerLp (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLp"], SEP)
217225 
218226 
219227 func keyWxPerLpX18 (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLpX18"], SEP)
220228 
221229 
222230 func keyWxPerLpIntegralUserLast (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "uIntL"], SEP)
223231 
224232 
225233 func keyOperationHistoryRecord (type,userAddress,txId58) = makeString(["%s%s%s%s__history", type, userAddress, txId58], SEP)
226234 
227235 
228236 func formatHistoryRecord (userAddress,lpAssetId,type,amount) = makeString(["%s%s%s%d%d%d", userAddress, lpAssetId, type, toString(height), toString(lastBlock.timestamp), toString(amount)], SEP)
229237 
230238 
231239 func OperationHistoryEntry (type,userAddress,lpAssetId,amount,txId) = StringEntry(keyOperationHistoryRecord(type, userAddress, toBase58String(txId)), formatHistoryRecord(userAddress, lpAssetId, type, amount))
232240 
233241 
234242 let factoryAddress = getStringOrFail(this, keyFactoryAddress())
235243 
236244 let factoryContract = addressFromStringValue(factoryAddress)
237245 
238246 let factoryCfg = readFactoryCfgOrFail(factoryContract)
239247 
240248 let emissionContract = getEmissionAddressOrFail(factoryCfg)
241249 
242250 let boostingContract = getBoostingAddressOrFail(factoryCfg)
243251 
244252 let boostCoeff = {
245253     let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
246254     if ($isInstanceOf(@, "Int"))
247255         then @
248256         else throw(($getType(@) + " couldn't be cast to Int"))
249257     }
250258 
251259 let lpStakingPoolsContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(makeString(["%s", "lpStakingPoolsContract"], SEP)), wrapErr("lp_staking_pools contract address is undefined"))), wrapErr("invalid lp_staking_pools contract address"))
252260 
253261 func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
254262 
255263 
256264 func getUsersListName (lpAssetId) = makeString(["users", lpAssetId], SEP)
257265 
258266 
259267 func keyListHead (listName) = makeString(["%s%s%s", listName, "head"], SEP)
260268 
261269 
262270 func keyListSize (listName) = makeString(["%s%s%s", listName, "size"], SEP)
263271 
264272 
265273 func keyListPrev (listName,id) = makeString(["%s%s%s%s", listName, id, "prev"], SEP)
266274 
267275 
268276 func keyListNext (listName,id) = makeString(["%s%s%s%s", listName, id, "next"], SEP)
269277 
270278 
271279 func containsNode (listName,id) = {
272280     let headOrUnit = getString(this, keyListHead(listName))
273281     let prevOrUnit = getString(this, keyListPrev(listName, id))
274282     let nextOrUnit = getString(this, keyListNext(listName, id))
275283     if (if ((id == valueOrElse(headOrUnit, "")))
276284         then true
277285         else (prevOrUnit != unit))
278286         then true
279287         else (nextOrUnit != unit)
280288     }
281289 
282290 
283291 func insertNodeActions (listName,id) = {
284292     let headOrUnit = getString(this, keyListHead(listName))
285293     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
286294     let checkNode = if (!(containsNode(listName, id)))
287295         then true
288296         else throwErr("Node exists")
289297     if ((checkNode == checkNode))
290298         then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
291299             then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
292300             else nil)) ++ [StringEntry(keyListHead(listName), id)])
293301         else throw("Strict value is not equal to itself.")
294302     }
295303 
296304 
297305 func deleteNodeActions (listName,id) = {
298306     let headOrUnit = getString(this, keyListHead(listName))
299307     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
300308     let prevOrUnit = getString(this, keyListPrev(listName, id))
301309     let nextOrUnit = getString(this, keyListNext(listName, id))
302310     ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
303311         then (nextOrUnit != unit)
304312         else false)
305313         then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
306314         else if ((nextOrUnit != unit))
307315             then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
308316             else if ((prevOrUnit != unit))
309317                 then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
310318                 else if ((id == valueOrElse(headOrUnit, "")))
311319                     then [DeleteEntry(keyListHead(listName))]
312320                     else throwErr(((("invalid node: " + listName) + ".") + id))))
313321     }
314322 
315323 
316324 func calcWxPerLpIntegralUserLast (stakedByUser,wxPerLpIntegralUserLastUpdHeightOrZero,wxPerLpIntegralNew,wxPerLpIntegralUserLastKEY) = if (if ((wxPerLpIntegralUserLastUpdHeightOrZero == zeroBigInt))
317325     then (stakedByUser > zeroBigInt)
318326     else false)
319327     then zeroBigInt
320328     else if ((stakedByUser == zeroBigInt))
321329         then wxPerLpIntegralNew
322330         else if (if ((wxPerLpIntegralUserLastUpdHeightOrZero > zeroBigInt))
323331             then (stakedByUser > zeroBigInt)
324332             else false)
325333             then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
326334             else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
327335 
328336 
329337 func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
330338     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
331339     let stakedTotal = toBigInt(readStaked(stakedTotalKEY))
332340     let nonZeroStakedTotal = if ((stakedTotal == zeroBigInt))
333341         then oneBigInt
334342         else stakedTotal
335343     let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
336344     let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
337345     let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
338346     let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
339347     let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
340348     let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
341349     let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
342350     let wxPerLpIntegralLastUpdHeight = getIntOrDefault(this, wxPerLpIntegralLastUpdHeightKEY, emissionStartBlock)
343351     let wxPerLpIntegral = getBigIntFromStringOrZero(this, wxPerLpIntegralKEY)
344352     let wxPerLpOrZeroX3 = 0
345353     let dh = max([(height - wxPerLpIntegralLastUpdHeight), 0])
346354     let wxPerLpX3 = if ((wxPerLpOrZeroX3 != 0))
347355         then toBigInt(wxPerLpOrZeroX3)
348356         else fraction(toBigInt(poolWxEmissionPerBlockX3), toBigInt(MULT8), nonZeroStakedTotal)
349357     let stakedTotalNew = (stakedTotal + toBigInt(lpDeltaAmount))
350358     let nonZeroStakedTotalNew = if ((stakedTotalNew == zeroBigInt))
351359         then oneBigInt
352360         else stakedTotalNew
353361     let wxPerLpIntegralNew = (wxPerLpIntegral + (wxPerLpX3 * toBigInt(dh)))
354362     let wxPerLpX3New = (toBigInt(poolWxEmissionPerBlockX3) / nonZeroStakedTotalNew)
355363     let wxPerLpIntegralLastUpdHeightNew = height
356364     let debug = makeString([toString(wxPerLpIntegralNew), toString(dh), toString(wxPerLpX3), toString(stakedTotal), toString(poolWxEmissionPerBlockX3), toString(wxEmissionPerBlockX3), toString(poolWeight)], "::")
357365     $Tuple3(wxPerLpIntegralNew, [StringEntry(wxPerLpIntegralKEY, toString(wxPerLpIntegralNew)), IntegerEntry(wxPerLpIntegralLastUpdHeightKEY, wxPerLpIntegralLastUpdHeightNew), StringEntry(wxPerLpKEY, toString(wxPerLpX3New))], debug)
358366     }
359367 
360368 
361369 func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
362-    let $t01472314845 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
363-    let wxPerLpIntegralNew = $t01472314845._1
364-    let poolIntegralSTATE = $t01472314845._2
365-    let poolDEBUG = $t01472314845._3
370+    let $t01487514997 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
371+    let wxPerLpIntegralNew = $t01487514997._1
372+    let poolIntegralSTATE = $t01487514997._2
373+    let poolDEBUG = $t01487514997._3
366374     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
367375     let stakedByUser = readStaked(stakedByUserKEY)
368376     let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
369377     let wxPerLpIntegralUserLastUpdHeightKEY = keyWxPerLpIntegralUserLastUpdHeight(lpAssetIdStr, userAddressStr)
370378     let wxPerLpIntegralUserLastKEY = keyWxPerLpIntegralUserLast(lpAssetIdStr, userAddressStr)
371379     let wxToClaimUser = getBigIntFromStringOrZero(this, wxToClaimUserKEY)
372380     let wxPerLpIntegralUserLastUpdHeightOrZero = getIntOrZero(this, wxPerLpIntegralUserLastUpdHeightKEY)
373381     let wxPerLpIntegralUserLast = calcWxPerLpIntegralUserLast(toBigInt(stakedByUser), toBigInt(wxPerLpIntegralUserLastUpdHeightOrZero), wxPerLpIntegralNew, wxPerLpIntegralUserLastKEY)
374382     let MULT11 = (MULT8 * MULT3)
375383     let wxToClaimUserNew = max([(wxToClaimUser + fraction((wxPerLpIntegralNew - wxPerLpIntegralUserLast), toBigInt(stakedByUser), toBigInt(MULT11))), zeroBigInt])
376384     let wxPerLpIntegralUserLastNew = wxPerLpIntegralNew
377385     let wxPerLpIntegralUserLastUpdHeightNew = height
378386     let debug = makeString([toString(wxToClaimUser), toString(wxPerLpIntegralUserLast), toString(stakedByUser), poolDEBUG, toString(height)], "::")
379387     $Tuple3(wxToClaimUserNew, (poolIntegralSTATE ++ [StringEntry(wxToClaimUserKEY, toString(wxToClaimUserNew)), IntegerEntry(wxPerLpIntegralUserLastUpdHeightKEY, wxPerLpIntegralUserLastUpdHeightNew), StringEntry(wxPerLpIntegralUserLastKEY, toString(wxPerLpIntegralUserLastNew))]), debug)
380388     }
381389 
382390 
383-func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
384-    case s: String => 
385-        fromBase58String(s)
386-    case _: Unit => 
387-        unit
388-    case _ => 
389-        throw("Match error")
390-}
391-
392-
393-func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
394-    case s: String => 
395-        fromBase58String(s)
396-    case _: Unit => 
397-        unit
398-    case _ => 
399-        throw("Match error")
400-}
391+func managerPublicKeyOrUnit () = {
392+    let managerVaultAddress = getManagerVaultAddressOrThis()
393+    match getString(managerVaultAddress, keyManagerPublicKey()) {
394+        case s: String => 
395+            fromBase58String(s)
396+        case _: Unit => 
397+            unit
398+        case _ => 
399+            throw("Match error")
400+    }
401+    }
401402 
402403 
403404 let permissionDeniedError = throwErr("Permission denied")
404405 
405406 func mustThis (i) = if ((i.caller == this))
406407     then true
407408     else permissionDeniedError
408409 
409410 
410411 func mustManager (i) = match managerPublicKeyOrUnit() {
411412     case pk: ByteVector => 
412413         if ((i.callerPublicKey == pk))
413414             then true
414415             else permissionDeniedError
415416     case _: Unit => 
416417         if ((i.caller == this))
417418             then true
418419             else permissionDeniedError
419420     case _ => 
420421         throw("Match error")
421422 }
422423 
423424 
425+func ensureVotingEmissionIsFinalized () = {
426+    let votingEmissionContract = addressFromStringValue(getStringValue(this, keyVotingEmissionContract()))
427+    let votingEmissionFinalizationInProgress = {
428+        let @ = invoke(votingEmissionContract, "isFinalizationInProgress", nil, nil)
429+        if ($isInstanceOf(@, "Boolean"))
430+            then @
431+            else throw(($getType(@) + " couldn't be cast to Boolean"))
432+        }
433+    if (!(votingEmissionFinalizationInProgress))
434+        then true
435+        else throwErr("voting emission should be finalized")
436+    }
437+
438+
424439 func stakeActions (i,lpAssetId,poolAddress,userAddress,amount) = {
425-    let userAddressStr = toString(userAddress)
426-    let lpAssetIdStr = toBase58String(lpAssetId)
427-    let poolAddressStr = toString(poolAddress)
428-    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
429-    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
430-    let stakedByUser = readStaked(stakedByUserKEY)
431-    let refreshStakedVote = if ((stakedByUser == 0))
432-        then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
433-        else unit
434-    if ((refreshStakedVote == refreshStakedVote))
440+    let checkVotingEmissionFinalization = ensureVotingEmissionIsFinalized()
441+    if ((checkVotingEmissionFinalization == checkVotingEmissionFinalization))
435442         then {
436-            let stakedTotal = readStaked(stakedTotalKEY)
437-            let $t01806418181 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
438-            let wxToClaimUserNew = $t01806418181._1
439-            let integralSTATE = $t01806418181._2
440-            let debug = $t01806418181._3
441-            let listName = getUsersListName(lpAssetIdStr)
442-            let listActions = if (containsNode(listName, userAddressStr))
443-                then nil
444-                else insertNodeActions(listName, userAddressStr)
445-            (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
443+            let userAddressStr = toString(userAddress)
444+            let lpAssetIdStr = toBase58String(lpAssetId)
445+            let poolAddressStr = toString(poolAddress)
446+            let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
447+            let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
448+            let stakedByUser = readStaked(stakedByUserKEY)
449+            let refreshStakedVote = if ((stakedByUser == 0))
450+                then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
451+                else unit
452+            if ((refreshStakedVote == refreshStakedVote))
453+                then {
454+                    let stakedTotal = readStaked(stakedTotalKEY)
455+                    let $t01859918716 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
456+                    let wxToClaimUserNew = $t01859918716._1
457+                    let integralSTATE = $t01859918716._2
458+                    let debug = $t01859918716._3
459+                    let listName = getUsersListName(lpAssetIdStr)
460+                    let listActions = if (containsNode(listName, userAddressStr))
461+                        then nil
462+                        else insertNodeActions(listName, userAddressStr)
463+                    (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
464+                    }
465+                else throw("Strict value is not equal to itself.")
446466             }
447467         else throw("Strict value is not equal to itself.")
448468     }
449469 
450470 
451471 func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
452-    let userAddressStr = toString(userAddress)
453-    let lpAssetIdStr = toBase58String(lpAssetId)
454-    let poolAddressStr = toString(poolAddress)
455-    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
456-    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
457-    let stakedByUser = readStaked(stakedByUserKEY)
458-    let stakedTotal = readStaked(stakedTotalKEY)
459-    let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
460-    let listName = getUsersListName(lpAssetIdStr)
461-    let listActions = if (if (containsNode(listName, userAddressStr))
462-        then (amount == stakedByUser)
463-        else false)
464-        then deleteNodeActions(listName, userAddressStr)
465-        else nil
466-    let refreshStakedVote = if ((amount == stakedByUser))
467-        then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
468-        else unit
469-    if ((refreshStakedVote == refreshStakedVote))
472+    let checkVotingEmissionFinalization = ensureVotingEmissionIsFinalized()
473+    if ((checkVotingEmissionFinalization == checkVotingEmissionFinalization))
470474         then {
471-            let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
472-            let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
473-            let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
474-            let throwIfNothingToClaim = true
475-            let r = if ((availableToClaim > zeroBigInt))
476-                then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
475+            let userAddressStr = toString(userAddress)
476+            let lpAssetIdStr = toBase58String(lpAssetId)
477+            let poolAddressStr = toString(poolAddress)
478+            let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
479+            let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
480+            let stakedByUser = readStaked(stakedByUserKEY)
481+            let stakedTotal = readStaked(stakedTotalKEY)
482+            let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
483+            let listName = getUsersListName(lpAssetIdStr)
484+            let listActions = if (if (containsNode(listName, userAddressStr))
485+                then (amount == stakedByUser)
486+                else false)
487+                then deleteNodeActions(listName, userAddressStr)
488+                else nil
489+            let refreshStakedVote = if ((amount == stakedByUser))
490+                then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
477491                 else unit
478-            if ((r == r))
479-                then if ((amount > stakedByUser))
480-                    then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
481-                    else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
492+            if ((refreshStakedVote == refreshStakedVote))
493+                then {
494+                    let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
495+                    let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
496+                    let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
497+                    let throwIfNothingToClaim = true
498+                    let r = if ((availableToClaim > zeroBigInt))
499+                        then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
500+                        else unit
501+                    if ((r == r))
502+                        then if ((amount > stakedByUser))
503+                            then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
504+                            else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
505+                        else throw("Strict value is not equal to itself.")
506+                    }
482507                 else throw("Strict value is not equal to itself.")
483508             }
484509         else throw("Strict value is not equal to itself.")
485510     }
486511 
487512 
488513 @Callable(i)
489514 func constructor (factoryAddressStr) = {
490515     let checkCaller = mustManager(i)
491516     if ((checkCaller == checkCaller))
492517         then [StringEntry(keyFactoryAddress(), factoryAddressStr)]
493518         else throw("Strict value is not equal to itself.")
494519     }
495520 
496521 
497522 
498523 @Callable(i)
499524 func constructorV2 (votingEmissionContract) = {
500525     let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
501526         then true
502527         else "invalid voting emission contract address"]
503528     if ((cheks == cheks))
504529         then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
505-        else throw("Strict value is not equal to itself.")
506-    }
507-
508-
509-
510-@Callable(i)
511-func setManager (pendingManagerPublicKey) = {
512-    let checkCaller = mustManager(i)
513-    if ((checkCaller == checkCaller))
514-        then {
515-            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
516-            if ((checkManagerPublicKey == checkManagerPublicKey))
517-                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
518-                else throw("Strict value is not equal to itself.")
519-            }
520-        else throw("Strict value is not equal to itself.")
521-    }
522-
523-
524-
525-@Callable(i)
526-func confirmManager () = {
527-    let pm = pendingManagerPublicKeyOrUnit()
528-    let hasPM = if (isDefined(pm))
529-        then true
530-        else throwErr("No pending manager")
531-    if ((hasPM == hasPM))
532-        then {
533-            let checkPM = if ((i.callerPublicKey == value(pm)))
534-                then true
535-                else throwErr("You are not pending manager")
536-            if ((checkPM == checkPM))
537-                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
538-                else throw("Strict value is not equal to itself.")
539-            }
540530         else throw("Strict value is not equal to itself.")
541531     }
542532 
543533 
544534 
545535 @Callable(i)
546536 func stake () = if ((size(i.payments) != 1))
547537     then throwErr("invalid payment - exact one payment must be attached")
548538     else {
549539         let pmt = i.payments[0]
550540         let lpAssetId = value(pmt.assetId)
551541         let lpAssetIdStr = toBase58String(lpAssetId)
552542         let amount = pmt.amount
553543         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
554544         let poolAddress = addressFromStringValue(poolAddressStr)
555545         let userAddress = if ((i.caller == poolAddress))
556546             then i.originCaller
557547             else i.caller
558548         stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
559549         }
560550 
561551 
562552 
563553 @Callable(i)
564554 func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
565555     then throwErr("invalid payment - exact one payment must be attached")
566556     else {
567557         let pmt = i.payments[0]
568558         let lpAssetId = value(pmt.assetId)
569559         let lpAssetIdStr = toBase58String(lpAssetId)
570560         let amount = pmt.amount
571561         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
572562         let poolAddress = addressFromStringValue(poolAddressStr)
573563         let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
574564         stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
575565         }
576566 
577567 
578568 
579569 @Callable(i)
580570 func unstake (lpAssetIdStr,amount) = {
581571     let lpAssetId = fromBase58String(lpAssetIdStr)
582572     let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
583573     let poolAddress = addressFromStringValue(poolAddressStr)
584574     let callerStr = toString(i.caller)
585575     let userAddress = if ((callerStr == poolAddressStr))
586576         then i.originCaller
587577         else i.caller
588578     let lpAssetRecipientAddress = i.caller
589579     unstakeActions(i, lpAssetId, poolAddress, userAddress, lpAssetRecipientAddress, amount)
590580     }
591581 
592582 
593583 
594584 @Callable(i)
595585 func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
596586     let lpAssetIdStr = toBase58String(lpAssetId)
597587     let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr))))
598588     let checkCaller = if ((i.caller == poolAddress))
599589         then true
600590         else permissionDeniedError
601591     if ((checkCaller == checkCaller))
602592         then unstakeActions(i, lpAssetId, poolAddress, Address(userAddress), Address(lpAssetRecipientAddress), amount)
603593         else throw("Strict value is not equal to itself.")
604594     }
605595 
606596 
607597 
608598 @Callable(i)
609599 func claimWx (lpAssetIdStr) = {
610600     let userAddressStr = toString(i.caller)
611601     let throwIfNothingToClaim = true
612602     let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
613603     $Tuple2(nil, result)
614604     }
615605 
616606 
617607 
618608 @Callable(i)
619609 func claimWxDoNotThrow (lpAssetIdStr) = {
620610     let userAddressStr = toString(i.caller)
621611     let throwIfNothingToClaim = false
622612     let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
623613     $Tuple2(nil, result)
624614     }
625615 
626616 
627617 
628618 @Callable(i)
629619 func claimWxINTERNAL (lpAssetIdStr,userAddressStr,throwIfNothingToClaim) = {
630620     let checkCaller = mustThis(i)
631621     if ((checkCaller == checkCaller))
632622         then {
633623             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
634624             let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
635625             let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
636626             let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
637627             let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
638628             let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
639629             let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
640630             let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
641631             let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
642632             let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
643-            let $t02599726109 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
644-            let wxToClaimUserNew = $t02599726109._1
645-            let integralSTATE = $t02599726109._2
646-            let debug = $t02599726109._3
633+            let $t02598426096 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
634+            let wxToClaimUserNew = $t02598426096._1
635+            let integralSTATE = $t02598426096._2
636+            let debug = $t02598426096._3
647637             let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
648638             if ((zeroBigInt >= availableToClaim))
649639                 then if (throwIfNothingToClaim)
650640                     then throwErr("nothing to claim")
651641                     else $Tuple2(nil, 0)
652642                 else {
653643                     let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
654644                     let minRewardPart = availableToClaim
655645                     let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
656646                     let totalReward = (minRewardPart + boostRewardPart)
657647                     let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
658648                     let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
659649                     if ((emitBoost == emitBoost))
660650                         then {
661651                             let claimedByUserValue = ((claimedByUser + minRewardPart) + boostRewardPart)
662652                             let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
663653                             let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserBoostReward + boostRewardPart)
664654                             let claimedTotalPlusAvailableToClaim = (claimedTotal + availableToClaim)
665655                             $Tuple2([StringEntry(claimedByUserKEY, toString(claimedByUserValue)), StringEntry(claimedByUserMinRewardKEY, toString(claimedByUserMinRewardPlusPart)), StringEntry(claimedByUserBoostRewardKEY, toString(claimedByUserBoostRewardPlusBoostRewardPart)), StringEntry(claimedTotalKEY, toString(claimedTotalPlusAvailableToClaim)), ScriptTransfer(userAddress, toInt(minRewardPart), wxAssetId), ScriptTransfer(userAddress, toInt(boostRewardPart), wxAssetId), OperationHistoryEntry("claim", userAddressStr, lpAssetIdStr, toInt(availableToClaim), i.transactionId)], toInt(totalReward))
666656                             }
667657                         else throw("Strict value is not equal to itself.")
668658                     }
669659             }
670660         else throw("Strict value is not equal to itself.")
671661     }
672662 
673663 
674664 
675665 @Callable(i)
676666 func claimWxBulkInternalREADONLY (currentIter,lpAssetIds,userAddressStr,resAcc) = if ((currentIter == size(lpAssetIds)))
677667     then $Tuple2(nil, resAcc)
678668     else {
679669         let lpAssetId = lpAssetIds[currentIter]
680670         let info = split({
681671             let @ = invoke(this, "claimWxREADONLY", [lpAssetId, userAddressStr], nil)
682672             if ($isInstanceOf(@, "String"))
683673                 then @
684674                 else throw(($getType(@) + " couldn't be cast to String"))
685675             }, SEP)
686676         let unclaimed = info[3]
687677         let claimed = info[4]
688678         let userVoteFinalized = {
689679             let @ = invoke(boostingContract, "getUserVoteFinalizedREADONLY", [lpAssetId, userAddressStr], nil)
690680             if ($isInstanceOf(@, "Int"))
691681                 then @
692682                 else throw(($getType(@) + " couldn't be cast to Int"))
693683             }
694684         let res = (resAcc :+ makeString(["%d%d%d", unclaimed, claimed, toString(userVoteFinalized)], SEP))
695685         let inv = {
696686             let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
697687             if ($isInstanceOf(@, "List[Any]"))
698688                 then @
699689                 else throw(($getType(@) + " couldn't be cast to List[Any]"))
700690             }
701691         if ((inv == inv))
702692             then $Tuple2(nil, inv)
703693             else throw("Strict value is not equal to itself.")
704694         }
705695 
706696 
707697 
708698 @Callable(i)
709699 func claimWxBulkREADONLY (lpAssetIds,userAddressStr) = {
710700     let res = invoke(this, "claimWxBulkInternalREADONLY", [0, lpAssetIds, userAddressStr, nil], nil)
711701     $Tuple2(nil, res)
712702     }
713703 
714704 
715705 
716706 @Callable(i)
717707 func claimWxREADONLY (lpAssetIdStr,userAddressStr) = {
718708     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
719709     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
720710     let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
721711     let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
722712     let stakedByUser = readStaked(stakedByUserKEY)
723713     let stakedTotal = readStaked(stakedTotalKEY)
724714     let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
725715     let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
726716     let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
727717     let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
728718     let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
729719     let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
730720     let passedBlocks = if ((emissionStartBlock > height))
731721         then 0
732722         else (height - emissionStartBlock)
733723     let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
734724     let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
735-    let $t03016030272 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
736-    let wxToClaimUserNew = $t03016030272._1
737-    let integralSTATE = $t03016030272._2
738-    let debug = $t03016030272._3
725+    let $t03014730259 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
726+    let wxToClaimUserNew = $t03014730259._1
727+    let integralSTATE = $t03014730259._2
728+    let debug = $t03014730259._3
739729     let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
740730     let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
741731     let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
742732     let boostDebug = asString(boostInvResult[1])
743733     let minRewardPart = availableToClaim
744734     let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
745735     let totalReward = (minRewardPart + boostRewardPart)
746736     $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
747737     }
748738 
749739 
750740 
751741 @Callable(i)
752742 func stakedByUserREADONLY (lpAssetIdStr,userAddressStr) = {
753743     let stakedByUser = valueOrElse(getInteger(keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
754744     $Tuple2(nil, stakedByUser)
755745     }
756746 
757747 
758748 
759749 @Callable(i)
760750 func stakedTotalREADONLY (lpAssetIdStr) = {
761751     let stakedTotal = valueOrElse(getInteger(keyStakedTotal(lpAssetIdStr)), 0)
762752     $Tuple2(nil, stakedTotal)
763753     }
764754 
765755 
766756 
767757 @Callable(i)
768758 func usersListTraversal (lpAssetId) = {
769759     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
770760         then true
771761         else mustManager(i)
772762     if ((checkCaller == checkCaller))
773763         then {
774764             let listName = getUsersListName(lpAssetId)
775765             let userOrUnit = getString(keyNextUser(lpAssetId))
776766             let headOrUnit = getString(keyListHead(listName))
777767             match userOrUnit {
778768                 case _: Unit => 
779769                     match headOrUnit {
780770                         case _: Unit => 
781771                             $Tuple2(nil, false)
782772                         case head: String => 
783773                             $Tuple2([StringEntry(keyNextUser(lpAssetId), head)], true)
784774                         case _ => 
785775                             throw("Match error")
786776                     }
787777                 case userAddress: String => 
788778                     let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetId, userAddress))
789779                     let poolAddress = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
790780                     let wxToClaimUserNew = refreshINTEGRALS(lpAssetId, userAddress, poolAddress, 0)._1
791781                     let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
792782                     let throwIfNothingToClaim = true
793783                     let r = if ((availableToClaim > zeroBigInt))
794784                         then invoke(this, "claimWxINTERNAL", [lpAssetId, userAddress, throwIfNothingToClaim], nil)
795785                         else unit
796786                     if ((r == r))
797787                         then {
798788                             let nextUserOrUnit = getString(keyListNext(listName, userAddress))
799789                             match nextUserOrUnit {
800790                                 case _: Unit => 
801791                                     $Tuple2([DeleteEntry(keyNextUser(lpAssetId))], false)
802792                                 case nextUser: String => 
803793                                     $Tuple2([StringEntry(keyNextUser(lpAssetId), nextUser)], true)
804794                                 case _ => 
805795                                     throw("Match error")
806796                             }
807797                             }
808798                         else throw("Strict value is not equal to itself.")
809799                 case _ => 
810800                     throw("Match error")
811801             }
812802             }
813803         else throw("Strict value is not equal to itself.")
814804     }
815805 
816806 
817807 
818808 @Callable(i)
819809 func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
820810     then throwErr("permissions denied")
821811     else {
822-        let $t03306233172 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
823-        let wxPerLpIntegralNew = $t03306233172._1
824-        let poolIntegralSTATE = $t03306233172._2
825-        let poolDEBUG = $t03306233172._3
812+        let $t03304933159 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
813+        let wxPerLpIntegralNew = $t03304933159._1
814+        let poolIntegralSTATE = $t03304933159._2
815+        let poolDEBUG = $t03304933159._3
826816         poolIntegralSTATE
827817         }
828818 
829819 
830820 @Verifier(tx)
831821 func verify () = {
832822     let targetPublicKey =     match managerPublicKeyOrUnit() {
833823         case pk: ByteVector => 
834824             pk
835825         case _: Unit => 
836826             tx.senderPublicKey
837827         case _ => 
838828             throw("Match error")
839829     }
840830     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
841831     }
842832 
github/deemru/w8io/873ac7e 
123.60 ms ◑