tx · Aq3WRhbiH1Z4fTsSes512H6dk1debkqZb2xd7m1cXTVw

3Mpswv9Gm171QdwF1u8TFnHZm8qAkvaXR5G:  -0.03800000 Waves

2023.05.04 13:10 [2562876] smart account 3Mpswv9Gm171QdwF1u8TFnHZm8qAkvaXR5G > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Aq3WRhbiH1Z4fTsSes512H6dk1debkqZb2xd7m1cXTVw",
    "fee": 3800000,
    "feeAssetId": null,
    "timestamp": 1683194937030,
    "version": 2,
    "chainId": 84,
    "sender": "3Mpswv9Gm171QdwF1u8TFnHZm8qAkvaXR5G",
    "senderPublicKey": "HRyP8LpjDbFrGQTxLdwyfKbHUiXuRRxrQDdN6eLcHz9d",
    "proofs": [
        "4h1d3H6uDeMhno6tVrajhrse4s6rVGp96VYQy1rn5t4am85Jr8xjXQUrMDy24qNBWb8VJNE8tiKW6yvhA2Nmwo18"
    ],
    "script": "base64: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",
    "height": 2562876,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EGTmYWSncvJ1RHrF6q1oyU4fVMSLtKsFABnHZ1GnB9g9
Next: 3NATTU1PkD7JeyZ1LCRyuFqBB8LsFWwDtF1YDjnojcvt

Diff: 

