tx · GREoUiztZu1cjmLjvssmYUBdRkwga58j37QTkEQdByUJ

3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3:  -0.03400000 Waves

2023.05.04 13:13 [2562879] smart account 3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3 > SELF 0.00000000 Waves

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

View: original | compacted
Prev: UaHE4eEWLGBCjSmRa3Fx43KGDiCXqnu34e2z1mv5hB1
Next: 46dKdHSxZHcrD88CEobzHgCg2WYXTWUBMCFM8K2CwZxi

Diff: 

OldNewDifferences
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SCALE8 = 8
5+
6+let MULT3 = 1000
57 
68 let MULT8 = 100000000
79 
2729     case valAnyLyst: List[Any] => 
2830         valAnyLyst
2931     case _ => 
30-        throw("fail to cast into List[Any]")
32+        throwErr("fail to cast into List[Any]")
3133 }
3234 
3335 
3537     case valInt: Int => 
3638         valInt
3739     case _ => 
38-        throw("fail to cast into Int")
40+        throwErr("fail to cast into Int")
3941 }
4042 
4143 
4345     case valStr: String => 
4446         valStr
4547     case _ => 
46-        throw("fail to cast into Int")
48+        throwErr("fail to cast into Int")
4749 }
4850 
4951 
5153     case valBin: ByteVector => 
5254         valBin
5355     case _ => 
54-        throw("fail to cast into Int")
56+        throwErr("fail to cast into Int")
5557 }
5658 
5759 
58-func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
60+func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
5961 
6062 
61-func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
63+func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
6264 
6365 
6466 func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
6769 func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
6870 
6971 
70-func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
72+func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
7173 
7274 
7375 func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
116118 
117119 
118120 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
119-
120-
121-func keyStablePoolAddonAddr () = "%s__stablePoolAddonAddr"
122-
123-
124-func keyAddonAddr () = "%s__addonAddr"
125121 
126122 
127123 func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
245241 
246242 let boostingContract = getBoostingAddressOrFail(factoryCfg)
247243 
244+let boostCoeff = {
245+    let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
246+    if ($isInstanceOf(@, "Int"))
247+        then @
248+        else throw(($getType(@) + " couldn't be cast to Int"))
249+    }
250+
248251 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"))
249252 
250253 func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
282285     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
283286     let checkNode = if (!(containsNode(listName, id)))
284287         then true
285-        else throw("Node exists")
288+        else throwErr("Node exists")
286289     if ((checkNode == checkNode))
287290         then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
288291             then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
306309                 then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
307310                 else if ((id == valueOrElse(headOrUnit, "")))
308311                     then [DeleteEntry(keyListHead(listName))]
309-                    else throw(((("invalid node: " + listName) + ".") + id))))
312+                    else throwErr(((("invalid node: " + listName) + ".") + id))))
310313     }
311314 
312315 
320323             then (stakedByUser > zeroBigInt)
321324             else false)
322325             then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
323-            else throw("calcWxPerLpIntegralUserLast: unexpected state")
326+            else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
324327 
325328 
326329 func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
331334         else stakedTotal
332335     let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
333336     let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
334-    let MULT3 = 1000
335337     let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
336-    let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
338+    let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
337339     let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
338340     let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
339341     let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
357359 
358360 
359361 func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
360-    let $t01475014872 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
361-    let wxPerLpIntegralNew = $t01475014872._1
362-    let poolIntegralSTATE = $t01475014872._2
363-    let poolDEBUG = $t01475014872._3
364-    let MULT3 = 1000
362+    let $t01472314845 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
363+    let wxPerLpIntegralNew = $t01472314845._1
364+    let poolIntegralSTATE = $t01472314845._2
365+    let poolDEBUG = $t01472314845._3
365366     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
366367     let stakedByUser = readStaked(stakedByUserKEY)
367368     let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
399400 }
400401 
401402 
402-let permissionDeniedError = throw("Permission denied")
403+let permissionDeniedError = throwErr("Permission denied")
403404 
404405 func mustThis (i) = if ((i.caller == this))
405406     then true
418419     case _ => 
419420         throw("Match error")
420421 }
422+
423+
424+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))
435+        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)
446+            }
447+        else throw("Strict value is not equal to itself.")
448+    }
421449 
422450 
423451 func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
449477                 else unit
450478             if ((r == r))
451479                 then if ((amount > stakedByUser))
452-                    then throw(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
480+                    then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
453481                     else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
454482                 else throw("Strict value is not equal to itself.")
455483             }
499527     let pm = pendingManagerPublicKeyOrUnit()
500528     let hasPM = if (isDefined(pm))
501529         then true
502-        else throw("No pending manager")
530+        else throwErr("No pending manager")
503531     if ((hasPM == hasPM))
504532         then {
505533             let checkPM = if ((i.callerPublicKey == value(pm)))
506534                 then true
507-                else throw("You are not pending manager")
535+                else throwErr("You are not pending manager")
508536             if ((checkPM == checkPM))
509537                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
510538                 else throw("Strict value is not equal to itself.")
516544 
517545 @Callable(i)
518546 func stake () = if ((size(i.payments) != 1))
519-    then throw("invalid payment - exact one payment must be attached")
547+    then throwErr("invalid payment - exact one payment must be attached")
520548     else {
521549         let pmt = i.payments[0]
522550         let lpAssetId = value(pmt.assetId)
523551         let lpAssetIdStr = toBase58String(lpAssetId)
524552         let amount = pmt.amount
525-        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
526-        let callerStr = toString(i.caller)
527-        let userAddressStr = if ((callerStr == poolAddressStr))
528-            then toString(i.originCaller)
529-            else callerStr
530-        let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
531-        let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
532-        let stakedByUser = readStaked(stakedByUserKEY)
533-        let refreshStakedVote = if ((stakedByUser == 0))
534-            then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
535-            else unit
536-        if ((refreshStakedVote == refreshStakedVote))
537-            then {
538-                let stakedTotal = readStaked(stakedTotalKEY)
539-                let $t02161321730 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
540-                let wxToClaimUserNew = $t02161321730._1
541-                let integralSTATE = $t02161321730._2
542-                let debug = $t02161321730._3
543-                let listName = getUsersListName(lpAssetIdStr)
544-                let listActions = if (containsNode(listName, userAddressStr))
545-                    then nil
546-                    else insertNodeActions(listName, userAddressStr)
547-                (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
548-                }
549-            else throw("Strict value is not equal to itself.")
553+        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
554+        let poolAddress = addressFromStringValue(poolAddressStr)
555+        let userAddress = if ((i.caller == poolAddress))
556+            then i.originCaller
557+            else i.caller
558+        stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
559+        }
560+
561+
562+
563+@Callable(i)
564+func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
565+    then throwErr("invalid payment - exact one payment must be attached")
566+    else {
567+        let pmt = i.payments[0]
568+        let lpAssetId = value(pmt.assetId)
569+        let lpAssetIdStr = toBase58String(lpAssetId)
570+        let amount = pmt.amount
571+        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
572+        let poolAddress = addressFromStringValue(poolAddressStr)
573+        let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
574+        stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
550575         }
551576 
552577 
554579 @Callable(i)
555580 func unstake (lpAssetIdStr,amount) = {
556581     let lpAssetId = fromBase58String(lpAssetIdStr)
557-    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
582+    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
558583     let poolAddress = addressFromStringValue(poolAddressStr)
559-    let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
560584     let callerStr = toString(i.caller)
561-    let userAddress = if (if ((callerStr == poolAddressStr))
562-        then true
563-        else (callerStr == poolAddon))
585+    let userAddress = if ((callerStr == poolAddressStr))
564586         then i.originCaller
565587         else i.caller
566588     let lpAssetRecipientAddress = i.caller
572594 @Callable(i)
573595 func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
574596     let lpAssetIdStr = toBase58String(lpAssetId)
575-    let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr)))
597+    let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr))))
576598     let checkCaller = if ((i.caller == poolAddress))
577599         then true
578600         else permissionDeniedError
608630     let checkCaller = mustThis(i)
609631     if ((checkCaller == checkCaller))
610632         then {
611-            let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), "claimWxINTERNAL: invalid user address")
633+            let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
612634             let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
613635             let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
614636             let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
618640             let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
619641             let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
620642             let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
621-            let $t02511625228 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
622-            let wxToClaimUserNew = $t02511625228._1
623-            let integralSTATE = $t02511625228._2
624-            let debug = $t02511625228._3
643+            let $t02599726109 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
644+            let wxToClaimUserNew = $t02599726109._1
645+            let integralSTATE = $t02599726109._2
646+            let debug = $t02599726109._3
625647             let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
626648             if ((zeroBigInt >= availableToClaim))
627649                 then if (throwIfNothingToClaim)
628-                    then throw("nothing to claim")
650+                    then throwErr("nothing to claim")
629651                     else $Tuple2(nil, 0)
630652                 else {
631653                     let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
632654                     let minRewardPart = availableToClaim
633-                    let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
655+                    let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
634656                     let totalReward = (minRewardPart + boostRewardPart)
635657                     let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
636658                     let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
663685             }, SEP)
664686         let unclaimed = info[3]
665687         let claimed = info[4]
666-        let res = (resAcc :+ makeString(["%d%d", unclaimed, claimed], SEP))
688+        let userVoteFinalized = {
689+            let @ = invoke(boostingContract, "getUserVoteFinalizedREADONLY", [lpAssetId, userAddressStr], nil)
690+            if ($isInstanceOf(@, "Int"))
691+                then @
692+                else throw(($getType(@) + " couldn't be cast to Int"))
693+            }
694+        let res = (resAcc :+ makeString(["%d%d%d", unclaimed, claimed, toString(userVoteFinalized)], SEP))
667695         let inv = {
668696             let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
669697             if ($isInstanceOf(@, "List[Any]"))
704732         else (height - emissionStartBlock)
705733     let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
706734     let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
707-    let $t02903729149 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
708-    let wxToClaimUserNew = $t02903729149._1
709-    let integralSTATE = $t02903729149._2
710-    let debug = $t02903729149._3
735+    let $t03016030272 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
736+    let wxToClaimUserNew = $t03016030272._1
737+    let integralSTATE = $t03016030272._2
738+    let debug = $t03016030272._3
711739     let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
712740     let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
713741     let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
714742     let boostDebug = asString(boostInvResult[1])
715743     let minRewardPart = availableToClaim
716-    let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
744+    let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
717745     let totalReward = (minRewardPart + boostRewardPart)
718746     $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
719747     }
724752 func stakedByUserREADONLY (lpAssetIdStr,userAddressStr) = {
725753     let stakedByUser = valueOrElse(getInteger(keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
726754     $Tuple2(nil, stakedByUser)
755+    }
756+
757+
758+
759+@Callable(i)
760+func stakedTotalREADONLY (lpAssetIdStr) = {
761+    let stakedTotal = valueOrElse(getInteger(keyStakedTotal(lpAssetIdStr)), 0)
762+    $Tuple2(nil, stakedTotal)
727763     }
728764 
729765 
781817 
782818 @Callable(i)
783819 func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
784-    then throw("permissions denied")
820+    then throwErr("permissions denied")
785821     else {
786-        let $t03175531865 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
787-        let wxPerLpIntegralNew = $t03175531865._1
788-        let poolIntegralSTATE = $t03175531865._2
789-        let poolDEBUG = $t03175531865._3
822+        let $t03306233172 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
823+        let wxPerLpIntegralNew = $t03306233172._1
824+        let poolIntegralSTATE = $t03306233172._2
825+        let poolDEBUG = $t03306233172._3
790826         poolIntegralSTATE
791827         }
792828 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SCALE8 = 8
5+
6+let MULT3 = 1000
57 
68 let MULT8 = 100000000
79 
810 let SCALE18 = 18
911 
1012 let MULT18 = toBigInt(1000000000000000000)
1113 
1214 let SEP = "__"
1315 
1416 let POOLWEIGHTMULT = MULT8
1517 
1618 let zeroBigInt = toBigInt(0)
1719 
1820 let oneBigInt = toBigInt(1)
1921 
2022 func wrapErr (msg) = makeString(["staking.ride:", toString(this), msg], " ")
2123 
2224 
2325 func throwErr (msg) = throw(wrapErr(msg))
2426 
2527 
2628 func asAnyList (val) = match val {
2729     case valAnyLyst: List[Any] => 
2830         valAnyLyst
2931     case _ => 
30-        throw("fail to cast into List[Any]")
32+        throwErr("fail to cast into List[Any]")
3133 }
3234 
3335 
3436 func asInt (val) = match val {
3537     case valInt: Int => 
3638         valInt
3739     case _ => 
38-        throw("fail to cast into Int")
40+        throwErr("fail to cast into Int")
3941 }
4042 
4143 
4244 func asString (val) = match val {
4345     case valStr: String => 
4446         valStr
4547     case _ => 
46-        throw("fail to cast into Int")
48+        throwErr("fail to cast into Int")
4749 }
4850 
4951 
5052 func asByteVector (val) = match val {
5153     case valBin: ByteVector => 
5254         valBin
5355     case _ => 
54-        throw("fail to cast into Int")
56+        throwErr("fail to cast into Int")
5557 }
5658 
5759 
58-func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
60+func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
5961 
6062 
61-func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
63+func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
6264 
6365 
6466 func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
6567 
6668 
6769 func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
6870 
6971 
70-func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
72+func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
7173 
7274 
7375 func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
7476 
7577 
7678 func getBigIntFromStringOrDefault (address,key,defaultVal) = match getString(address, key) {
7779     case s: String => 
7880         value(parseBigInt(s))
7981     case _: Unit => 
8082         defaultVal
8183     case _ => 
8284         throw("Match error")
8385 }
8486 
8587 
8688 func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), MULT18, toBigInt(origScaleMult))
8789 
8890 
8991 func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), MULT18))
9092 
9193 
9294 func keyFactoryAddress () = "%s%s__config__factoryAddress"
9395 
9496 
9597 func keyVotingEmissionContract () = "%s__votingEmissionContract"
9698 
9799 
98100 let IdxFactoryCfgStakingDapp = 1
99101 
100102 let IdxFactoryCfgBoostingDapp = 2
101103 
102104 let IdxFactoryCfgIdoDapp = 3
103105 
104106 let IdxFactoryCfgTeamDapp = 4
105107 
106108 let IdxFactoryCfgEmissionDapp = 5
107109 
108110 let IdxFactoryCfgRestDapp = 6
109111 
110112 let IdxFactoryCfgSlippageDapp = 7
111113 
112114 func keyFactoryCfg () = "%s__factoryConfig"
113115 
114116 
115117 func keyManagerPublicKey () = "%s__managerPublicKey"
116118 
117119 
118120 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
119-
120-
121-func keyStablePoolAddonAddr () = "%s__stablePoolAddonAddr"
122-
123-
124-func keyAddonAddr () = "%s__addonAddr"
125121 
126122 
127123 func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
128124 
129125 
130126 func keyFactoryLpList () = "%s__lpTokensList"
131127 
132128 
133129 func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
134130 
135131 
136132 func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
137133 
138134 
139135 func readLpList (factory) = split(valueOrElse(getString(factory, keyFactoryLpList()), ""), SEP)
140136 
141137 
142138 func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
143139 
144140 
145141 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
146142 
147143 
148144 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
149145 
150146 
151147 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
152148 
153149 
154150 func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
155151 
156152 
157153 func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
158154 
159155 
160156 func keyEmissionStartBlock () = "%s%s__emission__startBlock"
161157 
162158 
163159 func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
164160 
165161 
166162 func keyEmissionEndBlock () = "%s%s__emission__endBlock"
167163 
168164 
169165 func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
170166 
171167 
172168 func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
173169 
174170 
175171 func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
176172 
177173 
178174 func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
179175 
180176 
181177 func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
182178 
183179 
184180 func keyClaimedTotal (lpAssetIdStr) = makeString(["%s%s%s__claimed__total", lpAssetIdStr], SEP)
185181 
186182 
187183 func readStaked (key) = valueOrElse(getInteger(this, key), 0)
188184 
189185 
190186 func keyLastTotalLpBalance (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "bal"], SEP)
191187 
192188 
193189 func keyLastUserLpBalance (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "bal"], SEP)
194190 
195191 
196192 func keyTotalLpBalanceIntegral (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "balINT"], SEP)
197193 
198194 
199195 func keyUserLpBalanceIntegral (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "balINT"], SEP)
200196 
201197 
202198 func keyTotalLpBalanceIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "lastUpd"], SEP)
203199 
204200 
205201 func keyUserLpBalanceIntegralLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "lastUpd"], SEP)
206202 
207203 
208204 func keyWxPerLpIntegral (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpInt"], SEP)
209205 
210206 
211207 func keyWxPerLpIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpIntH"], SEP)
212208 
213209 
214210 func keyWxToClaimUser (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpInt"], SEP)
215211 
216212 
217213 func keyWxPerLpIntegralUserLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpIntH"], SEP)
218214 
219215 
220216 func keyWxPerLp (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLp"], SEP)
221217 
222218 
223219 func keyWxPerLpX18 (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLpX18"], SEP)
224220 
225221 
226222 func keyWxPerLpIntegralUserLast (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "uIntL"], SEP)
227223 
228224 
229225 func keyOperationHistoryRecord (type,userAddress,txId58) = makeString(["%s%s%s%s__history", type, userAddress, txId58], SEP)
230226 
231227 
232228 func formatHistoryRecord (userAddress,lpAssetId,type,amount) = makeString(["%s%s%s%d%d%d", userAddress, lpAssetId, type, toString(height), toString(lastBlock.timestamp), toString(amount)], SEP)
233229 
234230 
235231 func OperationHistoryEntry (type,userAddress,lpAssetId,amount,txId) = StringEntry(keyOperationHistoryRecord(type, userAddress, toBase58String(txId)), formatHistoryRecord(userAddress, lpAssetId, type, amount))
236232 
237233 
238234 let factoryAddress = getStringOrFail(this, keyFactoryAddress())
239235 
240236 let factoryContract = addressFromStringValue(factoryAddress)
241237 
242238 let factoryCfg = readFactoryCfgOrFail(factoryContract)
243239 
244240 let emissionContract = getEmissionAddressOrFail(factoryCfg)
245241 
246242 let boostingContract = getBoostingAddressOrFail(factoryCfg)
247243 
244+let boostCoeff = {
245+    let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
246+    if ($isInstanceOf(@, "Int"))
247+        then @
248+        else throw(($getType(@) + " couldn't be cast to Int"))
249+    }
250+
248251 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"))
249252 
250253 func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
251254 
252255 
253256 func getUsersListName (lpAssetId) = makeString(["users", lpAssetId], SEP)
254257 
255258 
256259 func keyListHead (listName) = makeString(["%s%s%s", listName, "head"], SEP)
257260 
258261 
259262 func keyListSize (listName) = makeString(["%s%s%s", listName, "size"], SEP)
260263 
261264 
262265 func keyListPrev (listName,id) = makeString(["%s%s%s%s", listName, id, "prev"], SEP)
263266 
264267 
265268 func keyListNext (listName,id) = makeString(["%s%s%s%s", listName, id, "next"], SEP)
266269 
267270 
268271 func containsNode (listName,id) = {
269272     let headOrUnit = getString(this, keyListHead(listName))
270273     let prevOrUnit = getString(this, keyListPrev(listName, id))
271274     let nextOrUnit = getString(this, keyListNext(listName, id))
272275     if (if ((id == valueOrElse(headOrUnit, "")))
273276         then true
274277         else (prevOrUnit != unit))
275278         then true
276279         else (nextOrUnit != unit)
277280     }
278281 
279282 
280283 func insertNodeActions (listName,id) = {
281284     let headOrUnit = getString(this, keyListHead(listName))
282285     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
283286     let checkNode = if (!(containsNode(listName, id)))
284287         then true
285-        else throw("Node exists")
288+        else throwErr("Node exists")
286289     if ((checkNode == checkNode))
287290         then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
288291             then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
289292             else nil)) ++ [StringEntry(keyListHead(listName), id)])
290293         else throw("Strict value is not equal to itself.")
291294     }
292295 
293296 
294297 func deleteNodeActions (listName,id) = {
295298     let headOrUnit = getString(this, keyListHead(listName))
296299     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
297300     let prevOrUnit = getString(this, keyListPrev(listName, id))
298301     let nextOrUnit = getString(this, keyListNext(listName, id))
299302     ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
300303         then (nextOrUnit != unit)
301304         else false)
302305         then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
303306         else if ((nextOrUnit != unit))
304307             then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
305308             else if ((prevOrUnit != unit))
306309                 then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
307310                 else if ((id == valueOrElse(headOrUnit, "")))
308311                     then [DeleteEntry(keyListHead(listName))]
309-                    else throw(((("invalid node: " + listName) + ".") + id))))
312+                    else throwErr(((("invalid node: " + listName) + ".") + id))))
310313     }
311314 
312315 
313316 func calcWxPerLpIntegralUserLast (stakedByUser,wxPerLpIntegralUserLastUpdHeightOrZero,wxPerLpIntegralNew,wxPerLpIntegralUserLastKEY) = if (if ((wxPerLpIntegralUserLastUpdHeightOrZero == zeroBigInt))
314317     then (stakedByUser > zeroBigInt)
315318     else false)
316319     then zeroBigInt
317320     else if ((stakedByUser == zeroBigInt))
318321         then wxPerLpIntegralNew
319322         else if (if ((wxPerLpIntegralUserLastUpdHeightOrZero > zeroBigInt))
320323             then (stakedByUser > zeroBigInt)
321324             else false)
322325             then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
323-            else throw("calcWxPerLpIntegralUserLast: unexpected state")
326+            else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
324327 
325328 
326329 func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
327330     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
328331     let stakedTotal = toBigInt(readStaked(stakedTotalKEY))
329332     let nonZeroStakedTotal = if ((stakedTotal == zeroBigInt))
330333         then oneBigInt
331334         else stakedTotal
332335     let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
333336     let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
334-    let MULT3 = 1000
335337     let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
336-    let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
338+    let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
337339     let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
338340     let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
339341     let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
340342     let wxPerLpIntegralLastUpdHeight = getIntOrDefault(this, wxPerLpIntegralLastUpdHeightKEY, emissionStartBlock)
341343     let wxPerLpIntegral = getBigIntFromStringOrZero(this, wxPerLpIntegralKEY)
342344     let wxPerLpOrZeroX3 = 0
343345     let dh = max([(height - wxPerLpIntegralLastUpdHeight), 0])
344346     let wxPerLpX3 = if ((wxPerLpOrZeroX3 != 0))
345347         then toBigInt(wxPerLpOrZeroX3)
346348         else fraction(toBigInt(poolWxEmissionPerBlockX3), toBigInt(MULT8), nonZeroStakedTotal)
347349     let stakedTotalNew = (stakedTotal + toBigInt(lpDeltaAmount))
348350     let nonZeroStakedTotalNew = if ((stakedTotalNew == zeroBigInt))
349351         then oneBigInt
350352         else stakedTotalNew
351353     let wxPerLpIntegralNew = (wxPerLpIntegral + (wxPerLpX3 * toBigInt(dh)))
352354     let wxPerLpX3New = (toBigInt(poolWxEmissionPerBlockX3) / nonZeroStakedTotalNew)
353355     let wxPerLpIntegralLastUpdHeightNew = height
354356     let debug = makeString([toString(wxPerLpIntegralNew), toString(dh), toString(wxPerLpX3), toString(stakedTotal), toString(poolWxEmissionPerBlockX3), toString(wxEmissionPerBlockX3), toString(poolWeight)], "::")
355357     $Tuple3(wxPerLpIntegralNew, [StringEntry(wxPerLpIntegralKEY, toString(wxPerLpIntegralNew)), IntegerEntry(wxPerLpIntegralLastUpdHeightKEY, wxPerLpIntegralLastUpdHeightNew), StringEntry(wxPerLpKEY, toString(wxPerLpX3New))], debug)
356358     }
357359 
358360 
359361 func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
360-    let $t01475014872 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
361-    let wxPerLpIntegralNew = $t01475014872._1
362-    let poolIntegralSTATE = $t01475014872._2
363-    let poolDEBUG = $t01475014872._3
364-    let MULT3 = 1000
362+    let $t01472314845 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
363+    let wxPerLpIntegralNew = $t01472314845._1
364+    let poolIntegralSTATE = $t01472314845._2
365+    let poolDEBUG = $t01472314845._3
365366     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
366367     let stakedByUser = readStaked(stakedByUserKEY)
367368     let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
368369     let wxPerLpIntegralUserLastUpdHeightKEY = keyWxPerLpIntegralUserLastUpdHeight(lpAssetIdStr, userAddressStr)
369370     let wxPerLpIntegralUserLastKEY = keyWxPerLpIntegralUserLast(lpAssetIdStr, userAddressStr)
370371     let wxToClaimUser = getBigIntFromStringOrZero(this, wxToClaimUserKEY)
371372     let wxPerLpIntegralUserLastUpdHeightOrZero = getIntOrZero(this, wxPerLpIntegralUserLastUpdHeightKEY)
372373     let wxPerLpIntegralUserLast = calcWxPerLpIntegralUserLast(toBigInt(stakedByUser), toBigInt(wxPerLpIntegralUserLastUpdHeightOrZero), wxPerLpIntegralNew, wxPerLpIntegralUserLastKEY)
373374     let MULT11 = (MULT8 * MULT3)
374375     let wxToClaimUserNew = max([(wxToClaimUser + fraction((wxPerLpIntegralNew - wxPerLpIntegralUserLast), toBigInt(stakedByUser), toBigInt(MULT11))), zeroBigInt])
375376     let wxPerLpIntegralUserLastNew = wxPerLpIntegralNew
376377     let wxPerLpIntegralUserLastUpdHeightNew = height
377378     let debug = makeString([toString(wxToClaimUser), toString(wxPerLpIntegralUserLast), toString(stakedByUser), poolDEBUG, toString(height)], "::")
378379     $Tuple3(wxToClaimUserNew, (poolIntegralSTATE ++ [StringEntry(wxToClaimUserKEY, toString(wxToClaimUserNew)), IntegerEntry(wxPerLpIntegralUserLastUpdHeightKEY, wxPerLpIntegralUserLastUpdHeightNew), StringEntry(wxPerLpIntegralUserLastKEY, toString(wxPerLpIntegralUserLastNew))]), debug)
379380     }
380381 
381382 
382383 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
383384     case s: String => 
384385         fromBase58String(s)
385386     case _: Unit => 
386387         unit
387388     case _ => 
388389         throw("Match error")
389390 }
390391 
391392 
392393 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
393394     case s: String => 
394395         fromBase58String(s)
395396     case _: Unit => 
396397         unit
397398     case _ => 
398399         throw("Match error")
399400 }
400401 
401402 
402-let permissionDeniedError = throw("Permission denied")
403+let permissionDeniedError = throwErr("Permission denied")
403404 
404405 func mustThis (i) = if ((i.caller == this))
405406     then true
406407     else permissionDeniedError
407408 
408409 
409410 func mustManager (i) = match managerPublicKeyOrUnit() {
410411     case pk: ByteVector => 
411412         if ((i.callerPublicKey == pk))
412413             then true
413414             else permissionDeniedError
414415     case _: Unit => 
415416         if ((i.caller == this))
416417             then true
417418             else permissionDeniedError
418419     case _ => 
419420         throw("Match error")
420421 }
422+
423+
424+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))
435+        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)
446+            }
447+        else throw("Strict value is not equal to itself.")
448+    }
421449 
422450 
423451 func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
424452     let userAddressStr = toString(userAddress)
425453     let lpAssetIdStr = toBase58String(lpAssetId)
426454     let poolAddressStr = toString(poolAddress)
427455     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
428456     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
429457     let stakedByUser = readStaked(stakedByUserKEY)
430458     let stakedTotal = readStaked(stakedTotalKEY)
431459     let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
432460     let listName = getUsersListName(lpAssetIdStr)
433461     let listActions = if (if (containsNode(listName, userAddressStr))
434462         then (amount == stakedByUser)
435463         else false)
436464         then deleteNodeActions(listName, userAddressStr)
437465         else nil
438466     let refreshStakedVote = if ((amount == stakedByUser))
439467         then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
440468         else unit
441469     if ((refreshStakedVote == refreshStakedVote))
442470         then {
443471             let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
444472             let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
445473             let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
446474             let throwIfNothingToClaim = true
447475             let r = if ((availableToClaim > zeroBigInt))
448476                 then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
449477                 else unit
450478             if ((r == r))
451479                 then if ((amount > stakedByUser))
452-                    then throw(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
480+                    then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
453481                     else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
454482                 else throw("Strict value is not equal to itself.")
455483             }
456484         else throw("Strict value is not equal to itself.")
457485     }
458486 
459487 
460488 @Callable(i)
461489 func constructor (factoryAddressStr) = {
462490     let checkCaller = mustManager(i)
463491     if ((checkCaller == checkCaller))
464492         then [StringEntry(keyFactoryAddress(), factoryAddressStr)]
465493         else throw("Strict value is not equal to itself.")
466494     }
467495 
468496 
469497 
470498 @Callable(i)
471499 func constructorV2 (votingEmissionContract) = {
472500     let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
473501         then true
474502         else "invalid voting emission contract address"]
475503     if ((cheks == cheks))
476504         then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
477505         else throw("Strict value is not equal to itself.")
478506     }
479507 
480508 
481509 
482510 @Callable(i)
483511 func setManager (pendingManagerPublicKey) = {
484512     let checkCaller = mustManager(i)
485513     if ((checkCaller == checkCaller))
486514         then {
487515             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
488516             if ((checkManagerPublicKey == checkManagerPublicKey))
489517                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
490518                 else throw("Strict value is not equal to itself.")
491519             }
492520         else throw("Strict value is not equal to itself.")
493521     }
494522 
495523 
496524 
497525 @Callable(i)
498526 func confirmManager () = {
499527     let pm = pendingManagerPublicKeyOrUnit()
500528     let hasPM = if (isDefined(pm))
501529         then true
502-        else throw("No pending manager")
530+        else throwErr("No pending manager")
503531     if ((hasPM == hasPM))
504532         then {
505533             let checkPM = if ((i.callerPublicKey == value(pm)))
506534                 then true
507-                else throw("You are not pending manager")
535+                else throwErr("You are not pending manager")
508536             if ((checkPM == checkPM))
509537                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
510538                 else throw("Strict value is not equal to itself.")
511539             }
512540         else throw("Strict value is not equal to itself.")
513541     }
514542 
515543 
516544 
517545 @Callable(i)
518546 func stake () = if ((size(i.payments) != 1))
519-    then throw("invalid payment - exact one payment must be attached")
547+    then throwErr("invalid payment - exact one payment must be attached")
520548     else {
521549         let pmt = i.payments[0]
522550         let lpAssetId = value(pmt.assetId)
523551         let lpAssetIdStr = toBase58String(lpAssetId)
524552         let amount = pmt.amount
525-        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
526-        let callerStr = toString(i.caller)
527-        let userAddressStr = if ((callerStr == poolAddressStr))
528-            then toString(i.originCaller)
529-            else callerStr
530-        let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
531-        let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
532-        let stakedByUser = readStaked(stakedByUserKEY)
533-        let refreshStakedVote = if ((stakedByUser == 0))
534-            then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
535-            else unit
536-        if ((refreshStakedVote == refreshStakedVote))
537-            then {
538-                let stakedTotal = readStaked(stakedTotalKEY)
539-                let $t02161321730 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
540-                let wxToClaimUserNew = $t02161321730._1
541-                let integralSTATE = $t02161321730._2
542-                let debug = $t02161321730._3
543-                let listName = getUsersListName(lpAssetIdStr)
544-                let listActions = if (containsNode(listName, userAddressStr))
545-                    then nil
546-                    else insertNodeActions(listName, userAddressStr)
547-                (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
548-                }
549-            else throw("Strict value is not equal to itself.")
553+        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
554+        let poolAddress = addressFromStringValue(poolAddressStr)
555+        let userAddress = if ((i.caller == poolAddress))
556+            then i.originCaller
557+            else i.caller
558+        stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
559+        }
560+
561+
562+
563+@Callable(i)
564+func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
565+    then throwErr("invalid payment - exact one payment must be attached")
566+    else {
567+        let pmt = i.payments[0]
568+        let lpAssetId = value(pmt.assetId)
569+        let lpAssetIdStr = toBase58String(lpAssetId)
570+        let amount = pmt.amount
571+        let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
572+        let poolAddress = addressFromStringValue(poolAddressStr)
573+        let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
574+        stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
550575         }
551576 
552577 
553578 
554579 @Callable(i)
555580 func unstake (lpAssetIdStr,amount) = {
556581     let lpAssetId = fromBase58String(lpAssetIdStr)
557-    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
582+    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
558583     let poolAddress = addressFromStringValue(poolAddressStr)
559-    let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
560584     let callerStr = toString(i.caller)
561-    let userAddress = if (if ((callerStr == poolAddressStr))
562-        then true
563-        else (callerStr == poolAddon))
585+    let userAddress = if ((callerStr == poolAddressStr))
564586         then i.originCaller
565587         else i.caller
566588     let lpAssetRecipientAddress = i.caller
567589     unstakeActions(i, lpAssetId, poolAddress, userAddress, lpAssetRecipientAddress, amount)
568590     }
569591 
570592 
571593 
572594 @Callable(i)
573595 func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
574596     let lpAssetIdStr = toBase58String(lpAssetId)
575-    let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr)))
597+    let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr))))
576598     let checkCaller = if ((i.caller == poolAddress))
577599         then true
578600         else permissionDeniedError
579601     if ((checkCaller == checkCaller))
580602         then unstakeActions(i, lpAssetId, poolAddress, Address(userAddress), Address(lpAssetRecipientAddress), amount)
581603         else throw("Strict value is not equal to itself.")
582604     }
583605 
584606 
585607 
586608 @Callable(i)
587609 func claimWx (lpAssetIdStr) = {
588610     let userAddressStr = toString(i.caller)
589611     let throwIfNothingToClaim = true
590612     let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
591613     $Tuple2(nil, result)
592614     }
593615 
594616 
595617 
596618 @Callable(i)
597619 func claimWxDoNotThrow (lpAssetIdStr) = {
598620     let userAddressStr = toString(i.caller)
599621     let throwIfNothingToClaim = false
600622     let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
601623     $Tuple2(nil, result)
602624     }
603625 
604626 
605627 
606628 @Callable(i)
607629 func claimWxINTERNAL (lpAssetIdStr,userAddressStr,throwIfNothingToClaim) = {
608630     let checkCaller = mustThis(i)
609631     if ((checkCaller == checkCaller))
610632         then {
611-            let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), "claimWxINTERNAL: invalid user address")
633+            let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
612634             let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
613635             let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
614636             let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
615637             let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
616638             let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
617639             let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
618640             let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
619641             let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
620642             let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
621-            let $t02511625228 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
622-            let wxToClaimUserNew = $t02511625228._1
623-            let integralSTATE = $t02511625228._2
624-            let debug = $t02511625228._3
643+            let $t02599726109 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
644+            let wxToClaimUserNew = $t02599726109._1
645+            let integralSTATE = $t02599726109._2
646+            let debug = $t02599726109._3
625647             let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
626648             if ((zeroBigInt >= availableToClaim))
627649                 then if (throwIfNothingToClaim)
628-                    then throw("nothing to claim")
650+                    then throwErr("nothing to claim")
629651                     else $Tuple2(nil, 0)
630652                 else {
631653                     let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
632654                     let minRewardPart = availableToClaim
633-                    let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
655+                    let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
634656                     let totalReward = (minRewardPart + boostRewardPart)
635657                     let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
636658                     let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
637659                     if ((emitBoost == emitBoost))
638660                         then {
639661                             let claimedByUserValue = ((claimedByUser + minRewardPart) + boostRewardPart)
640662                             let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
641663                             let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserBoostReward + boostRewardPart)
642664                             let claimedTotalPlusAvailableToClaim = (claimedTotal + availableToClaim)
643665                             $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))
644666                             }
645667                         else throw("Strict value is not equal to itself.")
646668                     }
647669             }
648670         else throw("Strict value is not equal to itself.")
649671     }
650672 
651673 
652674 
653675 @Callable(i)
654676 func claimWxBulkInternalREADONLY (currentIter,lpAssetIds,userAddressStr,resAcc) = if ((currentIter == size(lpAssetIds)))
655677     then $Tuple2(nil, resAcc)
656678     else {
657679         let lpAssetId = lpAssetIds[currentIter]
658680         let info = split({
659681             let @ = invoke(this, "claimWxREADONLY", [lpAssetId, userAddressStr], nil)
660682             if ($isInstanceOf(@, "String"))
661683                 then @
662684                 else throw(($getType(@) + " couldn't be cast to String"))
663685             }, SEP)
664686         let unclaimed = info[3]
665687         let claimed = info[4]
666-        let res = (resAcc :+ makeString(["%d%d", unclaimed, claimed], SEP))
688+        let userVoteFinalized = {
689+            let @ = invoke(boostingContract, "getUserVoteFinalizedREADONLY", [lpAssetId, userAddressStr], nil)
690+            if ($isInstanceOf(@, "Int"))
691+                then @
692+                else throw(($getType(@) + " couldn't be cast to Int"))
693+            }
694+        let res = (resAcc :+ makeString(["%d%d%d", unclaimed, claimed, toString(userVoteFinalized)], SEP))
667695         let inv = {
668696             let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
669697             if ($isInstanceOf(@, "List[Any]"))
670698                 then @
671699                 else throw(($getType(@) + " couldn't be cast to List[Any]"))
672700             }
673701         if ((inv == inv))
674702             then $Tuple2(nil, inv)
675703             else throw("Strict value is not equal to itself.")
676704         }
677705 
678706 
679707 
680708 @Callable(i)
681709 func claimWxBulkREADONLY (lpAssetIds,userAddressStr) = {
682710     let res = invoke(this, "claimWxBulkInternalREADONLY", [0, lpAssetIds, userAddressStr, nil], nil)
683711     $Tuple2(nil, res)
684712     }
685713 
686714 
687715 
688716 @Callable(i)
689717 func claimWxREADONLY (lpAssetIdStr,userAddressStr) = {
690718     let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
691719     let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
692720     let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
693721     let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
694722     let stakedByUser = readStaked(stakedByUserKEY)
695723     let stakedTotal = readStaked(stakedTotalKEY)
696724     let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
697725     let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
698726     let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
699727     let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
700728     let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
701729     let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
702730     let passedBlocks = if ((emissionStartBlock > height))
703731         then 0
704732         else (height - emissionStartBlock)
705733     let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
706734     let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
707-    let $t02903729149 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
708-    let wxToClaimUserNew = $t02903729149._1
709-    let integralSTATE = $t02903729149._2
710-    let debug = $t02903729149._3
735+    let $t03016030272 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
736+    let wxToClaimUserNew = $t03016030272._1
737+    let integralSTATE = $t03016030272._2
738+    let debug = $t03016030272._3
711739     let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
712740     let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
713741     let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
714742     let boostDebug = asString(boostInvResult[1])
715743     let minRewardPart = availableToClaim
716-    let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
744+    let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
717745     let totalReward = (minRewardPart + boostRewardPart)
718746     $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
719747     }
720748 
721749 
722750 
723751 @Callable(i)
724752 func stakedByUserREADONLY (lpAssetIdStr,userAddressStr) = {
725753     let stakedByUser = valueOrElse(getInteger(keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
726754     $Tuple2(nil, stakedByUser)
755+    }
756+
757+
758+
759+@Callable(i)
760+func stakedTotalREADONLY (lpAssetIdStr) = {
761+    let stakedTotal = valueOrElse(getInteger(keyStakedTotal(lpAssetIdStr)), 0)
762+    $Tuple2(nil, stakedTotal)
727763     }
728764 
729765 
730766 
731767 @Callable(i)
732768 func usersListTraversal (lpAssetId) = {
733769     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
734770         then true
735771         else mustManager(i)
736772     if ((checkCaller == checkCaller))
737773         then {
738774             let listName = getUsersListName(lpAssetId)
739775             let userOrUnit = getString(keyNextUser(lpAssetId))
740776             let headOrUnit = getString(keyListHead(listName))
741777             match userOrUnit {
742778                 case _: Unit => 
743779                     match headOrUnit {
744780                         case _: Unit => 
745781                             $Tuple2(nil, false)
746782                         case head: String => 
747783                             $Tuple2([StringEntry(keyNextUser(lpAssetId), head)], true)
748784                         case _ => 
749785                             throw("Match error")
750786                     }
751787                 case userAddress: String => 
752788                     let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetId, userAddress))
753789                     let poolAddress = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
754790                     let wxToClaimUserNew = refreshINTEGRALS(lpAssetId, userAddress, poolAddress, 0)._1
755791                     let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
756792                     let throwIfNothingToClaim = true
757793                     let r = if ((availableToClaim > zeroBigInt))
758794                         then invoke(this, "claimWxINTERNAL", [lpAssetId, userAddress, throwIfNothingToClaim], nil)
759795                         else unit
760796                     if ((r == r))
761797                         then {
762798                             let nextUserOrUnit = getString(keyListNext(listName, userAddress))
763799                             match nextUserOrUnit {
764800                                 case _: Unit => 
765801                                     $Tuple2([DeleteEntry(keyNextUser(lpAssetId))], false)
766802                                 case nextUser: String => 
767803                                     $Tuple2([StringEntry(keyNextUser(lpAssetId), nextUser)], true)
768804                                 case _ => 
769805                                     throw("Match error")
770806                             }
771807                             }
772808                         else throw("Strict value is not equal to itself.")
773809                 case _ => 
774810                     throw("Match error")
775811             }
776812             }
777813         else throw("Strict value is not equal to itself.")
778814     }
779815 
780816 
781817 
782818 @Callable(i)
783819 func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
784-    then throw("permissions denied")
820+    then throwErr("permissions denied")
785821     else {
786-        let $t03175531865 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
787-        let wxPerLpIntegralNew = $t03175531865._1
788-        let poolIntegralSTATE = $t03175531865._2
789-        let poolDEBUG = $t03175531865._3
822+        let $t03306233172 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
823+        let wxPerLpIntegralNew = $t03306233172._1
824+        let poolIntegralSTATE = $t03306233172._2
825+        let poolDEBUG = $t03306233172._3
790826         poolIntegralSTATE
791827         }
792828 
793829 
794830 @Verifier(tx)
795831 func verify () = {
796832     let targetPublicKey =     match managerPublicKeyOrUnit() {
797833         case pk: ByteVector => 
798834             pk
799835         case _: Unit => 
800836             tx.senderPublicKey
801837         case _ => 
802838             throw("Match error")
803839     }
804840     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
805841     }
806842 
github/deemru/w8io/873ac7e 
123.22 ms ◑