OldNewDifferences
1515 func throwErr (msg) = throw(wrapErr(msg))
1616 
1717 
18-func strf (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
18+func strf (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
1919 
2020 
2121 func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
2424 func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
2525 
2626 
27-func iof (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
27+func iof (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
2828 
2929 
3030 func abs (val) = if ((0 > val))
3636     case valAnyLyst: List[Any] => 
3737         valAnyLyst
3838     case _ => 
39-        throw("fail to cast into List[Any]")
39+        throwErr("fail to cast into List[Any]")
4040 }
4141 
4242 
4444     case valInt: Int => 
4545         valInt
4646     case _ => 
47-        throw("fail to cast into Int")
47+        throwErr("fail to cast into Int")
4848 }
4949 
5050 
8585 let IdxFactoryCfgBirdsDapp = 11
8686 
8787 func keyFactoryCfg () = "%s__factoryConfig"
88-
89-
90-func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
9188 
9289 
9390 func keyFactoryLpList () = "%s__lpTokensList"
136133 
137134 
138135 func keyEmissionStartBlock () = "%s%s__emission__startBlock"
136+
137+
138+func keyBoostingV2LastUpdateHeight () = "%s%s__boostingV2__startBlock"
139+
140+
141+func keyBoostingV2Integral () = "%s%s__boostingV2__integral"
139142 
140143 
141144 func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
195198 
196199 
197200 func mustManager (i) = {
198-    let pd = throw("Permission denied")
201+    let pd = throwErr("Permission denied")
199202     match managerPublicKeyOrUnit() {
200203         case pk: ByteVector => 
201204             if ((i.callerPublicKey == pk))
277280 func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
278281 
279282 
280-func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
283+func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum], SEP)
281284 
282285 
283-func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastInt", userNum, lpAssetId], SEP)
286+func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum, lpAssetId], SEP)
284287 
285288 
286289 func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
301304 func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
302305 
303306 
307+func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
308+
309+
310+func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], SEP)
311+
312+
313+func keyCurrentEpochUi () = makeString(["%s", "currentEpochUi"], SEP)
314+
315+
316+func keyVotingResultStaked (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStaked", lpAssetIdStr, toString(epoch)], SEP)
317+
318+
319+func keyVotingResultStakedIntegral (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegral", lpAssetIdStr, toString(epoch)], SEP)
320+
321+
322+func keyVotingResultStakedLastUpdateHeight (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(epoch)], SEP)
323+
324+
325+func keyVotingResultStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "votingResultStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
326+
327+
328+func keyVoteStakedIntegral (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegral", lpAssetIdStr, toString(address), toString(epoch)], SEP)
329+
330+
331+func keyVoteStakedLastUpdateHeight (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(address), toString(epoch)], SEP)
332+
333+
334+func keyVoteStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
335+
336+
337+func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s", "staked", userAddressStr, lpAssetIdStr], SEP)
338+
339+
304340 let factoryContract = readFactoryAddressOrFail()
305341 
306342 let factoryCfg = readFactoryCfgOrFail(factoryContract)
317353 
318354 let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
319355 
356+let boostCoeff = {
357+    let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
358+    if ($isInstanceOf(@, "Int"))
359+        then @
360+        else throw(($getType(@) + " couldn't be cast to Int"))
361+    }
362+
320363 func getTotalCachedGwx (correct) = {
321-    let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], SEP)
322-    let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi)
364+    let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi())
323365     let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
324366     let targetEpochOption = getInteger(this, keyTargetEpoch)
325367     let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
375417 
376418 
377419 func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
378-    then throw("only one payment is allowed")
420+    then throwErr("only one payment is allowed")
379421     else if ((size(i.payments) == 0))
380422         then 0
381423         else {
382424             let pmt = i.payments[0]
383425             if ((value(pmt.assetId) != expectedAssetId))
384-                then throw("invalid asset id in payment")
426+                then throwErr("invalid asset id in payment")
385427                 else pmt.amount
386428             }
387429 
404446 
405447 
406448 func getVotingEmissionEpochInfo () = {
407-    let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], SEP)
408-    let $t01492815216 = {
409-        let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi))
449+    let $t01710117391 = {
450+        let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi()))
410451         let lastFinalizedEpoch = (currentEpochUi - 1)
411452         if ((0 > lastFinalizedEpoch))
412453             then throwErr("invalid epoch")
413454             else $Tuple2(currentEpochUi, lastFinalizedEpoch)
414455         }
415-    let currentEpochUi = $t01492815216._1
416-    let lastFinalizedEpoch = $t01492815216._2
417-    func keyStartHeightByEpoch (epoch) =     makeString(["%s%d", "startHeight", toString(epoch)], SEP)
418-
456+    let currentEpochUi = $t01710117391._1
457+    let lastFinalizedEpoch = $t01710117391._2
419458     let currentEpochStartHeight = value(getInteger(votingEmissionContract, keyStartHeightByEpoch(currentEpochUi)))
420459     $Tuple2(lastFinalizedEpoch, currentEpochStartHeight)
421460     }
422461 
423462 
424-func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
425-
426-
427-func keyVotingResultStaked (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStaked", lpAssetIdStr, toString(epoch)], SEP)
428-
429-
430-func keyVotingResultStakedIntegral (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegral", lpAssetIdStr, toString(epoch)], SEP)
431-
432-
433-func keyVotingResultStakedLastUpdateHeight (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(epoch)], SEP)
434-
435-
436-func keyVoteStakedIntegral (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegral", lpAssetIdStr, toString(address), toString(epoch)], SEP)
437-
438-
439-func keyVoteStakedLastUpdateHeight (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(address), toString(epoch)], SEP)
440-
441-
442-func getVotingResultStaked (lpAssetIdStr) = {
443-    let $t01690116981 = getVotingEmissionEpochInfo()
444-    let lastFinalizedEpoch = $t01690116981._1
445-    let currentEpochStartHeight = $t01690116981._2
446-    let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
447-    let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
448-    votingResultStaked
449-    }
450-
451-
452-func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
453-    let $t01750217582 = getVotingEmissionEpochInfo()
454-    let lastFinalizedEpoch = $t01750217582._1
455-    let currentEpochStartHeight = $t01750217582._2
456-    let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
457-    let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
458-    let votingResultStakedIntegralKey = keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)
459-    let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, votingResultStakedIntegralKey), 0)
460-    let votingResultLastUpdateHeightKey = keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)
461-    let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, votingResultLastUpdateHeightKey), currentEpochStartHeight)
462-    let votingResultStakedIntegralDh = (height - votingResultStakedLastUpdateHeight)
463-    let votingResultStakedIntegral = ((votingResultStakedIntegralDh * votingResultStaked) + votingResultStakedIntegralPrev)
464-    $Tuple2([IntegerEntry(keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedNew), IntegerEntry(votingResultLastUpdateHeightKey, height), IntegerEntry(votingResultStakedIntegralKey, votingResultStakedIntegral)], votingResultStakedIntegral)
465-    }
466-
467-
468-func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
469-    let $t01878218862 = getVotingEmissionEpochInfo()
470-    let lastFinalizedEpoch = $t01878218862._1
471-    let currentEpochStartHeight = $t01878218862._2
472-    let userAddress = addressFromStringValue(userAddressStr)
463+func getPoolAssetsByLpAssetId (lpAssetIdStr) = {
473464     let idxAmountAssetId = 4
474465     let idxPriceAssetId = 5
475466     let poolCfg = {
476-        let @ = invoke(factoryContract, "getPoolConfigByLpAssetId", [lpAssetIdStr], nil)
467+        let @ = invoke(factoryContract, "getPoolConfigByLpAssetIdREADONLY", [lpAssetIdStr], nil)
477468         if ($isInstanceOf(@, "List[Any]"))
478469             then @
479470             else throw(($getType(@) + " couldn't be cast to List[Any]"))
490481             then @
491482             else throw(($getType(@) + " couldn't be cast to String"))
492483         }
493-    let userVote = valueOrElse(getInteger(votingEmissionContract, keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)), 0)
494-    let actions = if ((userVote == 0))
484+    $Tuple2(amountAssetId, priceAssetId)
485+    }
486+
487+
488+func getUserVoteFinalized (lpAssetIdStr,userAddressStr) = {
489+    let userAddress = addressFromStringValue(userAddressStr)
490+    let $t01808218162 = getVotingEmissionEpochInfo()
491+    let lastFinalizedEpoch = $t01808218162._1
492+    let currentEpochStartHeight = $t01808218162._2
493+    let $t01816518240 = getPoolAssetsByLpAssetId(lpAssetIdStr)
494+    let amountAssetId = $t01816518240._1
495+    let priceAssetId = $t01816518240._2
496+    let userVoteKey = keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)
497+    let userVote = valueOrElse(getInteger(votingEmissionContract, userVoteKey), 0)
498+    userVote
499+    }
500+
501+
502+func getUserVoteStaked (lpAssetIdStr,userAddressStr) = {
503+    let stakedByUser = valueOrElse(getInteger(stakingContract, keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
504+    let userVote = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
505+    if ((stakedByUser == 0))
506+        then 0
507+        else userVote
508+    }
509+
510+
511+func getVotingResultStaked (lpAssetIdStr) = {
512+    let $t01878418864 = getVotingEmissionEpochInfo()
513+    let lastFinalizedEpoch = $t01878418864._1
514+    let currentEpochStartHeight = $t01878418864._2
515+    let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
516+    let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
517+    votingResultStaked
518+    }
519+
520+
521+func getVotingResultStakedIntegral (lpAssetIdStr) = {
522+    let $t01922619306 = getVotingEmissionEpochInfo()
523+    let lastFinalizedEpoch = $t01922619306._1
524+    let currentEpochStartHeight = $t01922619306._2
525+    let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
526+    let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)), 0)
527+    let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)), currentEpochStartHeight)
528+    let votingResultStakedIntegralDh = (height - votingResultStakedLastUpdateHeight)
529+    let votingResultStakedIntegral = ((votingResultStakedIntegralDh * votingResultStaked) + votingResultStakedIntegralPrev)
530+    votingResultStakedIntegral
531+    }
532+
533+
534+func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
535+    let $t02014320223 = getVotingEmissionEpochInfo()
536+    let lastFinalizedEpoch = $t02014320223._1
537+    let currentEpochStartHeight = $t02014320223._2
538+    let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
539+    let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
540+    let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)
541+[IntegerEntry(keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedNew), IntegerEntry(keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch), height), IntegerEntry(keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedIntegral)]
542+    }
543+
544+
545+func getUserVoteStakedIntegral (lpAssetIdStr,userAddressStr) = {
546+    let $t02083420914 = getVotingEmissionEpochInfo()
547+    let lastFinalizedEpoch = $t02083420914._1
548+    let currentEpochStartHeight = $t02083420914._2
549+    let userAddress = addressFromStringValue(userAddressStr)
550+    let userVoteStaked = getUserVoteStaked(lpAssetIdStr, userAddressStr)
551+    let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)), 0)
552+    let userVoteStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch)), currentEpochStartHeight)
553+    let userVoteStakedIntegralDh = (height - userVoteStakedLastUpdateHeight)
554+    let userVoteStakedIntegral = ((userVoteStakedIntegralDh * userVoteStaked) + userVoteStakedIntegralPrev)
555+    userVoteStakedIntegral
556+    }
557+
558+
559+func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
560+    let $t02170221782 = getVotingEmissionEpochInfo()
561+    let lastFinalizedEpoch = $t02170221782._1
562+    let currentEpochStartHeight = $t02170221782._2
563+    let userAddress = addressFromStringValue(userAddressStr)
564+    let userVoteFinalized = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
565+    let actions = if ((userVoteFinalized == 0))
495566         then nil
496567         else {
497568             let stakedVoteDelta = if (edge)
498-                then userVote
499-                else -(userVote)
500-            let $t01946719586 = refreshVotingResultStakedIntegral(lpAssetIdStr, stakedVoteDelta)
501-            let votingResultActions = $t01946719586._1
502-            let votingResultStakedIntegral = $t01946719586._2
503-            let userVoteStaked = if (edge)
504-                then 0
505-                else userVote
506-            let userVoteStakedIntegralKey = keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)
507-            let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, userVoteStakedIntegralKey), 0)
508-            let userVoteStakedLastUpdateHeightKey = keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch)
509-            let userVoteStakedLastUpdateHeight = valueOrElse(getInteger(this, userVoteStakedLastUpdateHeightKey), currentEpochStartHeight)
510-            let userVoteStakedIntegralDh = (height - userVoteStakedLastUpdateHeight)
511-            let userVoteStakedIntegral = ((userVoteStakedIntegralDh * userVoteStaked) + userVoteStakedIntegralPrev)
512-            let voteActions = [IntegerEntry(userVoteStakedLastUpdateHeightKey, height), IntegerEntry(userVoteStakedIntegralKey, userVoteStakedIntegral)]
569+                then userVoteFinalized
570+                else -(userVoteFinalized)
571+            let votingResultActions = refreshVotingResultStakedIntegral(lpAssetIdStr, stakedVoteDelta)
572+            let userVoteStakedIntegral = getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr)
573+            let voteActions = [IntegerEntry(keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch), height), IntegerEntry(keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch), userVoteStakedIntegral)]
513574             (votingResultActions ++ voteActions)
514575             }
515576     actions
516577     }
517578 
518579 
580+func getStakedVotesIntegralsDiff (lpAssetIdStr,userAddressStr) = {
581+    let $t02263622716 = getVotingEmissionEpochInfo()
582+    let lastFinalizedEpoch = $t02263622716._1
583+    let currentEpochStartHeight = $t02263622716._2
584+    let userAddress = addressFromStringValue(userAddressStr)
585+    let userVoteStakedIntegralLastKey = keyVoteStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
586+    let userVoteStakedIntegralLast = valueOrElse(getInteger(this, userVoteStakedIntegralLastKey), 0)
587+    let votingResultStakedIntegralLastKey = keyVotingResultStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
588+    let votingResultStakedIntegralLast = valueOrElse(getInteger(this, votingResultStakedIntegralLastKey), 0)
589+    let userVoteStakedIntegral = getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr)
590+    let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)
591+    let userVoteStakedIntegralDiff = (userVoteStakedIntegral - userVoteStakedIntegralLast)
592+    let votingResultStakedIntegralDiff = (votingResultStakedIntegral - votingResultStakedIntegralLast)
593+    $Tuple3([IntegerEntry(userVoteStakedIntegralLastKey, userVoteStakedIntegral), IntegerEntry(votingResultStakedIntegralLastKey, votingResultStakedIntegral)], userVoteStakedIntegralDiff, votingResultStakedIntegralDiff)
594+    }
595+
596+
597+func refreshBoostEmissionIntegral () = {
598+    let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
599+    let boostingV2LastUpdateHeightOption = getInteger(this, keyBoostingV2LastUpdateHeight())
600+    let boostingV2IngergalOption = getInteger(this, keyBoostingV2Integral())
601+    let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
602+    let h = if ((height > emissionEnd))
603+        then emissionEnd
604+        else height
605+    let dh =     match boostingV2LastUpdateHeightOption {
606+        case lastUpdateHeight: Int => 
607+            max([(h - lastUpdateHeight), 0])
608+        case _: Unit => 
609+            0
610+        case _ => 
611+            throw("Match error")
612+    }
613+    let boostEmissionPerBlock = ((wxEmissionPerBlock * (boostCoeff - 1)) / boostCoeff)
614+    let boostEmissionIntegralPrev = valueOrElse(boostingV2IngergalOption, 0)
615+    let boostEmissionIntegral = ((boostEmissionPerBlock * dh) + boostEmissionIntegralPrev)
616+    $Tuple2([IntegerEntry(keyBoostingV2Integral(), boostEmissionIntegral), IntegerEntry(keyBoostingV2LastUpdateHeight(), height)], boostEmissionIntegral)
617+    }
618+
619+
519620 func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
520-    let EMPTY = "EMPTY"
521-    let userRecordOrEmpty = valueOrElse(getString(this, keyLockParamsRecord(userAddressStr)), EMPTY)
522-    if ((userRecordOrEmpty == EMPTY))
621+    let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
622+    if ((userRecordOption == unit))
523623         then $Tuple3(0, nil, "userRecord::is::empty")
524624         else {
525-            let userRecordArray = split(userRecordOrEmpty, SEP)
625+            let userRecordArray = split(value(userRecordOption), SEP)
526626             let userNumStr = userRecordArray[IdxLockUserNum]
527-            let gwxRewardEmissionStartHeight = valueOrElse(getInteger(gwxRewardContract, keyGwxRewardEmissionStartHeight()), 0)
528627             let EMPTYSTR = "empty"
529-            let $t02106521633 = if ((lpAssetIdStr != EMPTYSTR))
628+            let poolWeight = if ((lpAssetIdStr != EMPTYSTR))
530629                 then {
531-                    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
532-                    let pw1 = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
533-                    let pw0 = valueOrElse(getInteger(factoryContract, keyFactoryPoolWeightHistory(poolAddressStr, 0)), pw1)
534-                    $Tuple2(pw0, pw1)
630+                    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
631+                    getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
535632                     }
536633                 else if (readOnly)
537-                    then $Tuple2(0, 0)
538-                    else throw(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
539-            let poolWeight0 = $t02106521633._1
540-            let poolWeight1 = $t02106521633._2
541-            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
542-            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
543-            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
544-            let h = if ((height > emissionEnd))
545-                then emissionEnd
546-                else height
547-            let dh = max([(h - emissionStart), 0])
634+                    then 0
635+                    else throwErr(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
548636             let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
549637             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
550638             let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), ioz(this, userBoostEmissionLastIntegralKEY))
551-            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
639+            let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
552640             let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
553-            let udh = fraction(userBoostEmissionIntegral, 3, (2 * wxEmissionPerBlock))
554-            let uLastH = (h - udh)
555-            let udh0 = max([(gwxRewardEmissionStartHeight - uLastH), 0])
556-            let udh1 = ((h - uLastH) - udh0)
557-            if (if (if ((0 > uLastH))
558-                then true
559-                else (0 > udh1))
560-                then true
561-                else (abs(((udh0 + udh1) - udh)) >= 1))
562-                then throw(((((((((((("invalid udh calc: udh=" + toString(udh)) + " uLastH=") + toString(uLastH)) + " udh0=") + toString(udh0)) + " udh1=") + toString(udh1)) + " lpAssetId=") + lpAssetIdStr) + " userAddress=") + userAddressStr))
563-                else if ((0 > userBoostEmissionIntegral))
564-                    then throw("wrong calculations")
565-                    else {
566-                        let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
567-                        let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
568-                        let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
569-                        let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
570-                        let totalCachedGwxCorrected = getTotalCachedGwx(true)
571-                        let userCurrGwx = calcCurrentGwxAmount(userAddressStr)
572-                        let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
573-                        let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
574-                        let userBoostEmissionIntegral0 = if ((udh == 0))
575-                            then 0
576-                            else fraction(userBoostEmissionIntegral, udh0, udh)
577-                        let userBoostEmissionIntegral1 = if ((udh == 0))
578-                            then 0
579-                            else fraction(userBoostEmissionIntegral, udh1, udh)
580-                        let poolUserBoostEmissionIntegral0 = fraction(userBoostEmissionIntegral0, poolWeight0, POOLWEIGHTMULT)
581-                        let poolUserBoostEmissionIntegral1 = fraction(userBoostEmissionIntegral1, poolWeight1, POOLWEIGHTMULT)
582-                        let userBoostAvaliableToClaimTotalNew0 = if ((totalCachedGwxCorrected == 0))
583-                            then 0
584-                            else fraction(poolUserBoostEmissionIntegral0, userCurrGwx, totalCachedGwxCorrected)
585-                        let userBoostAvaliableToClaimTotalNew1 = if ((totalCachedGwxCorrected == 0))
586-                            then 0
587-                            else fraction(poolUserBoostEmissionIntegral1, userCurrGwx, totalCachedGwxCorrected)
588-                        let userBoostAvaliableToClaimTotalNew = (userBoostAvaliableToClaimTotalNew0 + userBoostAvaliableToClaimTotalNew1)
589-                        let userBoostClaimedKEY = keyUserBoostClaimed(userNumStr)
590-                        let userBoostClaimed = ioz(this, userBoostClaimedKEY)
591-                        let userBoostAvailable = (userBoostAvaliableToClaimTotalNew - userBoostClaimed)
592-                        let dataState = [IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)]
593-                        let debug = makeString([toString(userBoostEmissionLastIntegral), toString(userBoostEmissionIntegral), toString(userBoostClaimed), toString(userBoostAvailable), toString(poolWeight0), toString(poolWeight1), toString(h), toString(udh), toString(uLastH), toString(udh0), toString(udh1), toString(userCurrGwx), toString(totalCachedGwxCorrected)], ":")
594-                        $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
595-                        }
641+            if ((0 > userBoostEmissionIntegral))
642+                then throwErr("wrong calculations")
643+                else {
644+                    let $t02633526474 = getStakedVotesIntegralsDiff(lpAssetIdStr, userAddressStr)
645+                    let stakedVotesIntegralsActions = $t02633526474._1
646+                    let userVoteIntegralDiff = $t02633526474._2
647+                    let totalVotesIntegralDiff = $t02633526474._3
648+                    let poolUserBoostEmissionIntegral = fraction(userBoostEmissionIntegral, poolWeight, POOLWEIGHTMULT)
649+                    let userBoostAvaliableToClaimTotalNew = if ((totalVotesIntegralDiff == 0))
650+                        then 0
651+                        else fraction(poolUserBoostEmissionIntegral, userVoteIntegralDiff, totalVotesIntegralDiff)
652+                    let dataState = ([IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)] ++ stakedVotesIntegralsActions)
653+                    let debug = makeString([toString(userBoostEmissionLastIntegral), toString(userBoostEmissionIntegral), toString(poolWeight), toString(userVoteIntegralDiff), toString(totalVotesIntegralDiff)], ":")
654+                    $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
655+                    }
596656             }
597657     }
598658 
605665     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
606666     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
607667     if ((size(i.payments) != 1))
608-        then throw("invalid payment - exact one payment must be attached")
668+        then throwErr("invalid payment - exact one payment must be attached")
609669         else {
610670             let pmt = i.payments[0]
611671             let pmtAmount = pmt.amount
612672             if ((assetId != value(pmt.assetId)))
613-                then throw((("invalid asset is in payment - " + assetIdStr) + " is expected"))
673+                then throwErr((("invalid asset is in payment - " + assetIdStr) + " is expected"))
614674                 else {
615675                     let nextUserNumKEY = keyNextUserNum()
616676                     let userAddressStr = toString(i.caller)
626686                     if (if ((minLockAmount > pmtAmount))
627687                         then (i.caller != lpStakingPoolsContract)
628688                         else false)
629-                        then throw(("amount is less then minLockAmount=" + toString(minLockAmount)))
689+                        then throwErr(("amount is less then minLockAmount=" + toString(minLockAmount)))
630690                         else if ((minLockDuration > duration))
631-                            then throw(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
691+                            then throwErr(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
632692                             else if ((duration > maxLockDuration))
633-                                then throw(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
693+                                then throwErr(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
634694                                 else if (if (userIsExisting)
635695                                     then ((iof(this, startBlockKEY) + iof(this, durationKEY)) >= lockStart)
636696                                     else false)
637-                                    then throw("there is an active lock - consider to use increaseLock")
697+                                    then throwErr("there is an active lock - consider to use increaseLock")
638698                                     else if ((ioz(this, userAmountKEY) > 0))
639-                                        then throw(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
699+                                        then throwErr(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
640700                                         else {
641701                                             let coeffX8 = fraction(duration, MULT8, maxLockDuration)
642702                                             let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
644704                                             let k = ai(gWxParamsResultList[0])
645705                                             let b = ai(gWxParamsResultList[1])
646706                                             let period = toString(ai(gWxParamsResultList[2]))
647-                                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
648-                                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
649-                                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
650-                                            let h = if ((height > emissionEnd))
651-                                                then emissionEnd
652-                                                else height
653-                                            let dh = max([(h - emissionStart), 0])
707+                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
654708                                             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
655-                                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
656-                                            let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
657-                                            let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
658-                                            let userMaxBoostInt = ((gWxAmountStart * duration) / 2)
659-                                            let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
660-                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
709+                                            let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
661710                                             let arr = if (userIsExisting)
662711                                                 then nil
663712                                                 else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
682731 
683732 @Callable(i)
684733 func lockRef (duration,referrerAddress,signature) = {
685-    let $t03009830163 = lockActions(i, duration)
686-    let lockActionsResult = $t03009830163._1
687-    let gWxAmountStart = $t03009830163._2
734+    let $t03108531150 = lockActions(i, duration)
735+    let lockActionsResult = $t03108531150._1
736+    let gWxAmountStart = $t03108531150._2
688737     let referralAddress = toString(i.caller)
689738     let refInv = if (if ((referrerAddress == ""))
690739         then true
705754 
706755 @Callable(i)
707756 func lock (duration) = {
708-    let $t03062130686 = lockActions(i, duration)
709-    let lockActionsResult = $t03062130686._1
710-    let gWxAmountStart = $t03062130686._2
757+    let $t03160831673 = lockActions(i, duration)
758+    let lockActionsResult = $t03160831673._1
759+    let gWxAmountStart = $t03160831673._2
711760     let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
712761     if ((updateRefActivity == updateRefActivity))
713762         then $Tuple2(lockActionsResult, unit)
735784     let userAmountNew = (userAmount + pmtAmount)
736785     let lockDurationNew = (remainingDuration + deltaDuration)
737786     if ((0 > deltaDuration))
738-        then throw("duration is less then zero")
787+        then throwErr("duration is less then zero")
739788         else if ((minLockDuration > lockDurationNew))
740-            then throw(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
789+            then throwErr(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
741790             else if ((lockDurationNew > maxLockDuration))
742-                then throw(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
791+                then throwErr(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
743792                 else {
744793                     let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
745794                     let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
751800                             let k = ai(gWxParamsResultList[0])
752801                             let b = ai(gWxParamsResultList[1])
753802                             let period = toString(ai(gWxParamsResultList[2]))
754-                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
755-                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
756-                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
757-                            let h = if ((height > emissionEnd))
758-                                then emissionEnd
759-                                else height
760-                            let dh = max([(h - emissionStart), 0])
761-                            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
762-                            let userBoostEmissionLastIntegral = ioz(this, userBoostEmissionLastIntegralKEY)
763-                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
764-                            let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
765-                            if ((0 > userBoostEmissionIntegral))
766-                                then throw("wrong calculations")
803+                            let currUserGwx = calcCurrentGwxAmount(userAddressStr)
804+                            let gwxDiff = (gWxAmountStart - currUserGwx)
805+                            if ((0 > gwxDiff))
806+                                then throwErr(("gwxDiff is less then 0: " + toString(gwxDiff)))
767807                                 else {
768-                                    let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
769-                                    let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
770-                                    let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
771-                                    let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
772-                                    let currUserGwx = calcCurrentGwxAmount(userAddressStr)
773-                                    let gwxDiff = (gWxAmountStart - currUserGwx)
774-                                    if ((0 > gwxDiff))
775-                                        then throw(("gwxDiff is less then 0: " + toString(gwxDiff)))
776-                                        else {
777-                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
778-                                            let totalCachedGwxCorrected = getTotalCachedGwx(true)
779-                                            let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
780-                                            let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
781-                                            let userBoostAvaliableToClaimTotalNew = fraction(userBoostEmissionIntegral, currUserGwx, totalCachedGwxCorrected)
782-                                            let userMaxBoostIntNew = ((gWxAmountStart * lockDurationNew) / 2)
783-                                            let remainingUserMaxBoostInt = ((currUserGwx * remainingDuration) / 2)
784-                                            let userMaxBoostIntDiff = (userMaxBoostIntNew - remainingUserMaxBoostInt)
785-                                            (((LockParamsEntry(userAddressStr, userNumStr, userAmountNew, lockStartNew, lockDurationNew, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, lockDurationNew, k, b, i)) ++ [IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gwxDiff))])
786-                                            }
808+                                    let totalCachedGwxRaw = getTotalCachedGwx(false)
809+                                    let totalCachedGwxCorrected = getTotalCachedGwx(true)
810+                                    (((LockParamsEntry(userAddressStr, userNumStr, userAmountNew, lockStartNew, lockDurationNew, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, lockDurationNew, k, b, i)) ++ [IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gwxDiff))])
787811                                     }
788812                             }
789813                         else throw("Strict value is not equal to itself.")
794818 
795819 @Callable(i)
796820 func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
797-    then throw("permissions denied")
821+    then throwErr("permissions denied")
798822     else {
799-        let $t03566735769 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
800-        let userBoostAvailable = $t03566735769._1
801-        let dataState = $t03566735769._2
802-        let debug = $t03566735769._3
823+        let $t03477834880 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
824+        let userBoostAvailable = $t03477834880._1
825+        let dataState = $t03477834880._2
826+        let debug = $t03477834880._3
803827         $Tuple2(dataState, [userBoostAvailable])
804828         }
805829 
807831 
808832 @Callable(i)
809833 func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
810-    let $t03590136002 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
811-    let userBoostAvailable = $t03590136002._1
812-    let dataState = $t03590136002._2
813-    let debug = $t03590136002._3
834+    let $t03501235113 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
835+    let userBoostAvailable = $t03501235113._1
836+    let dataState = $t03501235113._2
837+    let debug = $t03501235113._3
814838     $Tuple2(nil, [userBoostAvailable, debug])
815839     }
816840 
827851     let cfgArray = readConfigArrayOrFail()
828852     let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
829853     if ((lockEnd >= height))
830-        then throw((("wait " + toString(lockEnd)) + " to unlock"))
854+        then throwErr((("wait " + toString(lockEnd)) + " to unlock"))
831855         else if ((0 >= userAmount))
832-            then throw("nothing to unlock")
856+            then throwErr("nothing to unlock")
833857             else {
834858                 let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
835859                 (((LockParamsEntry(userAddress, userNumStr, 0, lockStart, lockDuration, 0, 0, toString(period)) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ ScriptTransfer(addressFromStringValue(userAddress), userAmount, assetId))
880904 
881905 
882906 @Callable(i)
907+func onBoostEmissionUpdate () = {
908+    let checkCaller = if ((i.caller == emissionContract))
909+        then true
910+        else mustManager(i)
911+    if ((checkCaller == checkCaller))
912+        then refreshBoostEmissionIntegral()
913+        else throw("Strict value is not equal to itself.")
914+    }
915+
916+
917+
918+@Callable(i)
883919 func onStakedVoteUpdate (lpAssetIdStr,userAddressStr,edge) = {
884920     let checkCaller = if ((i.caller == stakingContract))
885921         then true
896932 
897933 @Callable(i)
898934 func getVotingResultStakedREADONLY (lpAssetIdStr) = $Tuple2(nil, getVotingResultStaked(lpAssetIdStr))
935+
936+
937+
938+@Callable(i)
939+func getVotingResultStakedIntegralREADONLY (lpAssetIdStr) = $Tuple2(nil, getVotingResultStakedIntegral(lpAssetIdStr))
940+
941+
942+
943+@Callable(i)
944+func getUserVoteFinalizedREADONLY (lpAssetIdStr,userAddressStr) = $Tuple2(nil, getUserVoteFinalized(lpAssetIdStr, userAddressStr))
945+
946+
947+
948+@Callable(i)
949+func getUserVoteStakedIntegralREADONLY (lpAssetIdStr,userAddressStr) = $Tuple2(nil, getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr))
899950 
900951 
901952 
919970     let pm = pendingManagerPublicKeyOrUnit()
920971     let hasPM = if (isDefined(pm))
921972         then true
922-        else throw("No pending manager")
973+        else throwErr("No pending manager")
923974     if ((hasPM == hasPM))
924975         then {
925976             let checkPM = if ((i.callerPublicKey == value(pm)))
926977                 then true
927-                else throw("You are not pending manager")
978+                else throwErr("You are not pending manager")
928979             if ((checkPM == checkPM))
929980                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
930981                 else throw("Strict value is not equal to itself.")

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 let SCALE8 = 8
77 
88 let MULT8 = 100000000
99 
1010 let POOLWEIGHTMULT = MULT8
1111 
1212 func wrapErr (msg) = makeString(["boosting.ride:", msg], " ")
1313 
1414 
1515 func throwErr (msg) = throw(wrapErr(msg))
1616 
1717 
18-func strf (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
18+func strf (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
1919 
2020 
2121 func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
2222 
2323 
2424 func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
2525 
2626 
27-func iof (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
27+func iof (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
2828 
2929 
3030 func abs (val) = if ((0 > val))
3131     then -(val)
3232     else val
3333 
3434 
3535 func aal (val) = match val {
3636     case valAnyLyst: List[Any] => 
3737         valAnyLyst
3838     case _ => 
39-        throw("fail to cast into List[Any]")
39+        throwErr("fail to cast into List[Any]")
4040 }
4141 
4242 
4343 func ai (val) = match val {
4444     case valInt: Int => 
4545         valInt
4646     case _ => 
47-        throw("fail to cast into Int")
47+        throwErr("fail to cast into Int")
4848 }
4949 
5050 
5151 func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
5252 
5353 
5454 let referralsContractAddressOrFail = addressFromStringValue(strf(this, keyReferralsContractAddress()))
5555 
5656 let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
5757 
5858 let referralProgramNameDefault = "wxlock"
5959 
6060 let referralProgramName = valueOrElse(getString(this, keyReferralProgramName), referralProgramNameDefault)
6161 
6262 func keyFactoryAddress () = "%s%s__config__factoryAddress"
6363 
6464 
6565 let IdxFactoryCfgStakingDapp = 1
6666 
6767 let IdxFactoryCfgBoostingDapp = 2
6868 
6969 let IdxFactoryCfgIdoDapp = 3
7070 
7171 let IdxFactoryCfgTeamDapp = 4
7272 
7373 let IdxFactoryCfgEmissionDapp = 5
7474 
7575 let IdxFactoryCfgRestDapp = 6
7676 
7777 let IdxFactoryCfgSlippageDapp = 7
7878 
7979 let IdxFactoryCfgDaoDapp = 8
8080 
8181 let IdxFactoryCfgMarketingDapp = 9
8282 
8383 let IdxFactoryCfgGwxRewardDapp = 10
8484 
8585 let IdxFactoryCfgBirdsDapp = 11
8686 
8787 func keyFactoryCfg () = "%s__factoryConfig"
88-
89-
90-func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
9188 
9289 
9390 func keyFactoryLpList () = "%s__lpTokensList"
9491 
9592 
9693 func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
9794 
9895 
9996 func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
10097 
10198 
10299 func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
103100 
104101 
105102 func readFactoryAddressOrFail () = addressFromStringValue(strf(this, keyFactoryAddress()))
106103 
107104 
108105 func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
109106 
110107 
111108 func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
112109 
113110 
114111 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
115112 
116113 
117114 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
118115 
119116 
120117 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
121118 
122119 
123120 func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
124121 
125122 
126123 func keyManagerPublicKey () = "%s__managerPublicKey"
127124 
128125 
129126 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
130127 
131128 
132129 func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
133130 
134131 
135132 func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
136133 
137134 
138135 func keyEmissionStartBlock () = "%s%s__emission__startBlock"
136+
137+
138+func keyBoostingV2LastUpdateHeight () = "%s%s__boostingV2__startBlock"
139+
140+
141+func keyBoostingV2Integral () = "%s%s__boostingV2__integral"
139142 
140143 
141144 func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
142145 
143146 
144147 func keyEmissionEndBlock () = "%s%s__emission__endBlock"
145148 
146149 
147150 func keyNextPeriod () = "%s__nextPeriod"
148151 
149152 
150153 func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
151154 
152155 
153156 let IdxCfgAssetId = 1
154157 
155158 let IdxCfgMinLockAmount = 2
156159 
157160 let IdxCfgMinLockDuration = 3
158161 
159162 let IdxCfgMaxLockDuration = 4
160163 
161164 let IdxCfgMathContract = 5
162165 
163166 func keyConfig () = "%s__config"
164167 
165168 
166169 func readConfigArrayOrFail () = split(strf(this, keyConfig()), SEP)
167170 
168171 
169172 let mathContract = addressFromStringValue(readConfigArrayOrFail()[IdxCfgMathContract])
170173 
171174 func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
172175 
173176 
174177 func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
175178 
176179 
177180 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
178181     case s: String => 
179182         fromBase58String(s)
180183     case _: Unit => 
181184         unit
182185     case _ => 
183186         throw("Match error")
184187 }
185188 
186189 
187190 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
188191     case s: String => 
189192         fromBase58String(s)
190193     case _: Unit => 
191194         unit
192195     case _ => 
193196         throw("Match error")
194197 }
195198 
196199 
197200 func mustManager (i) = {
198-    let pd = throw("Permission denied")
201+    let pd = throwErr("Permission denied")
199202     match managerPublicKeyOrUnit() {
200203         case pk: ByteVector => 
201204             if ((i.callerPublicKey == pk))
202205                 then true
203206                 else pd
204207         case _: Unit => 
205208             if ((i.caller == this))
206209                 then true
207210                 else pd
208211         case _ => 
209212             throw("Match error")
210213     }
211214     }
212215 
213216 
214217 let IdxLockUserNum = 1
215218 
216219 let IdxLockAmount = 2
217220 
218221 let IdxLockStart = 3
219222 
220223 let IdxLockDuration = 4
221224 
222225 let IdxLockParamK = 5
223226 
224227 let IdxLockParamB = 6
225228 
226229 func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
227230 
228231 
229232 func readLockParamsRecordOrFail (userAddress) = split(strf(this, keyLockParamsRecord(userAddress)), SEP)
230233 
231234 
232235 func formatLockParamsRecordS (userNum,amount,start,duration,paramK,paramB,lastUpdTimestamp,gwxAmount) = makeString(["%d%d%d%d%d%d%d%d", userNum, amount, start, duration, paramK, paramB, lastUpdTimestamp, gwxAmount], SEP)
233236 
234237 
235238 func formatLockParamsRecord (userNum,amount,start,duration,paramK,paramB,gwxAmount) = formatLockParamsRecordS(userNum, toString(amount), toString(start), toString(duration), toString(paramK), toString(paramB), toString(lastBlock.timestamp), toString(gwxAmount))
236239 
237240 
238241 func keyNextUserNum () = "%s__nextUserNum"
239242 
240243 
241244 func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
242245 
243246 
244247 func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
245248 
246249 
247250 func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
248251 
249252 
250253 func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
251254 
252255 
253256 func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
254257 
255258 
256259 func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
257260 
258261 
259262 func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
260263 
261264 
262265 func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
263266 
264267 
265268 func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
266269 
267270 
268271 func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
269272 
270273 
271274 func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
272275 
273276 
274277 func keyStatsLocksCount () = "%s%s__stats__locksCount"
275278 
276279 
277280 func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
278281 
279282 
280-func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
283+func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum], SEP)
281284 
282285 
283-func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastInt", userNum, lpAssetId], SEP)
286+func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum, lpAssetId], SEP)
284287 
285288 
286289 func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
287290 
288291 
289292 func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
290293 
291294 
292295 func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
293296 
294297 
295298 func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
296299 
297300 
298301 func keyTotalCachedGwx () = "%s%s__gwxCached__total"
299302 
300303 
301304 func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
302305 
303306 
307+func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
308+
309+
310+func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], SEP)
311+
312+
313+func keyCurrentEpochUi () = makeString(["%s", "currentEpochUi"], SEP)
314+
315+
316+func keyVotingResultStaked (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStaked", lpAssetIdStr, toString(epoch)], SEP)
317+
318+
319+func keyVotingResultStakedIntegral (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegral", lpAssetIdStr, toString(epoch)], SEP)
320+
321+
322+func keyVotingResultStakedLastUpdateHeight (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(epoch)], SEP)
323+
324+
325+func keyVotingResultStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "votingResultStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
326+
327+
328+func keyVoteStakedIntegral (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegral", lpAssetIdStr, toString(address), toString(epoch)], SEP)
329+
330+
331+func keyVoteStakedLastUpdateHeight (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(address), toString(epoch)], SEP)
332+
333+
334+func keyVoteStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
335+
336+
337+func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s", "staked", userAddressStr, lpAssetIdStr], SEP)
338+
339+
304340 let factoryContract = readFactoryAddressOrFail()
305341 
306342 let factoryCfg = readFactoryCfgOrFail(factoryContract)
307343 
308344 let emissionContract = getEmissionAddressOrFail(factoryCfg)
309345 
310346 let stakingContract = getStakingAddressOrFail(factoryCfg)
311347 
312348 let gwxRewardContract = getGwxRewardAddressOrFail(factoryCfg)
313349 
314350 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"))
315351 
316352 let keyVotingEmissionContract = makeString(["%s", "votingEmissionContract"], SEP)
317353 
318354 let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
319355 
356+let boostCoeff = {
357+    let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
358+    if ($isInstanceOf(@, "Int"))
359+        then @
360+        else throw(($getType(@) + " couldn't be cast to Int"))
361+    }
362+
320363 func getTotalCachedGwx (correct) = {
321-    let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], SEP)
322-    let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi)
364+    let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi())
323365     let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
324366     let targetEpochOption = getInteger(this, keyTargetEpoch)
325367     let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
326368     let isCorrectionActivated = if (isDefined(targetEpochOption))
327369         then (currentEpochUi >= value(targetEpochOption))
328370         else false
329371     let corrective = if (if (isCorrectionActivated)
330372         then correct
331373         else false)
332374         then valueOrElse(getInteger(this, keyTotalCachedGwxCorrective()), 0)
333375         else 0
334376     max([0, (totalCachedGwxRaw + corrective)])
335377     }
336378 
337379 
338380 func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
339381     let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
340382     let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(k), toString(b)], SEP)
341383     StringEntry(historyKEY, historyDATA)
342384     }
343385 
344386 
345387 func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
346388     let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
347389     let locksCountKEY = keyStatsLocksCount()
348390     let usersCountKEY = keyStatsUsersCount()
349391     let totalAmountKEY = keyLockParamTotalAmount()
350392     let locksDurationSumInBlocks = ioz(this, locksDurationSumInBlocksKEY)
351393     let locksCount = ioz(this, locksCountKEY)
352394     let usersCount = ioz(this, usersCountKEY)
353395     let totalAmount = ioz(this, totalAmountKEY)
354396 [IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
355397     }
356398 
357399 
358400 func calcGwxAmount (kRaw,bRaw,h) = {
359401     let SCALE = 1000
360402     (((kRaw * h) + bRaw) / SCALE)
361403     }
362404 
363405 
364406 func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
365407     let userAmountKEY = keyLockParamUserAmount(userNum)
366408     let startBlockKEY = keyLockParamStartBlock(userNum)
367409     let durationKEY = keyLockParamDuration(userNum)
368410     let kKEY = keyLockParamK(userNum)
369411     let bKEY = keyLockParamB(userNum)
370412     let kByPeriodKEY = keyLockParamByPeriodK(userNum, period)
371413     let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
372414     let gwxAmount = calcGwxAmount(k, b, height)
373415 [IntegerEntry(userAmountKEY, amount), IntegerEntry(startBlockKEY, start), IntegerEntry(durationKEY, duration), IntegerEntry(kKEY, k), IntegerEntry(bKEY, b), IntegerEntry(kByPeriodKEY, k), IntegerEntry(bByPeriodKEY, b), StringEntry(keyLockParamsRecord(userAddress), formatLockParamsRecord(userNum, amount, start, duration, k, b, gwxAmount))]
374416     }
375417 
376418 
377419 func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
378-    then throw("only one payment is allowed")
420+    then throwErr("only one payment is allowed")
379421     else if ((size(i.payments) == 0))
380422         then 0
381423         else {
382424             let pmt = i.payments[0]
383425             if ((value(pmt.assetId) != expectedAssetId))
384-                then throw("invalid asset id in payment")
426+                then throwErr("invalid asset id in payment")
385427                 else pmt.amount
386428             }
387429 
388430 
389431 func calcUserGwxAmountAtHeight (userAddress,targetHeight) = {
390432     let EMPTY = "empty"
391433     let user2NumMappingKEY = keyUser2NumMapping(userAddress)
392434     let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
393435     let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
394436     let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
395437     let gwxAmountCalc = calcGwxAmount(k, b, targetHeight)
396438     let gwxAmount = if ((0 > gwxAmountCalc))
397439         then 0
398440         else gwxAmountCalc
399441     gwxAmount
400442     }
401443 
402444 
403445 func calcCurrentGwxAmount (userAddress) = calcUserGwxAmountAtHeight(userAddress, height)
404446 
405447 
406448 func getVotingEmissionEpochInfo () = {
407-    let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], SEP)
408-    let $t01492815216 = {
409-        let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi))
449+    let $t01710117391 = {
450+        let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi()))
410451         let lastFinalizedEpoch = (currentEpochUi - 1)
411452         if ((0 > lastFinalizedEpoch))
412453             then throwErr("invalid epoch")
413454             else $Tuple2(currentEpochUi, lastFinalizedEpoch)
414455         }
415-    let currentEpochUi = $t01492815216._1
416-    let lastFinalizedEpoch = $t01492815216._2
417-    func keyStartHeightByEpoch (epoch) =     makeString(["%s%d", "startHeight", toString(epoch)], SEP)
418-
456+    let currentEpochUi = $t01710117391._1
457+    let lastFinalizedEpoch = $t01710117391._2
419458     let currentEpochStartHeight = value(getInteger(votingEmissionContract, keyStartHeightByEpoch(currentEpochUi)))
420459     $Tuple2(lastFinalizedEpoch, currentEpochStartHeight)
421460     }
422461 
423462 
424-func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
425-
426-
427-func keyVotingResultStaked (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStaked", lpAssetIdStr, toString(epoch)], SEP)
428-
429-
430-func keyVotingResultStakedIntegral (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegral", lpAssetIdStr, toString(epoch)], SEP)
431-
432-
433-func keyVotingResultStakedLastUpdateHeight (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(epoch)], SEP)
434-
435-
436-func keyVoteStakedIntegral (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegral", lpAssetIdStr, toString(address), toString(epoch)], SEP)
437-
438-
439-func keyVoteStakedLastUpdateHeight (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(address), toString(epoch)], SEP)
440-
441-
442-func getVotingResultStaked (lpAssetIdStr) = {
443-    let $t01690116981 = getVotingEmissionEpochInfo()
444-    let lastFinalizedEpoch = $t01690116981._1
445-    let currentEpochStartHeight = $t01690116981._2
446-    let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
447-    let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
448-    votingResultStaked
449-    }
450-
451-
452-func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
453-    let $t01750217582 = getVotingEmissionEpochInfo()
454-    let lastFinalizedEpoch = $t01750217582._1
455-    let currentEpochStartHeight = $t01750217582._2
456-    let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
457-    let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
458-    let votingResultStakedIntegralKey = keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)
459-    let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, votingResultStakedIntegralKey), 0)
460-    let votingResultLastUpdateHeightKey = keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)
461-    let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, votingResultLastUpdateHeightKey), currentEpochStartHeight)
462-    let votingResultStakedIntegralDh = (height - votingResultStakedLastUpdateHeight)
463-    let votingResultStakedIntegral = ((votingResultStakedIntegralDh * votingResultStaked) + votingResultStakedIntegralPrev)
464-    $Tuple2([IntegerEntry(keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedNew), IntegerEntry(votingResultLastUpdateHeightKey, height), IntegerEntry(votingResultStakedIntegralKey, votingResultStakedIntegral)], votingResultStakedIntegral)
465-    }
466-
467-
468-func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
469-    let $t01878218862 = getVotingEmissionEpochInfo()
470-    let lastFinalizedEpoch = $t01878218862._1
471-    let currentEpochStartHeight = $t01878218862._2
472-    let userAddress = addressFromStringValue(userAddressStr)
463+func getPoolAssetsByLpAssetId (lpAssetIdStr) = {
473464     let idxAmountAssetId = 4
474465     let idxPriceAssetId = 5
475466     let poolCfg = {
476-        let @ = invoke(factoryContract, "getPoolConfigByLpAssetId", [lpAssetIdStr], nil)
467+        let @ = invoke(factoryContract, "getPoolConfigByLpAssetIdREADONLY", [lpAssetIdStr], nil)
477468         if ($isInstanceOf(@, "List[Any]"))
478469             then @
479470             else throw(($getType(@) + " couldn't be cast to List[Any]"))
480471         }
481472     let amountAssetId = {
482473         let @ = poolCfg[idxAmountAssetId]
483474         if ($isInstanceOf(@, "String"))
484475             then @
485476             else throw(($getType(@) + " couldn't be cast to String"))
486477         }
487478     let priceAssetId = {
488479         let @ = poolCfg[idxPriceAssetId]
489480         if ($isInstanceOf(@, "String"))
490481             then @
491482             else throw(($getType(@) + " couldn't be cast to String"))
492483         }
493-    let userVote = valueOrElse(getInteger(votingEmissionContract, keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)), 0)
494-    let actions = if ((userVote == 0))
484+    $Tuple2(amountAssetId, priceAssetId)
485+    }
486+
487+
488+func getUserVoteFinalized (lpAssetIdStr,userAddressStr) = {
489+    let userAddress = addressFromStringValue(userAddressStr)
490+    let $t01808218162 = getVotingEmissionEpochInfo()
491+    let lastFinalizedEpoch = $t01808218162._1
492+    let currentEpochStartHeight = $t01808218162._2
493+    let $t01816518240 = getPoolAssetsByLpAssetId(lpAssetIdStr)
494+    let amountAssetId = $t01816518240._1
495+    let priceAssetId = $t01816518240._2
496+    let userVoteKey = keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)
497+    let userVote = valueOrElse(getInteger(votingEmissionContract, userVoteKey), 0)
498+    userVote
499+    }
500+
501+
502+func getUserVoteStaked (lpAssetIdStr,userAddressStr) = {
503+    let stakedByUser = valueOrElse(getInteger(stakingContract, keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
504+    let userVote = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
505+    if ((stakedByUser == 0))
506+        then 0
507+        else userVote
508+    }
509+
510+
511+func getVotingResultStaked (lpAssetIdStr) = {
512+    let $t01878418864 = getVotingEmissionEpochInfo()
513+    let lastFinalizedEpoch = $t01878418864._1
514+    let currentEpochStartHeight = $t01878418864._2
515+    let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
516+    let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
517+    votingResultStaked
518+    }
519+
520+
521+func getVotingResultStakedIntegral (lpAssetIdStr) = {
522+    let $t01922619306 = getVotingEmissionEpochInfo()
523+    let lastFinalizedEpoch = $t01922619306._1
524+    let currentEpochStartHeight = $t01922619306._2
525+    let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
526+    let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)), 0)
527+    let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)), currentEpochStartHeight)
528+    let votingResultStakedIntegralDh = (height - votingResultStakedLastUpdateHeight)
529+    let votingResultStakedIntegral = ((votingResultStakedIntegralDh * votingResultStaked) + votingResultStakedIntegralPrev)
530+    votingResultStakedIntegral
531+    }
532+
533+
534+func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
535+    let $t02014320223 = getVotingEmissionEpochInfo()
536+    let lastFinalizedEpoch = $t02014320223._1
537+    let currentEpochStartHeight = $t02014320223._2
538+    let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
539+    let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
540+    let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)
541+[IntegerEntry(keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedNew), IntegerEntry(keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch), height), IntegerEntry(keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedIntegral)]
542+    }
543+
544+
545+func getUserVoteStakedIntegral (lpAssetIdStr,userAddressStr) = {
546+    let $t02083420914 = getVotingEmissionEpochInfo()
547+    let lastFinalizedEpoch = $t02083420914._1
548+    let currentEpochStartHeight = $t02083420914._2
549+    let userAddress = addressFromStringValue(userAddressStr)
550+    let userVoteStaked = getUserVoteStaked(lpAssetIdStr, userAddressStr)
551+    let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)), 0)
552+    let userVoteStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch)), currentEpochStartHeight)
553+    let userVoteStakedIntegralDh = (height - userVoteStakedLastUpdateHeight)
554+    let userVoteStakedIntegral = ((userVoteStakedIntegralDh * userVoteStaked) + userVoteStakedIntegralPrev)
555+    userVoteStakedIntegral
556+    }
557+
558+
559+func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
560+    let $t02170221782 = getVotingEmissionEpochInfo()
561+    let lastFinalizedEpoch = $t02170221782._1
562+    let currentEpochStartHeight = $t02170221782._2
563+    let userAddress = addressFromStringValue(userAddressStr)
564+    let userVoteFinalized = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
565+    let actions = if ((userVoteFinalized == 0))
495566         then nil
496567         else {
497568             let stakedVoteDelta = if (edge)
498-                then userVote
499-                else -(userVote)
500-            let $t01946719586 = refreshVotingResultStakedIntegral(lpAssetIdStr, stakedVoteDelta)
501-            let votingResultActions = $t01946719586._1
502-            let votingResultStakedIntegral = $t01946719586._2
503-            let userVoteStaked = if (edge)
504-                then 0
505-                else userVote
506-            let userVoteStakedIntegralKey = keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)
507-            let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, userVoteStakedIntegralKey), 0)
508-            let userVoteStakedLastUpdateHeightKey = keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch)
509-            let userVoteStakedLastUpdateHeight = valueOrElse(getInteger(this, userVoteStakedLastUpdateHeightKey), currentEpochStartHeight)
510-            let userVoteStakedIntegralDh = (height - userVoteStakedLastUpdateHeight)
511-            let userVoteStakedIntegral = ((userVoteStakedIntegralDh * userVoteStaked) + userVoteStakedIntegralPrev)
512-            let voteActions = [IntegerEntry(userVoteStakedLastUpdateHeightKey, height), IntegerEntry(userVoteStakedIntegralKey, userVoteStakedIntegral)]
569+                then userVoteFinalized
570+                else -(userVoteFinalized)
571+            let votingResultActions = refreshVotingResultStakedIntegral(lpAssetIdStr, stakedVoteDelta)
572+            let userVoteStakedIntegral = getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr)
573+            let voteActions = [IntegerEntry(keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch), height), IntegerEntry(keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch), userVoteStakedIntegral)]
513574             (votingResultActions ++ voteActions)
514575             }
515576     actions
516577     }
517578 
518579 
580+func getStakedVotesIntegralsDiff (lpAssetIdStr,userAddressStr) = {
581+    let $t02263622716 = getVotingEmissionEpochInfo()
582+    let lastFinalizedEpoch = $t02263622716._1
583+    let currentEpochStartHeight = $t02263622716._2
584+    let userAddress = addressFromStringValue(userAddressStr)
585+    let userVoteStakedIntegralLastKey = keyVoteStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
586+    let userVoteStakedIntegralLast = valueOrElse(getInteger(this, userVoteStakedIntegralLastKey), 0)
587+    let votingResultStakedIntegralLastKey = keyVotingResultStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
588+    let votingResultStakedIntegralLast = valueOrElse(getInteger(this, votingResultStakedIntegralLastKey), 0)
589+    let userVoteStakedIntegral = getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr)
590+    let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)
591+    let userVoteStakedIntegralDiff = (userVoteStakedIntegral - userVoteStakedIntegralLast)
592+    let votingResultStakedIntegralDiff = (votingResultStakedIntegral - votingResultStakedIntegralLast)
593+    $Tuple3([IntegerEntry(userVoteStakedIntegralLastKey, userVoteStakedIntegral), IntegerEntry(votingResultStakedIntegralLastKey, votingResultStakedIntegral)], userVoteStakedIntegralDiff, votingResultStakedIntegralDiff)
594+    }
595+
596+
597+func refreshBoostEmissionIntegral () = {
598+    let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
599+    let boostingV2LastUpdateHeightOption = getInteger(this, keyBoostingV2LastUpdateHeight())
600+    let boostingV2IngergalOption = getInteger(this, keyBoostingV2Integral())
601+    let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
602+    let h = if ((height > emissionEnd))
603+        then emissionEnd
604+        else height
605+    let dh =     match boostingV2LastUpdateHeightOption {
606+        case lastUpdateHeight: Int => 
607+            max([(h - lastUpdateHeight), 0])
608+        case _: Unit => 
609+            0
610+        case _ => 
611+            throw("Match error")
612+    }
613+    let boostEmissionPerBlock = ((wxEmissionPerBlock * (boostCoeff - 1)) / boostCoeff)
614+    let boostEmissionIntegralPrev = valueOrElse(boostingV2IngergalOption, 0)
615+    let boostEmissionIntegral = ((boostEmissionPerBlock * dh) + boostEmissionIntegralPrev)
616+    $Tuple2([IntegerEntry(keyBoostingV2Integral(), boostEmissionIntegral), IntegerEntry(keyBoostingV2LastUpdateHeight(), height)], boostEmissionIntegral)
617+    }
618+
619+
519620 func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
520-    let EMPTY = "EMPTY"
521-    let userRecordOrEmpty = valueOrElse(getString(this, keyLockParamsRecord(userAddressStr)), EMPTY)
522-    if ((userRecordOrEmpty == EMPTY))
621+    let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
622+    if ((userRecordOption == unit))
523623         then $Tuple3(0, nil, "userRecord::is::empty")
524624         else {
525-            let userRecordArray = split(userRecordOrEmpty, SEP)
625+            let userRecordArray = split(value(userRecordOption), SEP)
526626             let userNumStr = userRecordArray[IdxLockUserNum]
527-            let gwxRewardEmissionStartHeight = valueOrElse(getInteger(gwxRewardContract, keyGwxRewardEmissionStartHeight()), 0)
528627             let EMPTYSTR = "empty"
529-            let $t02106521633 = if ((lpAssetIdStr != EMPTYSTR))
628+            let poolWeight = if ((lpAssetIdStr != EMPTYSTR))
530629                 then {
531-                    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
532-                    let pw1 = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
533-                    let pw0 = valueOrElse(getInteger(factoryContract, keyFactoryPoolWeightHistory(poolAddressStr, 0)), pw1)
534-                    $Tuple2(pw0, pw1)
630+                    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
631+                    getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
535632                     }
536633                 else if (readOnly)
537-                    then $Tuple2(0, 0)
538-                    else throw(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
539-            let poolWeight0 = $t02106521633._1
540-            let poolWeight1 = $t02106521633._2
541-            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
542-            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
543-            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
544-            let h = if ((height > emissionEnd))
545-                then emissionEnd
546-                else height
547-            let dh = max([(h - emissionStart), 0])
634+                    then 0
635+                    else throwErr(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
548636             let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
549637             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
550638             let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), ioz(this, userBoostEmissionLastIntegralKEY))
551-            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
639+            let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
552640             let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
553-            let udh = fraction(userBoostEmissionIntegral, 3, (2 * wxEmissionPerBlock))
554-            let uLastH = (h - udh)
555-            let udh0 = max([(gwxRewardEmissionStartHeight - uLastH), 0])
556-            let udh1 = ((h - uLastH) - udh0)
557-            if (if (if ((0 > uLastH))
558-                then true
559-                else (0 > udh1))
560-                then true
561-                else (abs(((udh0 + udh1) - udh)) >= 1))
562-                then throw(((((((((((("invalid udh calc: udh=" + toString(udh)) + " uLastH=") + toString(uLastH)) + " udh0=") + toString(udh0)) + " udh1=") + toString(udh1)) + " lpAssetId=") + lpAssetIdStr) + " userAddress=") + userAddressStr))
563-                else if ((0 > userBoostEmissionIntegral))
564-                    then throw("wrong calculations")
565-                    else {
566-                        let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
567-                        let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
568-                        let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
569-                        let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
570-                        let totalCachedGwxCorrected = getTotalCachedGwx(true)
571-                        let userCurrGwx = calcCurrentGwxAmount(userAddressStr)
572-                        let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
573-                        let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
574-                        let userBoostEmissionIntegral0 = if ((udh == 0))
575-                            then 0
576-                            else fraction(userBoostEmissionIntegral, udh0, udh)
577-                        let userBoostEmissionIntegral1 = if ((udh == 0))
578-                            then 0
579-                            else fraction(userBoostEmissionIntegral, udh1, udh)
580-                        let poolUserBoostEmissionIntegral0 = fraction(userBoostEmissionIntegral0, poolWeight0, POOLWEIGHTMULT)
581-                        let poolUserBoostEmissionIntegral1 = fraction(userBoostEmissionIntegral1, poolWeight1, POOLWEIGHTMULT)
582-                        let userBoostAvaliableToClaimTotalNew0 = if ((totalCachedGwxCorrected == 0))
583-                            then 0
584-                            else fraction(poolUserBoostEmissionIntegral0, userCurrGwx, totalCachedGwxCorrected)
585-                        let userBoostAvaliableToClaimTotalNew1 = if ((totalCachedGwxCorrected == 0))
586-                            then 0
587-                            else fraction(poolUserBoostEmissionIntegral1, userCurrGwx, totalCachedGwxCorrected)
588-                        let userBoostAvaliableToClaimTotalNew = (userBoostAvaliableToClaimTotalNew0 + userBoostAvaliableToClaimTotalNew1)
589-                        let userBoostClaimedKEY = keyUserBoostClaimed(userNumStr)
590-                        let userBoostClaimed = ioz(this, userBoostClaimedKEY)
591-                        let userBoostAvailable = (userBoostAvaliableToClaimTotalNew - userBoostClaimed)
592-                        let dataState = [IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)]
593-                        let debug = makeString([toString(userBoostEmissionLastIntegral), toString(userBoostEmissionIntegral), toString(userBoostClaimed), toString(userBoostAvailable), toString(poolWeight0), toString(poolWeight1), toString(h), toString(udh), toString(uLastH), toString(udh0), toString(udh1), toString(userCurrGwx), toString(totalCachedGwxCorrected)], ":")
594-                        $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
595-                        }
641+            if ((0 > userBoostEmissionIntegral))
642+                then throwErr("wrong calculations")
643+                else {
644+                    let $t02633526474 = getStakedVotesIntegralsDiff(lpAssetIdStr, userAddressStr)
645+                    let stakedVotesIntegralsActions = $t02633526474._1
646+                    let userVoteIntegralDiff = $t02633526474._2
647+                    let totalVotesIntegralDiff = $t02633526474._3
648+                    let poolUserBoostEmissionIntegral = fraction(userBoostEmissionIntegral, poolWeight, POOLWEIGHTMULT)
649+                    let userBoostAvaliableToClaimTotalNew = if ((totalVotesIntegralDiff == 0))
650+                        then 0
651+                        else fraction(poolUserBoostEmissionIntegral, userVoteIntegralDiff, totalVotesIntegralDiff)
652+                    let dataState = ([IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)] ++ stakedVotesIntegralsActions)
653+                    let debug = makeString([toString(userBoostEmissionLastIntegral), toString(userBoostEmissionIntegral), toString(poolWeight), toString(userVoteIntegralDiff), toString(totalVotesIntegralDiff)], ":")
654+                    $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
655+                    }
596656             }
597657     }
598658 
599659 
600660 func lockActions (i,duration) = {
601661     let cfgArray = readConfigArrayOrFail()
602662     let assetIdStr = cfgArray[IdxCfgAssetId]
603663     let assetId = fromBase58String(assetIdStr)
604664     let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
605665     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
606666     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
607667     if ((size(i.payments) != 1))
608-        then throw("invalid payment - exact one payment must be attached")
668+        then throwErr("invalid payment - exact one payment must be attached")
609669         else {
610670             let pmt = i.payments[0]
611671             let pmtAmount = pmt.amount
612672             if ((assetId != value(pmt.assetId)))
613-                then throw((("invalid asset is in payment - " + assetIdStr) + " is expected"))
673+                then throwErr((("invalid asset is in payment - " + assetIdStr) + " is expected"))
614674                 else {
615675                     let nextUserNumKEY = keyNextUserNum()
616676                     let userAddressStr = toString(i.caller)
617677                     let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
618678                     let userNumStr = if (userIsExisting)
619679                         then value(getString(keyUser2NumMapping(userAddressStr)))
620680                         else toString(iof(this, nextUserNumKEY))
621681                     let userNum = parseIntValue(userNumStr)
622682                     let lockStart = height
623683                     let startBlockKEY = keyLockParamStartBlock(userNumStr)
624684                     let durationKEY = keyLockParamDuration(userNumStr)
625685                     let userAmountKEY = keyLockParamUserAmount(userNumStr)
626686                     if (if ((minLockAmount > pmtAmount))
627687                         then (i.caller != lpStakingPoolsContract)
628688                         else false)
629-                        then throw(("amount is less then minLockAmount=" + toString(minLockAmount)))
689+                        then throwErr(("amount is less then minLockAmount=" + toString(minLockAmount)))
630690                         else if ((minLockDuration > duration))
631-                            then throw(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
691+                            then throwErr(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
632692                             else if ((duration > maxLockDuration))
633-                                then throw(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
693+                                then throwErr(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
634694                                 else if (if (userIsExisting)
635695                                     then ((iof(this, startBlockKEY) + iof(this, durationKEY)) >= lockStart)
636696                                     else false)
637-                                    then throw("there is an active lock - consider to use increaseLock")
697+                                    then throwErr("there is an active lock - consider to use increaseLock")
638698                                     else if ((ioz(this, userAmountKEY) > 0))
639-                                        then throw(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
699+                                        then throwErr(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
640700                                         else {
641701                                             let coeffX8 = fraction(duration, MULT8, maxLockDuration)
642702                                             let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
643703                                             let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStart, duration], nil))
644704                                             let k = ai(gWxParamsResultList[0])
645705                                             let b = ai(gWxParamsResultList[1])
646706                                             let period = toString(ai(gWxParamsResultList[2]))
647-                                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
648-                                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
649-                                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
650-                                            let h = if ((height > emissionEnd))
651-                                                then emissionEnd
652-                                                else height
653-                                            let dh = max([(h - emissionStart), 0])
707+                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
654708                                             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
655-                                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
656-                                            let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
657-                                            let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
658-                                            let userMaxBoostInt = ((gWxAmountStart * duration) / 2)
659-                                            let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
660-                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
709+                                            let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
661710                                             let arr = if (userIsExisting)
662711                                                 then nil
663712                                                 else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
664713                                             $Tuple2(((((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
665714                                                 then 0
666715                                                 else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gWxAmountStart))]), gWxAmountStart)
667716                                             }
668717                     }
669718             }
670719     }
671720 
672721 
673722 @Callable(i)
674723 func constructor (factoryAddressStr,lockAssetIdStr,minLockAmount,minDuration,maxDuration,mathContract) = {
675724     let checkCaller = mustManager(i)
676725     if ((checkCaller == checkCaller))
677726         then ([IntegerEntry(keyNextUserNum(), 0), StringEntry(keyConfig(), formatConfig(lockAssetIdStr, minLockAmount, minDuration, maxDuration, mathContract)), StringEntry(keyFactoryAddress(), factoryAddressStr)] ++ StatsEntry(0, 0, 0, 0))
678727         else throw("Strict value is not equal to itself.")
679728     }
680729 
681730 
682731 
683732 @Callable(i)
684733 func lockRef (duration,referrerAddress,signature) = {
685-    let $t03009830163 = lockActions(i, duration)
686-    let lockActionsResult = $t03009830163._1
687-    let gWxAmountStart = $t03009830163._2
734+    let $t03108531150 = lockActions(i, duration)
735+    let lockActionsResult = $t03108531150._1
736+    let gWxAmountStart = $t03108531150._2
688737     let referralAddress = toString(i.caller)
689738     let refInv = if (if ((referrerAddress == ""))
690739         then true
691740         else (signature == base58''))
692741         then unit
693742         else invoke(referralsContractAddressOrFail, "createPair", [referralProgramName, referrerAddress, referralAddress, signature], nil)
694743     if ((refInv == refInv))
695744         then {
696745             let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
697746             if ((updateRefActivity == updateRefActivity))
698747                 then $Tuple2(lockActionsResult, unit)
699748                 else throw("Strict value is not equal to itself.")
700749             }
701750         else throw("Strict value is not equal to itself.")
702751     }
703752 
704753 
705754 
706755 @Callable(i)
707756 func lock (duration) = {
708-    let $t03062130686 = lockActions(i, duration)
709-    let lockActionsResult = $t03062130686._1
710-    let gWxAmountStart = $t03062130686._2
757+    let $t03160831673 = lockActions(i, duration)
758+    let lockActionsResult = $t03160831673._1
759+    let gWxAmountStart = $t03160831673._2
711760     let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
712761     if ((updateRefActivity == updateRefActivity))
713762         then $Tuple2(lockActionsResult, unit)
714763         else throw("Strict value is not equal to itself.")
715764     }
716765 
717766 
718767 
719768 @Callable(i)
720769 func increaseLock (deltaDuration) = {
721770     let cfgArray = readConfigArrayOrFail()
722771     let assetIdStr = cfgArray[IdxCfgAssetId]
723772     let assetId = fromBase58String(assetIdStr)
724773     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
725774     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
726775     let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
727776     let userAddressStr = toString(i.caller)
728777     let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
729778     let userNumStr = userRecordArray[IdxLockUserNum]
730779     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
731780     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
732781     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
733782     let lockEnd = (lockStart + lockDuration)
734783     let remainingDuration = max([(lockEnd - height), 0])
735784     let userAmountNew = (userAmount + pmtAmount)
736785     let lockDurationNew = (remainingDuration + deltaDuration)
737786     if ((0 > deltaDuration))
738-        then throw("duration is less then zero")
787+        then throwErr("duration is less then zero")
739788         else if ((minLockDuration > lockDurationNew))
740-            then throw(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
789+            then throwErr(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
741790             else if ((lockDurationNew > maxLockDuration))
742-                then throw(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
791+                then throwErr(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
743792                 else {
744793                     let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
745794                     let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
746795                     let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
747796                     if ((updateRefActivity == updateRefActivity))
748797                         then {
749798                             let lockStartNew = height
750799                             let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStartNew, lockDurationNew], nil))
751800                             let k = ai(gWxParamsResultList[0])
752801                             let b = ai(gWxParamsResultList[1])
753802                             let period = toString(ai(gWxParamsResultList[2]))
754-                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
755-                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
756-                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
757-                            let h = if ((height > emissionEnd))
758-                                then emissionEnd
759-                                else height
760-                            let dh = max([(h - emissionStart), 0])
761-                            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
762-                            let userBoostEmissionLastIntegral = ioz(this, userBoostEmissionLastIntegralKEY)
763-                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
764-                            let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
765-                            if ((0 > userBoostEmissionIntegral))
766-                                then throw("wrong calculations")
803+                            let currUserGwx = calcCurrentGwxAmount(userAddressStr)
804+                            let gwxDiff = (gWxAmountStart - currUserGwx)
805+                            if ((0 > gwxDiff))
806+                                then throwErr(("gwxDiff is less then 0: " + toString(gwxDiff)))
767807                                 else {
768-                                    let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
769-                                    let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
770-                                    let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
771-                                    let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
772-                                    let currUserGwx = calcCurrentGwxAmount(userAddressStr)
773-                                    let gwxDiff = (gWxAmountStart - currUserGwx)
774-                                    if ((0 > gwxDiff))
775-                                        then throw(("gwxDiff is less then 0: " + toString(gwxDiff)))
776-                                        else {
777-                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
778-                                            let totalCachedGwxCorrected = getTotalCachedGwx(true)
779-                                            let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
780-                                            let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
781-                                            let userBoostAvaliableToClaimTotalNew = fraction(userBoostEmissionIntegral, currUserGwx, totalCachedGwxCorrected)
782-                                            let userMaxBoostIntNew = ((gWxAmountStart * lockDurationNew) / 2)
783-                                            let remainingUserMaxBoostInt = ((currUserGwx * remainingDuration) / 2)
784-                                            let userMaxBoostIntDiff = (userMaxBoostIntNew - remainingUserMaxBoostInt)
785-                                            (((LockParamsEntry(userAddressStr, userNumStr, userAmountNew, lockStartNew, lockDurationNew, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, lockDurationNew, k, b, i)) ++ [IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gwxDiff))])
786-                                            }
808+                                    let totalCachedGwxRaw = getTotalCachedGwx(false)
809+                                    let totalCachedGwxCorrected = getTotalCachedGwx(true)
810+                                    (((LockParamsEntry(userAddressStr, userNumStr, userAmountNew, lockStartNew, lockDurationNew, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, lockDurationNew, k, b, i)) ++ [IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gwxDiff))])
787811                                     }
788812                             }
789813                         else throw("Strict value is not equal to itself.")
790814                     }
791815     }
792816 
793817 
794818 
795819 @Callable(i)
796820 func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
797-    then throw("permissions denied")
821+    then throwErr("permissions denied")
798822     else {
799-        let $t03566735769 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
800-        let userBoostAvailable = $t03566735769._1
801-        let dataState = $t03566735769._2
802-        let debug = $t03566735769._3
823+        let $t03477834880 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
824+        let userBoostAvailable = $t03477834880._1
825+        let dataState = $t03477834880._2
826+        let debug = $t03477834880._3
803827         $Tuple2(dataState, [userBoostAvailable])
804828         }
805829 
806830 
807831 
808832 @Callable(i)
809833 func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
810-    let $t03590136002 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
811-    let userBoostAvailable = $t03590136002._1
812-    let dataState = $t03590136002._2
813-    let debug = $t03590136002._3
834+    let $t03501235113 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
835+    let userBoostAvailable = $t03501235113._1
836+    let dataState = $t03501235113._2
837+    let debug = $t03501235113._3
814838     $Tuple2(nil, [userBoostAvailable, debug])
815839     }
816840 
817841 
818842 
819843 @Callable(i)
820844 func unlock (userAddress) = {
821845     let userRecordArray = readLockParamsRecordOrFail(userAddress)
822846     let userNumStr = userRecordArray[IdxLockUserNum]
823847     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
824848     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
825849     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
826850     let lockEnd = (lockStart + lockDuration)
827851     let cfgArray = readConfigArrayOrFail()
828852     let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
829853     if ((lockEnd >= height))
830-        then throw((("wait " + toString(lockEnd)) + " to unlock"))
854+        then throwErr((("wait " + toString(lockEnd)) + " to unlock"))
831855         else if ((0 >= userAmount))
832-            then throw("nothing to unlock")
856+            then throwErr("nothing to unlock")
833857             else {
834858                 let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
835859                 (((LockParamsEntry(userAddress, userNumStr, 0, lockStart, lockDuration, 0, 0, toString(period)) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ ScriptTransfer(addressFromStringValue(userAddress), userAmount, assetId))
836860                 }
837861     }
838862 
839863 
840864 
841865 @Callable(i)
842866 func gwxUserInfoREADONLY (userAddress) = {
843867     let gwxAmount = calcCurrentGwxAmount(userAddress)
844868     $Tuple2(nil, [gwxAmount])
845869     }
846870 
847871 
848872 
849873 @Callable(i)
850874 func userMaxDurationREADONLY (userAddressStr) = {
851875     let cfgArray = readConfigArrayOrFail()
852876     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
853877     let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
854878     if ((userRecordOption == unit))
855879         then $Tuple2(nil, $Tuple2("lock", maxLockDuration))
856880         else {
857881             let userRecordArray = split(value(userRecordOption), SEP)
858882             let lockStart = parseIntValue(userRecordArray[IdxLockStart])
859883             let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
860884             let lockEnd = (lockStart + lockDuration)
861885             let remainingDuration = max([(lockEnd - height), 0])
862886             let maxDeltaDuration = (maxLockDuration - remainingDuration)
863887             $Tuple2(nil, $Tuple2("increaseLock", maxDeltaDuration))
864888             }
865889     }
866890 
867891 
868892 
869893 @Callable(i)
870894 func getUserGwxAmountAtHeightREADONLY (userAddress,targetHeight) = {
871895     let gwxAmount = calcUserGwxAmountAtHeight(userAddress, targetHeight)
872896     $Tuple2(nil, gwxAmount)
873897     }
874898 
875899 
876900 
877901 @Callable(i)
878902 func getTotalCachedGwxREADONLY () = $Tuple2(nil, getTotalCachedGwx(true))
879903 
880904 
881905 
882906 @Callable(i)
907+func onBoostEmissionUpdate () = {
908+    let checkCaller = if ((i.caller == emissionContract))
909+        then true
910+        else mustManager(i)
911+    if ((checkCaller == checkCaller))
912+        then refreshBoostEmissionIntegral()
913+        else throw("Strict value is not equal to itself.")
914+    }
915+
916+
917+
918+@Callable(i)
883919 func onStakedVoteUpdate (lpAssetIdStr,userAddressStr,edge) = {
884920     let checkCaller = if ((i.caller == stakingContract))
885921         then true
886922         else mustManager(i)
887923     if ((checkCaller == checkCaller))
888924         then {
889925             let actions = refreshVoteStakedIntegral(lpAssetIdStr, userAddressStr, edge)
890926             $Tuple2(actions, unit)
891927             }
892928         else throw("Strict value is not equal to itself.")
893929     }
894930 
895931 
896932 
897933 @Callable(i)
898934 func getVotingResultStakedREADONLY (lpAssetIdStr) = $Tuple2(nil, getVotingResultStaked(lpAssetIdStr))
935+
936+
937+
938+@Callable(i)
939+func getVotingResultStakedIntegralREADONLY (lpAssetIdStr) = $Tuple2(nil, getVotingResultStakedIntegral(lpAssetIdStr))
940+
941+
942+
943+@Callable(i)
944+func getUserVoteFinalizedREADONLY (lpAssetIdStr,userAddressStr) = $Tuple2(nil, getUserVoteFinalized(lpAssetIdStr, userAddressStr))
945+
946+
947+
948+@Callable(i)
949+func getUserVoteStakedIntegralREADONLY (lpAssetIdStr,userAddressStr) = $Tuple2(nil, getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr))
899950 
900951 
901952 
902953 @Callable(i)
903954 func setManager (pendingManagerPublicKey) = {
904955     let checkCaller = mustManager(i)
905956     if ((checkCaller == checkCaller))
906957         then {
907958             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
908959             if ((checkManagerPublicKey == checkManagerPublicKey))
909960                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
910961                 else throw("Strict value is not equal to itself.")
911962             }
912963         else throw("Strict value is not equal to itself.")
913964     }
914965 
915966 
916967 
917968 @Callable(i)
918969 func confirmManager () = {
919970     let pm = pendingManagerPublicKeyOrUnit()
920971     let hasPM = if (isDefined(pm))
921972         then true
922-        else throw("No pending manager")
973+        else throwErr("No pending manager")
923974     if ((hasPM == hasPM))
924975         then {
925976             let checkPM = if ((i.callerPublicKey == value(pm)))
926977                 then true
927-                else throw("You are not pending manager")
978+                else throwErr("You are not pending manager")
928979             if ((checkPM == checkPM))
929980                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
930981                 else throw("Strict value is not equal to itself.")
931982             }
932983         else throw("Strict value is not equal to itself.")
933984     }
934985 
935986 
936987 @Verifier(tx)
937988 func verify () = {
938989     let targetPublicKey =     match managerPublicKeyOrUnit() {
939990         case pk: ByteVector => 
940991             pk
941992         case _: Unit => 
942993             tx.senderPublicKey
943994         case _ => 
944995             throw("Match error")
945996     }
946997     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
947998     }
948999 
github/deemru/w8io/169f3d6 
157.42 ms ◑