w8 · tx · 319···5HG

tx · 319rJAAw9xqhiwHhkf2aoRxkpy2JsiWLU9sKv1ym55HG

3Myn55vLkduxbX3ZXfiDCZhaQsLxYp1kmCy:  -0.02700000 Waves

2023.08.14 17:39 [2710362] smart account 3Myn55vLkduxbX3ZXfiDCZhaQsLxYp1kmCy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "319rJAAw9xqhiwHhkf2aoRxkpy2JsiWLU9sKv1ym55HG",
    "fee": 2700000,
    "feeAssetId": null,
    "timestamp": 1692024013968,
    "version": 2,
    "chainId": 84,
    "sender": "3Myn55vLkduxbX3ZXfiDCZhaQsLxYp1kmCy",
    "senderPublicKey": "9W33iCCNfmFxUbiC6XZcH5x7f6xfwC7Jb3BoExT5q2PV",
    "proofs": [
        "5TurZTvh4sezLLsSA11iYEwJ87tQps1BaiMacwUADhLiaw28wkMrvNeNJKNKs8T8WL9VvFnf43aHxEiCmkobo5Y"
    ],
    "script": "base64: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",
    "height": 2710362,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: FisWfXcmP2HDisjzh8QUDSVtj5gya5bWqp5HuzvvbgSt
Next: AuGR23H1WV8mAjnRLoKH5dQnxjNH7SeF9ifWm75DfPFJ

Diff: 
Old New Differences
9 9  
10 10  let POOLWEIGHTMULT = MULT8
11 11  
12 - let contractFilename = "boosting.ride"
13 - 
14 - let SCALE18 = 18
15 - 
16 - let MULT18 = 1000000000000000000
17 - 
18 - let MULT18BI = toBigInt(MULT18)
19 - 
20 - let durationMonthsAllowed = [1, 3, 6, 12, 24, 48]
21 - 
22 - let blocksInDay = 1440
23 - 
24 - let blocksInMonth = 43800
25 - 
26 - func wrapErr (msg) = makeString([contractFilename, ": ", msg], "")
12 + func wrapErr (msg) = makeString(["boosting.ride:", msg], " ")
27 13  
28 14  
29 15  func throwErr (msg) = throw(wrapErr(msg))
30 16  
31 17  
32 - func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
18 + func strf (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
33 19  
34 20  
35 - func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
21 + func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
36 22  
37 23  
38 - func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
24 + func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
39 25  
40 26  
41 - func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
27 + func iof (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
42 28  
43 29  
44 30  func abs (val) = if ((0 > val))
46 32      else val
47 33  
48 34  
49 - func ensurePositive (v,m) = if ((v >= 0))
50 -     then v
51 -     else throwErr((valueOrElse(m, "value") + " should be positive"))
35 + func aal (val) = match val {
36 +     case valAnyLyst: List[Any] => 
37 +         valAnyLyst
38 +     case _ => 
39 +         throwErr("fail to cast into List[Any]")
40 + }
41 + 
42 + 
43 + func ai (val) = match val {
44 +     case valInt: Int => 
45 +         valInt
46 +     case _ => 
47 +         throwErr("fail to cast into Int")
48 + }
52 49  
53 50  
54 51  func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
55 52  
56 53  
57 - let referralsContractAddressOrFail = addressFromStringValue(getStringOrFail(this, keyReferralsContractAddress()))
54 + let referralsContractAddressOrFail = addressFromStringValue(strf(this, keyReferralsContractAddress()))
58 55  
59 56  let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
60 57  
90 87  func keyFactoryCfg () = "%s__factoryConfig"
91 88  
92 89  
90 + func keyFactoryLpList () = "%s__lpTokensList"
91 + 
92 + 
93 93  func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
94 94  
95 95  
99 99  func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
100 100  
101 101  
102 - func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(this, keyFactoryAddress()))
102 + func readFactoryAddressOrFail () = addressFromStringValue(strf(this, keyFactoryAddress()))
103 103  
104 104  
105 - func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
105 + func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
106 + 
107 + 
108 + func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
106 109  
107 110  
108 111  func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
144 147  func keyEmissionEndBlock () = "%s%s__emission__endBlock"
145 148  
146 149  
150 + func keyNextPeriod () = "%s__nextPeriod"
151 + 
152 + 
153 + func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
154 + 
155 + 
147 156  let IdxCfgAssetId = 1
148 157  
149 158  let IdxCfgMinLockAmount = 2
154 163  
155 164  let IdxCfgMathContract = 5
156 165  
157 - let IdxCfgBlocksInPeriod = 6
158 - 
159 166  func keyConfig () = "%s__config"
160 167  
161 168  
162 - func readConfigArrayOrFail () = split(getStringOrFail(this, keyConfig()), SEP)
169 + func readConfigArrayOrFail () = split(strf(this, keyConfig()), SEP)
163 170  
164 171  
165 - let cfgArray = readConfigArrayOrFail()
172 + let mathContract = addressFromStringValue(readConfigArrayOrFail()[IdxCfgMathContract])
166 173  
167 - let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
168 - 
169 - let minLockAmount = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockAmount]), wrapErr("invalid min lock amount"))
170 - 
171 - let minLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockDuration]), wrapErr("invalid min lock duration"))
172 - 
173 - let maxLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMaxLockDuration]), wrapErr("invalid max lock duration"))
174 - 
175 - let mathContract = valueOrErrorMessage(addressFromString(cfgArray[IdxCfgMathContract]), wrapErr("invalid math contract address"))
176 - 
177 - let blocksInPeriod = valueOrErrorMessage(parseInt(cfgArray[IdxCfgBlocksInPeriod]), wrapErr("invalid blocks in period"))
178 - 
179 - func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d%s", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
174 + func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
180 175  
181 176  
182 177  func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
220 215      }
221 216  
222 217  
223 - let IdxLockAmount = 1
218 + let IdxLockUserNum = 1
224 219  
225 - let IdxLockStart = 2
220 + let IdxLockAmount = 2
226 221  
227 - let IdxLockDuration = 3
222 + let IdxLockStart = 3
228 223  
229 - let IdxLockLastUpdateTimestamp = 4
224 + let IdxLockDuration = 4
230 225  
231 - let IdxLockGwxAmount = 5
226 + let IdxLockParamK = 5
232 227  
233 - let IdxLockWxClaimed = 6
228 + let IdxLockParamB = 6
234 229  
235 - func keyLockParamsRecord (userAddress,txId) = makeString(["%s%s%s__lock", toString(userAddress), match txId {
236 -     case b: ByteVector => 
237 -         toBase58String(b)
238 -     case _: Unit => 
239 -         "legacy"
240 -     case _ => 
241 -         throw("Match error")
242 - }], SEP)
230 + func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
243 231  
244 232  
245 - func readLockParamsRecordOrFail (userAddress,txId) = split(getStringOrFail(this, keyLockParamsRecord(userAddress, txId)), SEP)
233 + func readLockParamsRecordOrFail (userAddress) = split(strf(this, keyLockParamsRecord(userAddress)), SEP)
246 234  
247 235  
248 - func keyUserGwxAmountTotal (userAddress) = makeString(["%s%s__gwxAmountTotal", toString(userAddress)], SEP)
236 + 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)
249 237  
250 238  
251 - func formatLockParamsRecord (amount,start,duration,gwxAmount,wxClaimed) = makeString(["%d%d%d%d%d%d", toString(amount), toString(start), toString(duration), toString(lastBlock.timestamp), toString(gwxAmount), toString(wxClaimed)], SEP)
239 + 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))
252 240  
253 241  
254 242  func keyNextUserNum () = "%s__nextUserNum"
258 246  
259 247  
260 248  func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
249 + 
250 + 
251 + func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
252 + 
253 + 
254 + func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
255 + 
256 + 
257 + func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
258 + 
259 + 
260 + func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
261 + 
262 + 
263 + func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
264 + 
265 + 
266 + func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
267 + 
268 + 
269 + func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
261 270  
262 271  
263 272  func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
272 281  func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
273 282  
274 283  
275 - func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", toString(userNum)], SEP)
284 + func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum], SEP)
276 285  
277 286  
278 - func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", toString(userNum), lpAssetId], SEP)
287 + func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum, lpAssetId], SEP)
279 288  
280 289  
281 - func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", toString(userNum)], SEP)
290 + func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
282 291  
283 292  
284 293  func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
285 294  
286 295  
287 - func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", toString(userNum)], SEP)
296 + func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
288 297  
289 298  
290 - func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", toString(userNum)], SEP)
299 + func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
291 300  
292 301  
293 - func keyGwxTotal () = "%s%s__gwx__total"
302 + func keyTotalCachedGwx () = "%s%s__gwxCached__total"
303 + 
304 + 
305 + func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
294 306  
295 307  
296 308  func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
342 354  
343 355  let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
344 356  
345 - let keyVotingEmissionRateContract = makeString(["%s", "votingEmissionRateContract"], SEP)
346 - 
347 357  let boostCoeff = {
348 358      let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
349 359      if ($isInstanceOf(@, "Int"))
351 361          else throw(($getType(@) + " couldn't be cast to Int"))
352 362      }
353 363  
354 - func userNumberByAddressOrFail (userAddress) = match getString(this, keyUser2NumMapping(toString(userAddress))) {
355 -     case s: String => 
356 -         valueOrErrorMessage(parseInt(s), wrapErr("invalid user number"))
357 -     case _: Unit => 
358 -         throwErr("invalid user")
359 -     case _ => 
360 -         throw("Match error")
361 - }
362 - 
363 - 
364 - func getGwxAmountTotal () = valueOrElse(getInteger(this, keyGwxTotal()), 0)
365 - 
366 - 
367 - func getLockedGwxAmount (userAddress) = {
368 -     let functionName = "getLockedGwxAmount"
369 -     let votingEmissionRateContract = valueOrErrorMessage(    match getString(votingEmissionContract, keyVotingEmissionRateContract) {
370 -         case _: Unit => 
371 -             unit
372 -         case s: String => 
373 -             addressFromString(s)
374 -         case _ => 
375 -             throw("Match error")
376 -     }, wrapErr("invalid voting emission rate address"))
377 -     let lockedVotingEmissionRate = {
378 -         let @ = invoke(votingEmissionContract, functionName, [toString(userAddress)], nil)
379 -         if ($isInstanceOf(@, "Int"))
380 -             then @
381 -             else throw(($getType(@) + " couldn't be cast to Int"))
382 -         }
383 -     let lockedVotingEmission = {
384 -         let @ = invoke(votingEmissionRateContract, functionName, [toString(userAddress)], nil)
385 -         if ($isInstanceOf(@, "Int"))
386 -             then @
387 -             else throw(($getType(@) + " couldn't be cast to Int"))
388 -         }
389 -     let locked = max([lockedVotingEmissionRate, lockedVotingEmission])
390 -     locked
364 + func getTotalCachedGwx (correct) = {
365 +     let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi())
366 +     let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
367 +     let targetEpochOption = getInteger(this, keyTargetEpoch)
368 +     let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
369 +     let isCorrectionActivated = if (isDefined(targetEpochOption))
370 +         then (currentEpochUi >= value(targetEpochOption))
371 +         else false
372 +     let corrective = if (if (isCorrectionActivated)
373 +         then correct
374 +         else false)
375 +         then valueOrElse(getInteger(this, keyTotalCachedGwxCorrective()), 0)
376 +         else 0
377 +     max([0, (totalCachedGwxRaw + corrective)])
391 378      }
392 379  
393 380  
394 - func HistoryEntry (type,user,amount,lockStart,duration,gwxAmount,i) = {
381 + func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
395 382      let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
396 -     let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(gwxAmount)], SEP)
383 +     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)
397 384      StringEntry(historyKEY, historyDATA)
398 385      }
399 386  
403 390      let locksCountKEY = keyStatsLocksCount()
404 391      let usersCountKEY = keyStatsUsersCount()
405 392      let totalAmountKEY = keyLockParamTotalAmount()
406 -     let locksDurationSumInBlocks = getIntOrZero(this, locksDurationSumInBlocksKEY)
407 -     let locksCount = getIntOrZero(this, locksCountKEY)
408 -     let usersCount = getIntOrZero(this, usersCountKEY)
409 -     let totalAmount = getIntOrZero(this, totalAmountKEY)
393 +     let locksDurationSumInBlocks = ioz(this, locksDurationSumInBlocksKEY)
394 +     let locksCount = ioz(this, locksCountKEY)
395 +     let usersCount = ioz(this, usersCountKEY)
396 +     let totalAmount = ioz(this, totalAmountKEY)
410 397  [IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
411 398      }
412 399  
413 400  
414 - func LockParamsEntry (userAddress,txId,amount,start,duration,gwxAmount,wxClaimed) = [StringEntry(keyLockParamsRecord(userAddress, txId), formatLockParamsRecord(amount, start, duration, gwxAmount, wxClaimed))]
401 + func calcGwxAmount (kRaw,bRaw,h) = {
402 +     let SCALE = 1000
403 +     (((kRaw * h) + bRaw) / SCALE)
404 +     }
405 + 
406 + 
407 + func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
408 +     let userAmountKEY = keyLockParamUserAmount(userNum)
409 +     let startBlockKEY = keyLockParamStartBlock(userNum)
410 +     let durationKEY = keyLockParamDuration(userNum)
411 +     let kKEY = keyLockParamK(userNum)
412 +     let bKEY = keyLockParamB(userNum)
413 +     let kByPeriodKEY = keyLockParamByPeriodK(userNum, period)
414 +     let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
415 +     let gwxAmount = calcGwxAmount(k, b, height)
416 + [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))]
417 +     }
415 418  
416 419  
417 420  func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
426 429              }
427 430  
428 431  
429 - func getUserGwxAmountTotal (userAddress) = valueOrElse(getInteger(this, keyUserGwxAmountTotal(userAddress)), 0)
432 + func calcUserGwxAmountAtHeight (userAddress,targetHeight) = {
433 +     let EMPTY = "empty"
434 +     let user2NumMappingKEY = keyUser2NumMapping(userAddress)
435 +     let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
436 +     let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
437 +     let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
438 +     let gwxAmountCalc = calcGwxAmount(k, b, targetHeight)
439 +     let gwxAmount = if ((0 > gwxAmountCalc))
440 +         then 0
441 +         else gwxAmountCalc
442 +     gwxAmount
443 +     }
444 + 
445 + 
446 + func calcCurrentGwxAmount (userAddress) = calcUserGwxAmountAtHeight(userAddress, height)
430 447  
431 448  
432 449  func getVotingEmissionEpochInfo () = {
433 -     let $t01505115341 = {
450 +     let $t01718617476 = {
434 451          let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi()))
435 452          let lastFinalizedEpoch = (currentEpochUi - 1)
436 453          if ((0 > lastFinalizedEpoch))
437 454              then throwErr("invalid epoch")
438 455              else $Tuple2(currentEpochUi, lastFinalizedEpoch)
439 456          }
440 -     let currentEpochUi = $t01505115341._1
441 -     let lastFinalizedEpoch = $t01505115341._2
457 +     let currentEpochUi = $t01718617476._1
458 +     let lastFinalizedEpoch = $t01718617476._2
442 459      let currentEpochStartHeight = value(getInteger(votingEmissionContract, keyStartHeightByEpoch(currentEpochUi)))
443 460      $Tuple2(lastFinalizedEpoch, currentEpochStartHeight)
444 461      }
471 488  
472 489  func getUserVoteFinalized (lpAssetIdStr,userAddressStr) = {
473 490      let userAddress = addressFromStringValue(userAddressStr)
474 -     let $t01603216112 = getVotingEmissionEpochInfo()
475 -     let lastFinalizedEpoch = $t01603216112._1
476 -     let currentEpochStartHeight = $t01603216112._2
477 -     let $t01611516190 = getPoolAssetsByLpAssetId(lpAssetIdStr)
478 -     let amountAssetId = $t01611516190._1
479 -     let priceAssetId = $t01611516190._2
491 +     let $t01816718247 = getVotingEmissionEpochInfo()
492 +     let lastFinalizedEpoch = $t01816718247._1
493 +     let currentEpochStartHeight = $t01816718247._2
494 +     let $t01825018325 = getPoolAssetsByLpAssetId(lpAssetIdStr)
495 +     let amountAssetId = $t01825018325._1
496 +     let priceAssetId = $t01825018325._2
480 497      let userVoteKey = keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)
481 498      let userVote = valueOrElse(getInteger(votingEmissionContract, userVoteKey), 0)
482 499      userVote
493 510  
494 511  
495 512  func getVotingResultStaked (lpAssetIdStr) = {
496 -     let $t01673416814 = getVotingEmissionEpochInfo()
497 -     let lastFinalizedEpoch = $t01673416814._1
498 -     let currentEpochStartHeight = $t01673416814._2
513 +     let $t01886918949 = getVotingEmissionEpochInfo()
514 +     let lastFinalizedEpoch = $t01886918949._1
515 +     let currentEpochStartHeight = $t01886918949._2
499 516      let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
500 517      let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
501 518      votingResultStaked
503 520  
504 521  
505 522  func getVotingResultStakedIntegral (lpAssetIdStr) = {
506 -     let $t01717617256 = getVotingEmissionEpochInfo()
507 -     let lastFinalizedEpoch = $t01717617256._1
508 -     let currentEpochStartHeight = $t01717617256._2
523 +     let $t01931119391 = getVotingEmissionEpochInfo()
524 +     let lastFinalizedEpoch = $t01931119391._1
525 +     let currentEpochStartHeight = $t01931119391._2
509 526      let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
510 527      let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)), 0)
511 528      let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)), currentEpochStartHeight)
516 533  
517 534  
518 535  func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
519 -     let $t01809318173 = getVotingEmissionEpochInfo()
520 -     let lastFinalizedEpoch = $t01809318173._1
521 -     let currentEpochStartHeight = $t01809318173._2
536 +     let $t02022820308 = getVotingEmissionEpochInfo()
537 +     let lastFinalizedEpoch = $t02022820308._1
538 +     let currentEpochStartHeight = $t02022820308._2
522 539      let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
523 540      let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
524 541      let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)
527 544  
528 545  
529 546  func getUserVoteStakedIntegral (lpAssetIdStr,userAddressStr) = {
530 -     let $t01878418864 = getVotingEmissionEpochInfo()
531 -     let lastFinalizedEpoch = $t01878418864._1
532 -     let currentEpochStartHeight = $t01878418864._2
547 +     let $t02091920999 = getVotingEmissionEpochInfo()
548 +     let lastFinalizedEpoch = $t02091920999._1
549 +     let currentEpochStartHeight = $t02091920999._2
533 550      let userAddress = addressFromStringValue(userAddressStr)
534 551      let userVoteStaked = getUserVoteStaked(lpAssetIdStr, userAddressStr)
535 552      let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)), 0)
541 558  
542 559  
543 560  func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
544 -     let $t01965219732 = getVotingEmissionEpochInfo()
545 -     let lastFinalizedEpoch = $t01965219732._1
546 -     let currentEpochStartHeight = $t01965219732._2
561 +     let $t02178721867 = getVotingEmissionEpochInfo()
562 +     let lastFinalizedEpoch = $t02178721867._1
563 +     let currentEpochStartHeight = $t02178721867._2
547 564      let userAddress = addressFromStringValue(userAddressStr)
548 565      let userVoteFinalized = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
549 566      let actions = if ((userVoteFinalized == 0))
562 579  
563 580  
564 581  func getStakedVotesIntegralsDiff (lpAssetIdStr,userAddressStr) = {
565 -     let $t02058620666 = getVotingEmissionEpochInfo()
566 -     let lastFinalizedEpoch = $t02058620666._1
567 -     let currentEpochStartHeight = $t02058620666._2
582 +     let $t02272122801 = getVotingEmissionEpochInfo()
583 +     let lastFinalizedEpoch = $t02272122801._1
584 +     let currentEpochStartHeight = $t02272122801._2
568 585      let userAddress = addressFromStringValue(userAddressStr)
569 586      let userVoteStakedIntegralLastKey = keyVoteStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
570 587      let userVoteStakedIntegralLast = valueOrElse(getInteger(this, userVoteStakedIntegralLastKey), 0)
579 596  
580 597  
581 598  func refreshBoostEmissionIntegral () = {
582 -     let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
599 +     let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
583 600      let boostingV2LastUpdateHeightOption = getInteger(this, keyBoostingV2LastUpdateHeight())
584 601      let boostingV2IngergalOption = getInteger(this, keyBoostingV2Integral())
585 -     let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
602 +     let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
586 603      let h = if ((height > emissionEnd))
587 604          then emissionEnd
588 605          else height
602 619  
603 620  
604 621  func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
605 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
606 -     let userNum = userNumberByAddressOrFail(userAddress)
607 -     if ((userNum == userNum))
608 -         then {
622 +     let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
623 +     if ((userRecordOption == unit))
624 +         then $Tuple3(0, nil, "userRecord::is::empty")
625 +         else {
626 +             let userRecordArray = split(value(userRecordOption), SEP)
627 +             let userNumStr = userRecordArray[IdxLockUserNum]
609 628              let EMPTYSTR = "empty"
610 629              let poolWeight = if ((lpAssetIdStr != EMPTYSTR))
611 630                  then {
615 634                  else if (readOnly)
616 635                      then 0
617 636                      else throwErr(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
618 -             let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNum, lpAssetIdStr)
619 -             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNum)
620 -             let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), getIntOrZero(this, userBoostEmissionLastIntegralKEY))
637 +             let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
638 +             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
639 +             let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), ioz(this, userBoostEmissionLastIntegralKEY))
621 640              let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
622 641              let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
623 642              if ((0 > userBoostEmissionIntegral))
624 643                  then throwErr("wrong calculations")
625 644                  else {
626 -                     let $t02420824347 = getStakedVotesIntegralsDiff(lpAssetIdStr, userAddressStr)
627 -                     let stakedVotesIntegralsActions = $t02420824347._1
628 -                     let userVoteIntegralDiff = $t02420824347._2
629 -                     let totalVotesIntegralDiff = $t02420824347._3
645 +                     let $t02642026559 = getStakedVotesIntegralsDiff(lpAssetIdStr, userAddressStr)
646 +                     let stakedVotesIntegralsActions = $t02642026559._1
647 +                     let userVoteIntegralDiff = $t02642026559._2
648 +                     let totalVotesIntegralDiff = $t02642026559._3
630 649                      let poolUserBoostEmissionIntegral = fraction(userBoostEmissionIntegral, poolWeight, POOLWEIGHTMULT)
631 650                      let userBoostAvaliableToClaimTotalNew = if ((totalVotesIntegralDiff == 0))
632 651                          then 0
636 655                      $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
637 656                      }
638 657              }
639 -         else throw("Strict value is not equal to itself.")
640 658      }
641 659  
642 660  
643 - func lockActions (i,durationMonths) = if (!(containsElement(durationMonthsAllowed, durationMonths)))
644 -     then throwErr("invalid duration")
645 -     else {
646 -         let duration = (durationMonths * blocksInMonth)
647 -         let assetIdStr = toBase58String(assetId)
648 -         if ((size(i.payments) != 1))
649 -             then throwErr("invalid payment - exact one payment must be attached")
650 -             else {
651 -                 let pmt = i.payments[0]
652 -                 let pmtAmount = pmt.amount
653 -                 if ((assetId != value(pmt.assetId)))
654 -                     then throwErr((("invalid asset is in payment - " + assetIdStr) + " is expected"))
655 -                     else {
656 -                         let nextUserNumKEY = keyNextUserNum()
657 -                         let userAddress = i.caller
658 -                         let userAddressStr = toString(userAddress)
659 -                         let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
660 -                         let userNumStr = if (userIsExisting)
661 -                             then value(getString(keyUser2NumMapping(userAddressStr)))
662 -                             else toString(getIntOrFail(this, nextUserNumKEY))
663 -                         let userNum = parseIntValue(userNumStr)
664 -                         let lockStart = height
665 -                         if (if ((minLockAmount > pmtAmount))
666 -                             then (userAddress != lpStakingPoolsContract)
667 -                             else false)
668 -                             then throwErr(("amount is less then minLockAmount=" + toString(minLockAmount)))
669 -                             else if ((minLockDuration > duration))
670 -                                 then throwErr(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
671 -                                 else if ((duration > maxLockDuration))
672 -                                     then throwErr(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
673 -                                     else {
674 -                                         let gWxAmountStart = fraction(pmtAmount, duration, maxLockDuration)
675 -                                         let gwxAmountTotal = getGwxAmountTotal()
676 -                                         let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNum)
677 -                                         let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
678 -                                         let userGwxAmountTotal = getUserGwxAmountTotal(userAddress)
679 -                                         let gwxRewardInv = reentrantInvoke(gwxRewardContract, "refreshUserReward", [userAddress.bytes], nil)
680 -                                         if ((gwxRewardInv == gwxRewardInv))
681 -                                             then {
682 -                                                 let arr = if (userIsExisting)
683 -                                                     then nil
684 -                                                     else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
685 -                                                 $Tuple2(((((arr ++ LockParamsEntry(userAddress, i.transactionId, pmtAmount, lockStart, duration, gWxAmountStart, 0)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
686 -                                                     then 0
687 -                                                     else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, gWxAmountStart, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(keyGwxTotal(), (gwxAmountTotal + gWxAmountStart)), IntegerEntry(keyUserGwxAmountTotal(userAddress), (userGwxAmountTotal + gWxAmountStart))]), gWxAmountStart)
688 -                                                 }
689 -                                             else throw("Strict value is not equal to itself.")
690 -                                         }
691 -                         }
692 -                 }
693 -         }
694 - 
695 - 
696 - func getWxWithdrawable (userAddress,txIdOption) = {
697 -     let userRecordArray = readLockParamsRecordOrFail(userAddress, txIdOption)
698 -     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
699 -     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
700 -     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
701 -     let lockEnd = (lockStart + lockDuration)
702 -     let wxClaimed = parseIntValue(userRecordArray[IdxLockWxClaimed])
703 -     let t = ((height - lockStart) / blocksInPeriod)
704 -     let exponent = fraction(toBigInt(t), (toBigInt((8 * blocksInPeriod)) * MULT18BI), toBigInt(lockDuration))
705 -     let wxWithdrawable = if ((height > lockEnd))
706 -         then userAmount
707 -         else (toInt(fraction(toBigInt(userAmount), (MULT18BI - pow(toBigInt(5), 1, exponent, SCALE18, SCALE18, DOWN)), MULT18BI)) - wxClaimed)
708 -     wxWithdrawable
661 + func lockActions (i,duration) = {
662 +     let cfgArray = readConfigArrayOrFail()
663 +     let assetIdStr = cfgArray[IdxCfgAssetId]
664 +     let assetId = fromBase58String(assetIdStr)
665 +     let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
666 +     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
667 +     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
668 +     if ((size(i.payments) != 1))
669 +         then throwErr("invalid payment - exact one payment must be attached")
670 +         else {
671 +             let pmt = i.payments[0]
672 +             let pmtAmount = pmt.amount
673 +             if ((assetId != value(pmt.assetId)))
674 +                 then throwErr((("invalid asset is in payment - " + assetIdStr) + " is expected"))
675 +                 else {
676 +                     let nextUserNumKEY = keyNextUserNum()
677 +                     let userAddressStr = toString(i.caller)
678 +                     let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
679 +                     let userNumStr = if (userIsExisting)
680 +                         then value(getString(keyUser2NumMapping(userAddressStr)))
681 +                         else toString(iof(this, nextUserNumKEY))
682 +                     let userNum = parseIntValue(userNumStr)
683 +                     let lockStart = height
684 +                     let startBlockKEY = keyLockParamStartBlock(userNumStr)
685 +                     let durationKEY = keyLockParamDuration(userNumStr)
686 +                     let userAmountKEY = keyLockParamUserAmount(userNumStr)
687 +                     if (if ((minLockAmount > pmtAmount))
688 +                         then (i.caller != lpStakingPoolsContract)
689 +                         else false)
690 +                         then throwErr(("amount is less then minLockAmount=" + toString(minLockAmount)))
691 +                         else if ((minLockDuration > duration))
692 +                             then throwErr(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
693 +                             else if ((duration > maxLockDuration))
694 +                                 then throwErr(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
695 +                                 else if (if (userIsExisting)
696 +                                     then ((iof(this, startBlockKEY) + iof(this, durationKEY)) >= lockStart)
697 +                                     else false)
698 +                                     then throwErr("there is an active lock - consider to use increaseLock")
699 +                                     else if ((ioz(this, userAmountKEY) > 0))
700 +                                         then throwErr(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
701 +                                         else {
702 +                                             let coeffX8 = fraction(duration, MULT8, maxLockDuration)
703 +                                             let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
704 +                                             let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStart, duration], nil))
705 +                                             let k = ai(gWxParamsResultList[0])
706 +                                             let b = ai(gWxParamsResultList[1])
707 +                                             let period = toString(ai(gWxParamsResultList[2]))
708 +                                             let totalCachedGwxRaw = getTotalCachedGwx(false)
709 +                                             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
710 +                                             let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
711 +                                             let arr = if (userIsExisting)
712 +                                                 then nil
713 +                                                 else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
714 +                                             $Tuple2(((((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
715 +                                                 then 0
716 +                                                 else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gWxAmountStart))]), gWxAmountStart)
717 +                                             }
718 +                     }
719 +             }
709 720      }
710 721  
711 722  
721 732  
722 733  @Callable(i)
723 734  func lockRef (duration,referrerAddress,signature) = {
724 -     let $t02914629211 = lockActions(i, duration)
725 -     let lockActionsResult = $t02914629211._1
726 -     let gWxAmountStart = $t02914629211._2
735 +     let $t03117031235 = lockActions(i, duration)
736 +     let lockActionsResult = $t03117031235._1
737 +     let gWxAmountStart = $t03117031235._2
727 738      let referralAddress = toString(i.caller)
728 739      let refInv = if (if ((referrerAddress == ""))
729 740          then true
744 755  
745 756  @Callable(i)
746 757  func lock (duration) = {
747 -     let $t02966929734 = lockActions(i, duration)
748 -     let lockActionsResult = $t02966929734._1
749 -     let gWxAmountStart = $t02966929734._2
758 +     let $t03169331758 = lockActions(i, duration)
759 +     let lockActionsResult = $t03169331758._1
760 +     let gWxAmountStart = $t03169331758._2
750 761      let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
751 762      if ((updateRefActivity == updateRefActivity))
752 763          then $Tuple2(lockActionsResult, unit)
756 767  
757 768  
758 769  @Callable(i)
770 + func increaseLock (deltaDuration) = {
771 +     let cfgArray = readConfigArrayOrFail()
772 +     let assetIdStr = cfgArray[IdxCfgAssetId]
773 +     let assetId = fromBase58String(assetIdStr)
774 +     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
775 +     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
776 +     let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
777 +     let userAddressStr = toString(i.caller)
778 +     let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
779 +     let userNumStr = userRecordArray[IdxLockUserNum]
780 +     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
781 +     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
782 +     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
783 +     let lockEnd = (lockStart + lockDuration)
784 +     let remainingDuration = max([(lockEnd - height), 0])
785 +     let userAmountNew = (userAmount + pmtAmount)
786 +     let lockDurationNew = (remainingDuration + deltaDuration)
787 +     if ((0 > deltaDuration))
788 +         then throwErr("duration is less then zero")
789 +         else if ((minLockDuration > lockDurationNew))
790 +             then throwErr(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
791 +             else if ((lockDurationNew > maxLockDuration))
792 +                 then throwErr(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
793 +                 else {
794 +                     let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
795 +                     let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
796 +                     let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
797 +                     if ((updateRefActivity == updateRefActivity))
798 +                         then {
799 +                             let lockStartNew = height
800 +                             let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStartNew, lockDurationNew], nil))
801 +                             let k = ai(gWxParamsResultList[0])
802 +                             let b = ai(gWxParamsResultList[1])
803 +                             let period = toString(ai(gWxParamsResultList[2]))
804 +                             let currUserGwx = calcCurrentGwxAmount(userAddressStr)
805 +                             let gwxDiff = (gWxAmountStart - currUserGwx)
806 +                             if ((0 > gwxDiff))
807 +                                 then throwErr(("gwxDiff is less then 0: " + toString(gwxDiff)))
808 +                                 else {
809 +                                     let totalCachedGwxRaw = getTotalCachedGwx(false)
810 +                                     let totalCachedGwxCorrected = getTotalCachedGwx(true)
811 +                                     (((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))])
812 +                                     }
813 +                             }
814 +                         else throw("Strict value is not equal to itself.")
815 +                     }
816 +     }
817 + 
818 + 
819 + 
820 + @Callable(i)
759 821  func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
760 822      then throwErr("permissions denied")
761 823      else {
762 -         let $t03004430146 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
763 -         let userBoostAvailable = $t03004430146._1
764 -         let dataState = $t03004430146._2
765 -         let debug = $t03004430146._3
824 +         let $t03486334965 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
825 +         let userBoostAvailable = $t03486334965._1
826 +         let dataState = $t03486334965._2
827 +         let debug = $t03486334965._3
766 828          $Tuple2(dataState, [userBoostAvailable])
767 829          }
768 830  
770 832  
771 833  @Callable(i)
772 834  func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
773 -     let $t03027830379 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
774 -     let userBoostAvailable = $t03027830379._1
775 -     let dataState = $t03027830379._2
776 -     let debug = $t03027830379._3
835 +     let $t03509735198 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
836 +     let userBoostAvailable = $t03509735198._1
837 +     let dataState = $t03509735198._2
838 +     let debug = $t03509735198._3
777 839      $Tuple2(nil, [userBoostAvailable, debug])
778 840      }
779 841  
780 842  
781 843  
782 844  @Callable(i)
783 - func unlock (txIdStr) = {
784 -     let userAddress = i.caller
785 -     let userAddressStr = toString(userAddress)
786 -     let txId = fromBase58String(txIdStr)
787 -     let userRecordArray = readLockParamsRecordOrFail(userAddress, if ((txIdStr == ""))
788 -         then unit
789 -         else txId)
845 + func unlock (userAddress) = {
846 +     let userRecordArray = readLockParamsRecordOrFail(userAddress)
847 +     let userNumStr = userRecordArray[IdxLockUserNum]
790 848      let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
791 849      let lockStart = parseIntValue(userRecordArray[IdxLockStart])
792 850      let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
793 -     let wxClaimed = parseIntValue(userRecordArray[IdxLockWxClaimed])
794 -     let gwxAmount = parseIntValue(userRecordArray[IdxLockGwxAmount])
795 -     let t = ((height - lockStart) / blocksInPeriod)
796 -     let wxWithdrawable = getWxWithdrawable(userAddress, if ((txIdStr == ""))
797 -         then unit
798 -         else txId)
799 -     let gWxAmountStart = fraction(userAmount, lockDuration, maxLockDuration)
800 -     let gwxBurned = min([fraction((t * blocksInPeriod), gWxAmountStart, maxLockDuration), gwxAmount])
801 -     let gwxRemaining = ensurePositive((gwxAmount - gwxBurned), "gwxRemaining")
802 -     let lockedGwxAmount = getLockedGwxAmount(userAddress)
803 -     if ((0 >= userAmount))
804 -         then throwErr("nothing to unlock")
851 +     let lockEnd = (lockStart + lockDuration)
852 +     let cfgArray = readConfigArrayOrFail()
853 +     let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
854 +     if ((lockEnd >= height))
855 +         then throwErr((("wait " + toString(lockEnd)) + " to unlock"))
856 +         else if ((0 >= userAmount))
857 +             then throwErr("nothing to unlock")
858 +             else {
859 +                 let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
860 +                 (((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))
861 +                 }
862 +     }
863 + 
864 + 
865 + 
866 + @Callable(i)
867 + func gwxUserInfoREADONLY (userAddress) = {
868 +     let gwxAmount = calcCurrentGwxAmount(userAddress)
869 +     $Tuple2(nil, [gwxAmount])
870 +     }
871 + 
872 + 
873 + 
874 + @Callable(i)
875 + func userMaxDurationREADONLY (userAddressStr) = {
876 +     let cfgArray = readConfigArrayOrFail()
877 +     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
878 +     let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
879 +     if ((userRecordOption == unit))
880 +         then $Tuple2(nil, $Tuple2("lock", maxLockDuration))
805 881          else {
806 -             let gwxAmountTotal = getGwxAmountTotal()
807 -             let userGwxAmountTotal = getUserGwxAmountTotal(userAddress)
808 -             let userGwxAmountTotalNew = ensurePositive((userGwxAmountTotal - gwxBurned), "userGwxAmountTotalNew")
809 -             if ((lockedGwxAmount > userGwxAmountTotalNew))
810 -                 then throwErr(("locked gwx amount: " + toString(lockedGwxAmount)))
811 -                 else {
812 -                     let gwxRewardInv = reentrantInvoke(gwxRewardContract, "refreshUserReward", [userAddress.bytes], nil)
813 -                     if ((gwxRewardInv == gwxRewardInv))
814 -                         then ((((LockParamsEntry(userAddress, txId, userAmount, lockStart, lockDuration, gwxRemaining, (wxClaimed + wxWithdrawable)) ++ StatsEntry(-(wxWithdrawable), 0, 0, 0)) :+ HistoryEntry("unlock", userAddressStr, wxWithdrawable, lockStart, lockDuration, gwxBurned, i)) :+ ScriptTransfer(userAddress, wxWithdrawable, assetId)) ++ [IntegerEntry(keyGwxTotal(), ensurePositive((gwxAmountTotal - gwxBurned), "gwxTotal")), IntegerEntry(keyUserGwxAmountTotal(userAddress), userGwxAmountTotalNew)])
815 -                         else throw("Strict value is not equal to itself.")
816 -                     }
882 +             let userRecordArray = split(value(userRecordOption), SEP)
883 +             let lockStart = parseIntValue(userRecordArray[IdxLockStart])
884 +             let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
885 +             let lockEnd = (lockStart + lockDuration)
886 +             let remainingDuration = max([(lockEnd - height), 0])
887 +             let maxDeltaDuration = (maxLockDuration - remainingDuration)
888 +             $Tuple2(nil, $Tuple2("increaseLock", maxDeltaDuration))
817 889              }
818 890      }
819 891  
820 892  
821 893  
822 894  @Callable(i)
823 - func gwxUserInfoREADONLY (userAddressStr) = {
824 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
825 -     let gwxAmount = getUserGwxAmountTotal(userAddress)
826 -     $Tuple2(nil, [gwxAmount])
827 -     }
828 - 
829 - 
830 - 
831 - @Callable(i)
832 - func userMaxDurationREADONLY (userAddressStr) = $Tuple2(nil, $Tuple2("increaseLock", maxLockDuration))
833 - 
834 - 
835 - 
836 - @Callable(i)
837 - func getUserGwxAmountAtHeightREADONLY (userAddressStr,targetHeight) = {
838 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
839 -     let gwxAmount = getUserGwxAmountTotal(userAddress)
895 + func getUserGwxAmountAtHeightREADONLY (userAddress,targetHeight) = {
896 +     let gwxAmount = calcUserGwxAmountAtHeight(userAddress, targetHeight)
840 897      $Tuple2(nil, gwxAmount)
841 898      }
842 899  
843 900  
844 901  
845 902  @Callable(i)
846 - func getUserGwxAmount (userAddressStr) = {
847 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
848 -     let gwxAmount = getUserGwxAmountTotal(userAddress)
849 -     $Tuple2(nil, gwxAmount)
850 -     }
851 - 
852 - 
853 - 
854 - @Callable(i)
855 - func getGwxTotalREADONLY () = $Tuple2(nil, getGwxAmountTotal())
903 + func getTotalCachedGwxREADONLY () = $Tuple2(nil, getTotalCachedGwx(true))
856 904  
857 905  
858 906  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let SEP = "__"
5 5  
6 6  let SCALE8 = 8
7 7  
8 8  let MULT8 = 100000000
9 9  
10 10  let POOLWEIGHTMULT = MULT8
11 11  
12 - let contractFilename = "boosting.ride"
13 - 
14 - let SCALE18 = 18
15 - 
16 - let MULT18 = 1000000000000000000
17 - 
18 - let MULT18BI = toBigInt(MULT18)
19 - 
20 - let durationMonthsAllowed = [1, 3, 6, 12, 24, 48]
21 - 
22 - let blocksInDay = 1440
23 - 
24 - let blocksInMonth = 43800
25 - 
26 - func wrapErr (msg) = makeString([contractFilename, ": ", msg], "")
12 + func wrapErr (msg) = makeString(["boosting.ride:", msg], " ")
27 13  
28 14  
29 15  func throwErr (msg) = throw(wrapErr(msg))
30 16  
31 17  
32 - func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
18 + func strf (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
33 19  
34 20  
35 - func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
21 + func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
36 22  
37 23  
38 - func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
24 + func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
39 25  
40 26  
41 - func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
27 + func iof (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
42 28  
43 29  
44 30  func abs (val) = if ((0 > val))
45 31      then -(val)
46 32      else val
47 33  
48 34  
49 - func ensurePositive (v,m) = if ((v >= 0))
50 -     then v
51 -     else throwErr((valueOrElse(m, "value") + " should be positive"))
35 + func aal (val) = match val {
36 +     case valAnyLyst: List[Any] => 
37 +         valAnyLyst
38 +     case _ => 
39 +         throwErr("fail to cast into List[Any]")
40 + }
41 + 
42 + 
43 + func ai (val) = match val {
44 +     case valInt: Int => 
45 +         valInt
46 +     case _ => 
47 +         throwErr("fail to cast into Int")
48 + }
52 49  
53 50  
54 51  func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
55 52  
56 53  
57 - let referralsContractAddressOrFail = addressFromStringValue(getStringOrFail(this, keyReferralsContractAddress()))
54 + let referralsContractAddressOrFail = addressFromStringValue(strf(this, keyReferralsContractAddress()))
58 55  
59 56  let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
60 57  
61 58  let referralProgramNameDefault = "wxlock"
62 59  
63 60  let referralProgramName = valueOrElse(getString(this, keyReferralProgramName), referralProgramNameDefault)
64 61  
65 62  func keyFactoryAddress () = "%s%s__config__factoryAddress"
66 63  
67 64  
68 65  let IdxFactoryCfgStakingDapp = 1
69 66  
70 67  let IdxFactoryCfgBoostingDapp = 2
71 68  
72 69  let IdxFactoryCfgIdoDapp = 3
73 70  
74 71  let IdxFactoryCfgTeamDapp = 4
75 72  
76 73  let IdxFactoryCfgEmissionDapp = 5
77 74  
78 75  let IdxFactoryCfgRestDapp = 6
79 76  
80 77  let IdxFactoryCfgSlippageDapp = 7
81 78  
82 79  let IdxFactoryCfgDaoDapp = 8
83 80  
84 81  let IdxFactoryCfgMarketingDapp = 9
85 82  
86 83  let IdxFactoryCfgGwxRewardDapp = 10
87 84  
88 85  let IdxFactoryCfgBirdsDapp = 11
89 86  
90 87  func keyFactoryCfg () = "%s__factoryConfig"
91 88  
92 89  
90 + func keyFactoryLpList () = "%s__lpTokensList"
91 + 
92 + 
93 93  func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
94 94  
95 95  
96 96  func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
97 97  
98 98  
99 99  func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
100 100  
101 101  
102 - func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(this, keyFactoryAddress()))
102 + func readFactoryAddressOrFail () = addressFromStringValue(strf(this, keyFactoryAddress()))
103 103  
104 104  
105 - func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
105 + func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
106 + 
107 + 
108 + func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
106 109  
107 110  
108 111  func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
109 112  
110 113  
111 114  func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
112 115  
113 116  
114 117  func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
115 118  
116 119  
117 120  func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
118 121  
119 122  
120 123  func keyManagerPublicKey () = "%s__managerPublicKey"
121 124  
122 125  
123 126  func keyManagerVaultAddress () = "%s__managerVaultAddress"
124 127  
125 128  
126 129  func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
127 130  
128 131  
129 132  func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
130 133  
131 134  
132 135  func keyEmissionStartBlock () = "%s%s__emission__startBlock"
133 136  
134 137  
135 138  func keyBoostingV2LastUpdateHeight () = "%s%s__boostingV2__startBlock"
136 139  
137 140  
138 141  func keyBoostingV2Integral () = "%s%s__boostingV2__integral"
139 142  
140 143  
141 144  func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
142 145  
143 146  
144 147  func keyEmissionEndBlock () = "%s%s__emission__endBlock"
145 148  
146 149  
150 + func keyNextPeriod () = "%s__nextPeriod"
151 + 
152 + 
153 + func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
154 + 
155 + 
147 156  let IdxCfgAssetId = 1
148 157  
149 158  let IdxCfgMinLockAmount = 2
150 159  
151 160  let IdxCfgMinLockDuration = 3
152 161  
153 162  let IdxCfgMaxLockDuration = 4
154 163  
155 164  let IdxCfgMathContract = 5
156 165  
157 - let IdxCfgBlocksInPeriod = 6
158 - 
159 166  func keyConfig () = "%s__config"
160 167  
161 168  
162 - func readConfigArrayOrFail () = split(getStringOrFail(this, keyConfig()), SEP)
169 + func readConfigArrayOrFail () = split(strf(this, keyConfig()), SEP)
163 170  
164 171  
165 - let cfgArray = readConfigArrayOrFail()
172 + let mathContract = addressFromStringValue(readConfigArrayOrFail()[IdxCfgMathContract])
166 173  
167 - let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
168 - 
169 - let minLockAmount = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockAmount]), wrapErr("invalid min lock amount"))
170 - 
171 - let minLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockDuration]), wrapErr("invalid min lock duration"))
172 - 
173 - let maxLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMaxLockDuration]), wrapErr("invalid max lock duration"))
174 - 
175 - let mathContract = valueOrErrorMessage(addressFromString(cfgArray[IdxCfgMathContract]), wrapErr("invalid math contract address"))
176 - 
177 - let blocksInPeriod = valueOrErrorMessage(parseInt(cfgArray[IdxCfgBlocksInPeriod]), wrapErr("invalid blocks in period"))
178 - 
179 - func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d%s", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
174 + func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
180 175  
181 176  
182 177  func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
183 178  
184 179  
185 180  func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
186 181      case s: String => 
187 182          addressFromStringValue(s)
188 183      case _ => 
189 184          this
190 185  }
191 186  
192 187  
193 188  func managerPublicKeyOrUnit () = {
194 189      let managerVaultAddress = getManagerVaultAddressOrThis()
195 190      match getString(managerVaultAddress, keyManagerPublicKey()) {
196 191          case s: String => 
197 192              fromBase58String(s)
198 193          case _: Unit => 
199 194              unit
200 195          case _ => 
201 196              throw("Match error")
202 197      }
203 198      }
204 199  
205 200  
206 201  func mustManager (i) = {
207 202      let pd = throwErr("Permission denied")
208 203      match managerPublicKeyOrUnit() {
209 204          case pk: ByteVector => 
210 205              if ((i.callerPublicKey == pk))
211 206                  then true
212 207                  else pd
213 208          case _: Unit => 
214 209              if ((i.caller == this))
215 210                  then true
216 211                  else pd
217 212          case _ => 
218 213              throw("Match error")
219 214      }
220 215      }
221 216  
222 217  
223 - let IdxLockAmount = 1
218 + let IdxLockUserNum = 1
224 219  
225 - let IdxLockStart = 2
220 + let IdxLockAmount = 2
226 221  
227 - let IdxLockDuration = 3
222 + let IdxLockStart = 3
228 223  
229 - let IdxLockLastUpdateTimestamp = 4
224 + let IdxLockDuration = 4
230 225  
231 - let IdxLockGwxAmount = 5
226 + let IdxLockParamK = 5
232 227  
233 - let IdxLockWxClaimed = 6
228 + let IdxLockParamB = 6
234 229  
235 - func keyLockParamsRecord (userAddress,txId) = makeString(["%s%s%s__lock", toString(userAddress), match txId {
236 -     case b: ByteVector => 
237 -         toBase58String(b)
238 -     case _: Unit => 
239 -         "legacy"
240 -     case _ => 
241 -         throw("Match error")
242 - }], SEP)
230 + func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
243 231  
244 232  
245 - func readLockParamsRecordOrFail (userAddress,txId) = split(getStringOrFail(this, keyLockParamsRecord(userAddress, txId)), SEP)
233 + func readLockParamsRecordOrFail (userAddress) = split(strf(this, keyLockParamsRecord(userAddress)), SEP)
246 234  
247 235  
248 - func keyUserGwxAmountTotal (userAddress) = makeString(["%s%s__gwxAmountTotal", toString(userAddress)], SEP)
236 + 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)
249 237  
250 238  
251 - func formatLockParamsRecord (amount,start,duration,gwxAmount,wxClaimed) = makeString(["%d%d%d%d%d%d", toString(amount), toString(start), toString(duration), toString(lastBlock.timestamp), toString(gwxAmount), toString(wxClaimed)], SEP)
239 + 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))
252 240  
253 241  
254 242  func keyNextUserNum () = "%s__nextUserNum"
255 243  
256 244  
257 245  func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
258 246  
259 247  
260 248  func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
249 + 
250 + 
251 + func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
252 + 
253 + 
254 + func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
255 + 
256 + 
257 + func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
258 + 
259 + 
260 + func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
261 + 
262 + 
263 + func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
264 + 
265 + 
266 + func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
267 + 
268 + 
269 + func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
261 270  
262 271  
263 272  func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
264 273  
265 274  
266 275  func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
267 276  
268 277  
269 278  func keyStatsLocksCount () = "%s%s__stats__locksCount"
270 279  
271 280  
272 281  func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
273 282  
274 283  
275 - func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", toString(userNum)], SEP)
284 + func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum], SEP)
276 285  
277 286  
278 - func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", toString(userNum), lpAssetId], SEP)
287 + func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum, lpAssetId], SEP)
279 288  
280 289  
281 - func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", toString(userNum)], SEP)
290 + func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
282 291  
283 292  
284 293  func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
285 294  
286 295  
287 - func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", toString(userNum)], SEP)
296 + func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
288 297  
289 298  
290 - func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", toString(userNum)], SEP)
299 + func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
291 300  
292 301  
293 - func keyGwxTotal () = "%s%s__gwx__total"
302 + func keyTotalCachedGwx () = "%s%s__gwxCached__total"
303 + 
304 + 
305 + func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
294 306  
295 307  
296 308  func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
297 309  
298 310  
299 311  func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], SEP)
300 312  
301 313  
302 314  func keyCurrentEpochUi () = makeString(["%s", "currentEpochUi"], SEP)
303 315  
304 316  
305 317  func keyVotingResultStaked (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStaked", lpAssetIdStr, toString(epoch)], SEP)
306 318  
307 319  
308 320  func keyVotingResultStakedIntegral (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegral", lpAssetIdStr, toString(epoch)], SEP)
309 321  
310 322  
311 323  func keyVotingResultStakedLastUpdateHeight (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(epoch)], SEP)
312 324  
313 325  
314 326  func keyVotingResultStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "votingResultStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
315 327  
316 328  
317 329  func keyVoteStakedIntegral (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegral", lpAssetIdStr, toString(address), toString(epoch)], SEP)
318 330  
319 331  
320 332  func keyVoteStakedLastUpdateHeight (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(address), toString(epoch)], SEP)
321 333  
322 334  
323 335  func keyVoteStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
324 336  
325 337  
326 338  func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s", "staked", userAddressStr, lpAssetIdStr], SEP)
327 339  
328 340  
329 341  let factoryContract = readFactoryAddressOrFail()
330 342  
331 343  let factoryCfg = readFactoryCfgOrFail(factoryContract)
332 344  
333 345  let emissionContract = getEmissionAddressOrFail(factoryCfg)
334 346  
335 347  let stakingContract = getStakingAddressOrFail(factoryCfg)
336 348  
337 349  let gwxRewardContract = getGwxRewardAddressOrFail(factoryCfg)
338 350  
339 351  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"))
340 352  
341 353  let keyVotingEmissionContract = makeString(["%s", "votingEmissionContract"], SEP)
342 354  
343 355  let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
344 356  
345 - let keyVotingEmissionRateContract = makeString(["%s", "votingEmissionRateContract"], SEP)
346 - 
347 357  let boostCoeff = {
348 358      let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
349 359      if ($isInstanceOf(@, "Int"))
350 360          then @
351 361          else throw(($getType(@) + " couldn't be cast to Int"))
352 362      }
353 363  
354 - func userNumberByAddressOrFail (userAddress) = match getString(this, keyUser2NumMapping(toString(userAddress))) {
355 -     case s: String => 
356 -         valueOrErrorMessage(parseInt(s), wrapErr("invalid user number"))
357 -     case _: Unit => 
358 -         throwErr("invalid user")
359 -     case _ => 
360 -         throw("Match error")
361 - }
362 - 
363 - 
364 - func getGwxAmountTotal () = valueOrElse(getInteger(this, keyGwxTotal()), 0)
365 - 
366 - 
367 - func getLockedGwxAmount (userAddress) = {
368 -     let functionName = "getLockedGwxAmount"
369 -     let votingEmissionRateContract = valueOrErrorMessage(    match getString(votingEmissionContract, keyVotingEmissionRateContract) {
370 -         case _: Unit => 
371 -             unit
372 -         case s: String => 
373 -             addressFromString(s)
374 -         case _ => 
375 -             throw("Match error")
376 -     }, wrapErr("invalid voting emission rate address"))
377 -     let lockedVotingEmissionRate = {
378 -         let @ = invoke(votingEmissionContract, functionName, [toString(userAddress)], nil)
379 -         if ($isInstanceOf(@, "Int"))
380 -             then @
381 -             else throw(($getType(@) + " couldn't be cast to Int"))
382 -         }
383 -     let lockedVotingEmission = {
384 -         let @ = invoke(votingEmissionRateContract, functionName, [toString(userAddress)], nil)
385 -         if ($isInstanceOf(@, "Int"))
386 -             then @
387 -             else throw(($getType(@) + " couldn't be cast to Int"))
388 -         }
389 -     let locked = max([lockedVotingEmissionRate, lockedVotingEmission])
390 -     locked
364 + func getTotalCachedGwx (correct) = {
365 +     let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi())
366 +     let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
367 +     let targetEpochOption = getInteger(this, keyTargetEpoch)
368 +     let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
369 +     let isCorrectionActivated = if (isDefined(targetEpochOption))
370 +         then (currentEpochUi >= value(targetEpochOption))
371 +         else false
372 +     let corrective = if (if (isCorrectionActivated)
373 +         then correct
374 +         else false)
375 +         then valueOrElse(getInteger(this, keyTotalCachedGwxCorrective()), 0)
376 +         else 0
377 +     max([0, (totalCachedGwxRaw + corrective)])
391 378      }
392 379  
393 380  
394 - func HistoryEntry (type,user,amount,lockStart,duration,gwxAmount,i) = {
381 + func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
395 382      let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
396 -     let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(gwxAmount)], SEP)
383 +     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)
397 384      StringEntry(historyKEY, historyDATA)
398 385      }
399 386  
400 387  
401 388  func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
402 389      let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
403 390      let locksCountKEY = keyStatsLocksCount()
404 391      let usersCountKEY = keyStatsUsersCount()
405 392      let totalAmountKEY = keyLockParamTotalAmount()
406 -     let locksDurationSumInBlocks = getIntOrZero(this, locksDurationSumInBlocksKEY)
407 -     let locksCount = getIntOrZero(this, locksCountKEY)
408 -     let usersCount = getIntOrZero(this, usersCountKEY)
409 -     let totalAmount = getIntOrZero(this, totalAmountKEY)
393 +     let locksDurationSumInBlocks = ioz(this, locksDurationSumInBlocksKEY)
394 +     let locksCount = ioz(this, locksCountKEY)
395 +     let usersCount = ioz(this, usersCountKEY)
396 +     let totalAmount = ioz(this, totalAmountKEY)
410 397  [IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
411 398      }
412 399  
413 400  
414 - func LockParamsEntry (userAddress,txId,amount,start,duration,gwxAmount,wxClaimed) = [StringEntry(keyLockParamsRecord(userAddress, txId), formatLockParamsRecord(amount, start, duration, gwxAmount, wxClaimed))]
401 + func calcGwxAmount (kRaw,bRaw,h) = {
402 +     let SCALE = 1000
403 +     (((kRaw * h) + bRaw) / SCALE)
404 +     }
405 + 
406 + 
407 + func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
408 +     let userAmountKEY = keyLockParamUserAmount(userNum)
409 +     let startBlockKEY = keyLockParamStartBlock(userNum)
410 +     let durationKEY = keyLockParamDuration(userNum)
411 +     let kKEY = keyLockParamK(userNum)
412 +     let bKEY = keyLockParamB(userNum)
413 +     let kByPeriodKEY = keyLockParamByPeriodK(userNum, period)
414 +     let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
415 +     let gwxAmount = calcGwxAmount(k, b, height)
416 + [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))]
417 +     }
415 418  
416 419  
417 420  func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
418 421      then throwErr("only one payment is allowed")
419 422      else if ((size(i.payments) == 0))
420 423          then 0
421 424          else {
422 425              let pmt = i.payments[0]
423 426              if ((value(pmt.assetId) != expectedAssetId))
424 427                  then throwErr("invalid asset id in payment")
425 428                  else pmt.amount
426 429              }
427 430  
428 431  
429 - func getUserGwxAmountTotal (userAddress) = valueOrElse(getInteger(this, keyUserGwxAmountTotal(userAddress)), 0)
432 + func calcUserGwxAmountAtHeight (userAddress,targetHeight) = {
433 +     let EMPTY = "empty"
434 +     let user2NumMappingKEY = keyUser2NumMapping(userAddress)
435 +     let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
436 +     let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
437 +     let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
438 +     let gwxAmountCalc = calcGwxAmount(k, b, targetHeight)
439 +     let gwxAmount = if ((0 > gwxAmountCalc))
440 +         then 0
441 +         else gwxAmountCalc
442 +     gwxAmount
443 +     }
444 + 
445 + 
446 + func calcCurrentGwxAmount (userAddress) = calcUserGwxAmountAtHeight(userAddress, height)
430 447  
431 448  
432 449  func getVotingEmissionEpochInfo () = {
433 -     let $t01505115341 = {
450 +     let $t01718617476 = {
434 451          let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi()))
435 452          let lastFinalizedEpoch = (currentEpochUi - 1)
436 453          if ((0 > lastFinalizedEpoch))
437 454              then throwErr("invalid epoch")
438 455              else $Tuple2(currentEpochUi, lastFinalizedEpoch)
439 456          }
440 -     let currentEpochUi = $t01505115341._1
441 -     let lastFinalizedEpoch = $t01505115341._2
457 +     let currentEpochUi = $t01718617476._1
458 +     let lastFinalizedEpoch = $t01718617476._2
442 459      let currentEpochStartHeight = value(getInteger(votingEmissionContract, keyStartHeightByEpoch(currentEpochUi)))
443 460      $Tuple2(lastFinalizedEpoch, currentEpochStartHeight)
444 461      }
445 462  
446 463  
447 464  func getPoolAssetsByLpAssetId (lpAssetIdStr) = {
448 465      let idxAmountAssetId = 4
449 466      let idxPriceAssetId = 5
450 467      let poolCfg = {
451 468          let @ = invoke(factoryContract, "getPoolConfigByLpAssetIdREADONLY", [lpAssetIdStr], nil)
452 469          if ($isInstanceOf(@, "List[Any]"))
453 470              then @
454 471              else throw(($getType(@) + " couldn't be cast to List[Any]"))
455 472          }
456 473      let amountAssetId = {
457 474          let @ = poolCfg[idxAmountAssetId]
458 475          if ($isInstanceOf(@, "String"))
459 476              then @
460 477              else throw(($getType(@) + " couldn't be cast to String"))
461 478          }
462 479      let priceAssetId = {
463 480          let @ = poolCfg[idxPriceAssetId]
464 481          if ($isInstanceOf(@, "String"))
465 482              then @
466 483              else throw(($getType(@) + " couldn't be cast to String"))
467 484          }
468 485      $Tuple2(amountAssetId, priceAssetId)
469 486      }
470 487  
471 488  
472 489  func getUserVoteFinalized (lpAssetIdStr,userAddressStr) = {
473 490      let userAddress = addressFromStringValue(userAddressStr)
474 -     let $t01603216112 = getVotingEmissionEpochInfo()
475 -     let lastFinalizedEpoch = $t01603216112._1
476 -     let currentEpochStartHeight = $t01603216112._2
477 -     let $t01611516190 = getPoolAssetsByLpAssetId(lpAssetIdStr)
478 -     let amountAssetId = $t01611516190._1
479 -     let priceAssetId = $t01611516190._2
491 +     let $t01816718247 = getVotingEmissionEpochInfo()
492 +     let lastFinalizedEpoch = $t01816718247._1
493 +     let currentEpochStartHeight = $t01816718247._2
494 +     let $t01825018325 = getPoolAssetsByLpAssetId(lpAssetIdStr)
495 +     let amountAssetId = $t01825018325._1
496 +     let priceAssetId = $t01825018325._2
480 497      let userVoteKey = keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)
481 498      let userVote = valueOrElse(getInteger(votingEmissionContract, userVoteKey), 0)
482 499      userVote
483 500      }
484 501  
485 502  
486 503  func getUserVoteStaked (lpAssetIdStr,userAddressStr) = {
487 504      let stakedByUser = valueOrElse(getInteger(stakingContract, keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
488 505      let userVote = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
489 506      if ((stakedByUser == 0))
490 507          then 0
491 508          else userVote
492 509      }
493 510  
494 511  
495 512  func getVotingResultStaked (lpAssetIdStr) = {
496 -     let $t01673416814 = getVotingEmissionEpochInfo()
497 -     let lastFinalizedEpoch = $t01673416814._1
498 -     let currentEpochStartHeight = $t01673416814._2
513 +     let $t01886918949 = getVotingEmissionEpochInfo()
514 +     let lastFinalizedEpoch = $t01886918949._1
515 +     let currentEpochStartHeight = $t01886918949._2
499 516      let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
500 517      let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
501 518      votingResultStaked
502 519      }
503 520  
504 521  
505 522  func getVotingResultStakedIntegral (lpAssetIdStr) = {
506 -     let $t01717617256 = getVotingEmissionEpochInfo()
507 -     let lastFinalizedEpoch = $t01717617256._1
508 -     let currentEpochStartHeight = $t01717617256._2
523 +     let $t01931119391 = getVotingEmissionEpochInfo()
524 +     let lastFinalizedEpoch = $t01931119391._1
525 +     let currentEpochStartHeight = $t01931119391._2
509 526      let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
510 527      let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)), 0)
511 528      let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)), currentEpochStartHeight)
512 529      let votingResultStakedIntegralDh = (height - votingResultStakedLastUpdateHeight)
513 530      let votingResultStakedIntegral = ((votingResultStakedIntegralDh * votingResultStaked) + votingResultStakedIntegralPrev)
514 531      votingResultStakedIntegral
515 532      }
516 533  
517 534  
518 535  func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
519 -     let $t01809318173 = getVotingEmissionEpochInfo()
520 -     let lastFinalizedEpoch = $t01809318173._1
521 -     let currentEpochStartHeight = $t01809318173._2
536 +     let $t02022820308 = getVotingEmissionEpochInfo()
537 +     let lastFinalizedEpoch = $t02022820308._1
538 +     let currentEpochStartHeight = $t02022820308._2
522 539      let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
523 540      let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
524 541      let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)
525 542  [IntegerEntry(keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedNew), IntegerEntry(keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch), height), IntegerEntry(keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedIntegral)]
526 543      }
527 544  
528 545  
529 546  func getUserVoteStakedIntegral (lpAssetIdStr,userAddressStr) = {
530 -     let $t01878418864 = getVotingEmissionEpochInfo()
531 -     let lastFinalizedEpoch = $t01878418864._1
532 -     let currentEpochStartHeight = $t01878418864._2
547 +     let $t02091920999 = getVotingEmissionEpochInfo()
548 +     let lastFinalizedEpoch = $t02091920999._1
549 +     let currentEpochStartHeight = $t02091920999._2
533 550      let userAddress = addressFromStringValue(userAddressStr)
534 551      let userVoteStaked = getUserVoteStaked(lpAssetIdStr, userAddressStr)
535 552      let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)), 0)
536 553      let userVoteStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch)), currentEpochStartHeight)
537 554      let userVoteStakedIntegralDh = (height - userVoteStakedLastUpdateHeight)
538 555      let userVoteStakedIntegral = ((userVoteStakedIntegralDh * userVoteStaked) + userVoteStakedIntegralPrev)
539 556      userVoteStakedIntegral
540 557      }
541 558  
542 559  
543 560  func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
544 -     let $t01965219732 = getVotingEmissionEpochInfo()
545 -     let lastFinalizedEpoch = $t01965219732._1
546 -     let currentEpochStartHeight = $t01965219732._2
561 +     let $t02178721867 = getVotingEmissionEpochInfo()
562 +     let lastFinalizedEpoch = $t02178721867._1
563 +     let currentEpochStartHeight = $t02178721867._2
547 564      let userAddress = addressFromStringValue(userAddressStr)
548 565      let userVoteFinalized = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
549 566      let actions = if ((userVoteFinalized == 0))
550 567          then nil
551 568          else {
552 569              let stakedVoteDelta = if (edge)
553 570                  then userVoteFinalized
554 571                  else -(userVoteFinalized)
555 572              let votingResultActions = refreshVotingResultStakedIntegral(lpAssetIdStr, stakedVoteDelta)
556 573              let userVoteStakedIntegral = getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr)
557 574              let voteActions = [IntegerEntry(keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch), height), IntegerEntry(keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch), userVoteStakedIntegral)]
558 575              (votingResultActions ++ voteActions)
559 576              }
560 577      actions
561 578      }
562 579  
563 580  
564 581  func getStakedVotesIntegralsDiff (lpAssetIdStr,userAddressStr) = {
565 -     let $t02058620666 = getVotingEmissionEpochInfo()
566 -     let lastFinalizedEpoch = $t02058620666._1
567 -     let currentEpochStartHeight = $t02058620666._2
582 +     let $t02272122801 = getVotingEmissionEpochInfo()
583 +     let lastFinalizedEpoch = $t02272122801._1
584 +     let currentEpochStartHeight = $t02272122801._2
568 585      let userAddress = addressFromStringValue(userAddressStr)
569 586      let userVoteStakedIntegralLastKey = keyVoteStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
570 587      let userVoteStakedIntegralLast = valueOrElse(getInteger(this, userVoteStakedIntegralLastKey), 0)
571 588      let votingResultStakedIntegralLastKey = keyVotingResultStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
572 589      let votingResultStakedIntegralLast = valueOrElse(getInteger(this, votingResultStakedIntegralLastKey), 0)
573 590      let userVoteStakedIntegral = getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr)
574 591      let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)
575 592      let userVoteStakedIntegralDiff = (userVoteStakedIntegral - userVoteStakedIntegralLast)
576 593      let votingResultStakedIntegralDiff = (votingResultStakedIntegral - votingResultStakedIntegralLast)
577 594      $Tuple3([IntegerEntry(userVoteStakedIntegralLastKey, userVoteStakedIntegral), IntegerEntry(votingResultStakedIntegralLastKey, votingResultStakedIntegral)], userVoteStakedIntegralDiff, votingResultStakedIntegralDiff)
578 595      }
579 596  
580 597  
581 598  func refreshBoostEmissionIntegral () = {
582 -     let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
599 +     let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
583 600      let boostingV2LastUpdateHeightOption = getInteger(this, keyBoostingV2LastUpdateHeight())
584 601      let boostingV2IngergalOption = getInteger(this, keyBoostingV2Integral())
585 -     let emissionEnd = getIntOrFail(emissionContract, keyEmissionEndBlock())
602 +     let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
586 603      let h = if ((height > emissionEnd))
587 604          then emissionEnd
588 605          else height
589 606      let dh =     match boostingV2LastUpdateHeightOption {
590 607          case lastUpdateHeight: Int => 
591 608              max([(h - lastUpdateHeight), 0])
592 609          case _: Unit => 
593 610              0
594 611          case _ => 
595 612              throw("Match error")
596 613      }
597 614      let boostEmissionPerBlock = ((wxEmissionPerBlock * (boostCoeff - 1)) / boostCoeff)
598 615      let boostEmissionIntegralPrev = valueOrElse(boostingV2IngergalOption, 0)
599 616      let boostEmissionIntegral = ((boostEmissionPerBlock * dh) + boostEmissionIntegralPrev)
600 617      $Tuple2([IntegerEntry(keyBoostingV2Integral(), boostEmissionIntegral), IntegerEntry(keyBoostingV2LastUpdateHeight(), height)], boostEmissionIntegral)
601 618      }
602 619  
603 620  
604 621  func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
605 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
606 -     let userNum = userNumberByAddressOrFail(userAddress)
607 -     if ((userNum == userNum))
608 -         then {
622 +     let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
623 +     if ((userRecordOption == unit))
624 +         then $Tuple3(0, nil, "userRecord::is::empty")
625 +         else {
626 +             let userRecordArray = split(value(userRecordOption), SEP)
627 +             let userNumStr = userRecordArray[IdxLockUserNum]
609 628              let EMPTYSTR = "empty"
610 629              let poolWeight = if ((lpAssetIdStr != EMPTYSTR))
611 630                  then {
612 631                      let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
613 632                      getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
614 633                      }
615 634                  else if (readOnly)
616 635                      then 0
617 636                      else throwErr(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
618 -             let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNum, lpAssetIdStr)
619 -             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNum)
620 -             let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), getIntOrZero(this, userBoostEmissionLastIntegralKEY))
637 +             let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
638 +             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
639 +             let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), ioz(this, userBoostEmissionLastIntegralKEY))
621 640              let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
622 641              let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
623 642              if ((0 > userBoostEmissionIntegral))
624 643                  then throwErr("wrong calculations")
625 644                  else {
626 -                     let $t02420824347 = getStakedVotesIntegralsDiff(lpAssetIdStr, userAddressStr)
627 -                     let stakedVotesIntegralsActions = $t02420824347._1
628 -                     let userVoteIntegralDiff = $t02420824347._2
629 -                     let totalVotesIntegralDiff = $t02420824347._3
645 +                     let $t02642026559 = getStakedVotesIntegralsDiff(lpAssetIdStr, userAddressStr)
646 +                     let stakedVotesIntegralsActions = $t02642026559._1
647 +                     let userVoteIntegralDiff = $t02642026559._2
648 +                     let totalVotesIntegralDiff = $t02642026559._3
630 649                      let poolUserBoostEmissionIntegral = fraction(userBoostEmissionIntegral, poolWeight, POOLWEIGHTMULT)
631 650                      let userBoostAvaliableToClaimTotalNew = if ((totalVotesIntegralDiff == 0))
632 651                          then 0
633 652                          else fraction(poolUserBoostEmissionIntegral, userVoteIntegralDiff, totalVotesIntegralDiff)
634 653                      let dataState = ([IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)] ++ stakedVotesIntegralsActions)
635 654                      let debug = makeString([toString(userBoostEmissionLastIntegral), toString(userBoostEmissionIntegral), toString(poolWeight), toString(userVoteIntegralDiff), toString(totalVotesIntegralDiff)], ":")
636 655                      $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
637 656                      }
638 657              }
639 -         else throw("Strict value is not equal to itself.")
640 658      }
641 659  
642 660  
643 - func lockActions (i,durationMonths) = if (!(containsElement(durationMonthsAllowed, durationMonths)))
644 -     then throwErr("invalid duration")
645 -     else {
646 -         let duration = (durationMonths * blocksInMonth)
647 -         let assetIdStr = toBase58String(assetId)
648 -         if ((size(i.payments) != 1))
649 -             then throwErr("invalid payment - exact one payment must be attached")
650 -             else {
651 -                 let pmt = i.payments[0]
652 -                 let pmtAmount = pmt.amount
653 -                 if ((assetId != value(pmt.assetId)))
654 -                     then throwErr((("invalid asset is in payment - " + assetIdStr) + " is expected"))
655 -                     else {
656 -                         let nextUserNumKEY = keyNextUserNum()
657 -                         let userAddress = i.caller
658 -                         let userAddressStr = toString(userAddress)
659 -                         let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
660 -                         let userNumStr = if (userIsExisting)
661 -                             then value(getString(keyUser2NumMapping(userAddressStr)))
662 -                             else toString(getIntOrFail(this, nextUserNumKEY))
663 -                         let userNum = parseIntValue(userNumStr)
664 -                         let lockStart = height
665 -                         if (if ((minLockAmount > pmtAmount))
666 -                             then (userAddress != lpStakingPoolsContract)
667 -                             else false)
668 -                             then throwErr(("amount is less then minLockAmount=" + toString(minLockAmount)))
669 -                             else if ((minLockDuration > duration))
670 -                                 then throwErr(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
671 -                                 else if ((duration > maxLockDuration))
672 -                                     then throwErr(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
673 -                                     else {
674 -                                         let gWxAmountStart = fraction(pmtAmount, duration, maxLockDuration)
675 -                                         let gwxAmountTotal = getGwxAmountTotal()
676 -                                         let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNum)
677 -                                         let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
678 -                                         let userGwxAmountTotal = getUserGwxAmountTotal(userAddress)
679 -                                         let gwxRewardInv = reentrantInvoke(gwxRewardContract, "refreshUserReward", [userAddress.bytes], nil)
680 -                                         if ((gwxRewardInv == gwxRewardInv))
681 -                                             then {
682 -                                                 let arr = if (userIsExisting)
683 -                                                     then nil
684 -                                                     else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
685 -                                                 $Tuple2(((((arr ++ LockParamsEntry(userAddress, i.transactionId, pmtAmount, lockStart, duration, gWxAmountStart, 0)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
686 -                                                     then 0
687 -                                                     else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, gWxAmountStart, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(keyGwxTotal(), (gwxAmountTotal + gWxAmountStart)), IntegerEntry(keyUserGwxAmountTotal(userAddress), (userGwxAmountTotal + gWxAmountStart))]), gWxAmountStart)
688 -                                                 }
689 -                                             else throw("Strict value is not equal to itself.")
690 -                                         }
691 -                         }
692 -                 }
693 -         }
694 - 
695 - 
696 - func getWxWithdrawable (userAddress,txIdOption) = {
697 -     let userRecordArray = readLockParamsRecordOrFail(userAddress, txIdOption)
698 -     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
699 -     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
700 -     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
701 -     let lockEnd = (lockStart + lockDuration)
702 -     let wxClaimed = parseIntValue(userRecordArray[IdxLockWxClaimed])
703 -     let t = ((height - lockStart) / blocksInPeriod)
704 -     let exponent = fraction(toBigInt(t), (toBigInt((8 * blocksInPeriod)) * MULT18BI), toBigInt(lockDuration))
705 -     let wxWithdrawable = if ((height > lockEnd))
706 -         then userAmount
707 -         else (toInt(fraction(toBigInt(userAmount), (MULT18BI - pow(toBigInt(5), 1, exponent, SCALE18, SCALE18, DOWN)), MULT18BI)) - wxClaimed)
708 -     wxWithdrawable
661 + func lockActions (i,duration) = {
662 +     let cfgArray = readConfigArrayOrFail()
663 +     let assetIdStr = cfgArray[IdxCfgAssetId]
664 +     let assetId = fromBase58String(assetIdStr)
665 +     let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
666 +     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
667 +     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
668 +     if ((size(i.payments) != 1))
669 +         then throwErr("invalid payment - exact one payment must be attached")
670 +         else {
671 +             let pmt = i.payments[0]
672 +             let pmtAmount = pmt.amount
673 +             if ((assetId != value(pmt.assetId)))
674 +                 then throwErr((("invalid asset is in payment - " + assetIdStr) + " is expected"))
675 +                 else {
676 +                     let nextUserNumKEY = keyNextUserNum()
677 +                     let userAddressStr = toString(i.caller)
678 +                     let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
679 +                     let userNumStr = if (userIsExisting)
680 +                         then value(getString(keyUser2NumMapping(userAddressStr)))
681 +                         else toString(iof(this, nextUserNumKEY))
682 +                     let userNum = parseIntValue(userNumStr)
683 +                     let lockStart = height
684 +                     let startBlockKEY = keyLockParamStartBlock(userNumStr)
685 +                     let durationKEY = keyLockParamDuration(userNumStr)
686 +                     let userAmountKEY = keyLockParamUserAmount(userNumStr)
687 +                     if (if ((minLockAmount > pmtAmount))
688 +                         then (i.caller != lpStakingPoolsContract)
689 +                         else false)
690 +                         then throwErr(("amount is less then minLockAmount=" + toString(minLockAmount)))
691 +                         else if ((minLockDuration > duration))
692 +                             then throwErr(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
693 +                             else if ((duration > maxLockDuration))
694 +                                 then throwErr(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
695 +                                 else if (if (userIsExisting)
696 +                                     then ((iof(this, startBlockKEY) + iof(this, durationKEY)) >= lockStart)
697 +                                     else false)
698 +                                     then throwErr("there is an active lock - consider to use increaseLock")
699 +                                     else if ((ioz(this, userAmountKEY) > 0))
700 +                                         then throwErr(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
701 +                                         else {
702 +                                             let coeffX8 = fraction(duration, MULT8, maxLockDuration)
703 +                                             let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
704 +                                             let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStart, duration], nil))
705 +                                             let k = ai(gWxParamsResultList[0])
706 +                                             let b = ai(gWxParamsResultList[1])
707 +                                             let period = toString(ai(gWxParamsResultList[2]))
708 +                                             let totalCachedGwxRaw = getTotalCachedGwx(false)
709 +                                             let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
710 +                                             let boostEmissionIntegral = refreshBoostEmissionIntegral()._2
711 +                                             let arr = if (userIsExisting)
712 +                                                 then nil
713 +                                                 else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
714 +                                             $Tuple2(((((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
715 +                                                 then 0
716 +                                                 else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gWxAmountStart))]), gWxAmountStart)
717 +                                             }
718 +                     }
719 +             }
709 720      }
710 721  
711 722  
712 723  @Callable(i)
713 724  func constructor (factoryAddressStr,lockAssetIdStr,minLockAmount,minDuration,maxDuration,mathContract) = {
714 725      let checkCaller = mustManager(i)
715 726      if ((checkCaller == checkCaller))
716 727          then ([IntegerEntry(keyNextUserNum(), 0), StringEntry(keyConfig(), formatConfig(lockAssetIdStr, minLockAmount, minDuration, maxDuration, mathContract)), StringEntry(keyFactoryAddress(), factoryAddressStr)] ++ StatsEntry(0, 0, 0, 0))
717 728          else throw("Strict value is not equal to itself.")
718 729      }
719 730  
720 731  
721 732  
722 733  @Callable(i)
723 734  func lockRef (duration,referrerAddress,signature) = {
724 -     let $t02914629211 = lockActions(i, duration)
725 -     let lockActionsResult = $t02914629211._1
726 -     let gWxAmountStart = $t02914629211._2
735 +     let $t03117031235 = lockActions(i, duration)
736 +     let lockActionsResult = $t03117031235._1
737 +     let gWxAmountStart = $t03117031235._2
727 738      let referralAddress = toString(i.caller)
728 739      let refInv = if (if ((referrerAddress == ""))
729 740          then true
730 741          else (signature == base58''))
731 742          then unit
732 743          else invoke(referralsContractAddressOrFail, "createPair", [referralProgramName, referrerAddress, referralAddress, signature], nil)
733 744      if ((refInv == refInv))
734 745          then {
735 746              let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
736 747              if ((updateRefActivity == updateRefActivity))
737 748                  then $Tuple2(lockActionsResult, unit)
738 749                  else throw("Strict value is not equal to itself.")
739 750              }
740 751          else throw("Strict value is not equal to itself.")
741 752      }
742 753  
743 754  
744 755  
745 756  @Callable(i)
746 757  func lock (duration) = {
747 -     let $t02966929734 = lockActions(i, duration)
748 -     let lockActionsResult = $t02966929734._1
749 -     let gWxAmountStart = $t02966929734._2
758 +     let $t03169331758 = lockActions(i, duration)
759 +     let lockActionsResult = $t03169331758._1
760 +     let gWxAmountStart = $t03169331758._2
750 761      let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
751 762      if ((updateRefActivity == updateRefActivity))
752 763          then $Tuple2(lockActionsResult, unit)
753 764          else throw("Strict value is not equal to itself.")
754 765      }
755 766  
756 767  
757 768  
758 769  @Callable(i)
770 + func increaseLock (deltaDuration) = {
771 +     let cfgArray = readConfigArrayOrFail()
772 +     let assetIdStr = cfgArray[IdxCfgAssetId]
773 +     let assetId = fromBase58String(assetIdStr)
774 +     let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
775 +     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
776 +     let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
777 +     let userAddressStr = toString(i.caller)
778 +     let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
779 +     let userNumStr = userRecordArray[IdxLockUserNum]
780 +     let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
781 +     let lockStart = parseIntValue(userRecordArray[IdxLockStart])
782 +     let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
783 +     let lockEnd = (lockStart + lockDuration)
784 +     let remainingDuration = max([(lockEnd - height), 0])
785 +     let userAmountNew = (userAmount + pmtAmount)
786 +     let lockDurationNew = (remainingDuration + deltaDuration)
787 +     if ((0 > deltaDuration))
788 +         then throwErr("duration is less then zero")
789 +         else if ((minLockDuration > lockDurationNew))
790 +             then throwErr(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
791 +             else if ((lockDurationNew > maxLockDuration))
792 +                 then throwErr(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
793 +                 else {
794 +                     let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
795 +                     let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
796 +                     let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
797 +                     if ((updateRefActivity == updateRefActivity))
798 +                         then {
799 +                             let lockStartNew = height
800 +                             let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStartNew, lockDurationNew], nil))
801 +                             let k = ai(gWxParamsResultList[0])
802 +                             let b = ai(gWxParamsResultList[1])
803 +                             let period = toString(ai(gWxParamsResultList[2]))
804 +                             let currUserGwx = calcCurrentGwxAmount(userAddressStr)
805 +                             let gwxDiff = (gWxAmountStart - currUserGwx)
806 +                             if ((0 > gwxDiff))
807 +                                 then throwErr(("gwxDiff is less then 0: " + toString(gwxDiff)))
808 +                                 else {
809 +                                     let totalCachedGwxRaw = getTotalCachedGwx(false)
810 +                                     let totalCachedGwxCorrected = getTotalCachedGwx(true)
811 +                                     (((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))])
812 +                                     }
813 +                             }
814 +                         else throw("Strict value is not equal to itself.")
815 +                     }
816 +     }
817 + 
818 + 
819 + 
820 + @Callable(i)
759 821  func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
760 822      then throwErr("permissions denied")
761 823      else {
762 -         let $t03004430146 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
763 -         let userBoostAvailable = $t03004430146._1
764 -         let dataState = $t03004430146._2
765 -         let debug = $t03004430146._3
824 +         let $t03486334965 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
825 +         let userBoostAvailable = $t03486334965._1
826 +         let dataState = $t03486334965._2
827 +         let debug = $t03486334965._3
766 828          $Tuple2(dataState, [userBoostAvailable])
767 829          }
768 830  
769 831  
770 832  
771 833  @Callable(i)
772 834  func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
773 -     let $t03027830379 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
774 -     let userBoostAvailable = $t03027830379._1
775 -     let dataState = $t03027830379._2
776 -     let debug = $t03027830379._3
835 +     let $t03509735198 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
836 +     let userBoostAvailable = $t03509735198._1
837 +     let dataState = $t03509735198._2
838 +     let debug = $t03509735198._3
777 839      $Tuple2(nil, [userBoostAvailable, debug])
778 840      }
779 841  
780 842  
781 843  
782 844  @Callable(i)
783 - func unlock (txIdStr) = {
784 -     let userAddress = i.caller
785 -     let userAddressStr = toString(userAddress)
786 -     let txId = fromBase58String(txIdStr)
787 -     let userRecordArray = readLockParamsRecordOrFail(userAddress, if ((txIdStr == ""))
788 -         then unit
789 -         else txId)
845 + func unlock (userAddress) = {
846 +     let userRecordArray = readLockParamsRecordOrFail(userAddress)
847 +     let userNumStr = userRecordArray[IdxLockUserNum]
790 848      let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
791 849      let lockStart = parseIntValue(userRecordArray[IdxLockStart])
792 850      let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
793 -     let wxClaimed = parseIntValue(userRecordArray[IdxLockWxClaimed])
794 -     let gwxAmount = parseIntValue(userRecordArray[IdxLockGwxAmount])
795 -     let t = ((height - lockStart) / blocksInPeriod)
796 -     let wxWithdrawable = getWxWithdrawable(userAddress, if ((txIdStr == ""))
797 -         then unit
798 -         else txId)
799 -     let gWxAmountStart = fraction(userAmount, lockDuration, maxLockDuration)
800 -     let gwxBurned = min([fraction((t * blocksInPeriod), gWxAmountStart, maxLockDuration), gwxAmount])
801 -     let gwxRemaining = ensurePositive((gwxAmount - gwxBurned), "gwxRemaining")
802 -     let lockedGwxAmount = getLockedGwxAmount(userAddress)
803 -     if ((0 >= userAmount))
804 -         then throwErr("nothing to unlock")
851 +     let lockEnd = (lockStart + lockDuration)
852 +     let cfgArray = readConfigArrayOrFail()
853 +     let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
854 +     if ((lockEnd >= height))
855 +         then throwErr((("wait " + toString(lockEnd)) + " to unlock"))
856 +         else if ((0 >= userAmount))
857 +             then throwErr("nothing to unlock")
858 +             else {
859 +                 let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
860 +                 (((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))
861 +                 }
862 +     }
863 + 
864 + 
865 + 
866 + @Callable(i)
867 + func gwxUserInfoREADONLY (userAddress) = {
868 +     let gwxAmount = calcCurrentGwxAmount(userAddress)
869 +     $Tuple2(nil, [gwxAmount])
870 +     }
871 + 
872 + 
873 + 
874 + @Callable(i)
875 + func userMaxDurationREADONLY (userAddressStr) = {
876 +     let cfgArray = readConfigArrayOrFail()
877 +     let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
878 +     let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
879 +     if ((userRecordOption == unit))
880 +         then $Tuple2(nil, $Tuple2("lock", maxLockDuration))
805 881          else {
806 -             let gwxAmountTotal = getGwxAmountTotal()
807 -             let userGwxAmountTotal = getUserGwxAmountTotal(userAddress)
808 -             let userGwxAmountTotalNew = ensurePositive((userGwxAmountTotal - gwxBurned), "userGwxAmountTotalNew")
809 -             if ((lockedGwxAmount > userGwxAmountTotalNew))
810 -                 then throwErr(("locked gwx amount: " + toString(lockedGwxAmount)))
811 -                 else {
812 -                     let gwxRewardInv = reentrantInvoke(gwxRewardContract, "refreshUserReward", [userAddress.bytes], nil)
813 -                     if ((gwxRewardInv == gwxRewardInv))
814 -                         then ((((LockParamsEntry(userAddress, txId, userAmount, lockStart, lockDuration, gwxRemaining, (wxClaimed + wxWithdrawable)) ++ StatsEntry(-(wxWithdrawable), 0, 0, 0)) :+ HistoryEntry("unlock", userAddressStr, wxWithdrawable, lockStart, lockDuration, gwxBurned, i)) :+ ScriptTransfer(userAddress, wxWithdrawable, assetId)) ++ [IntegerEntry(keyGwxTotal(), ensurePositive((gwxAmountTotal - gwxBurned), "gwxTotal")), IntegerEntry(keyUserGwxAmountTotal(userAddress), userGwxAmountTotalNew)])
815 -                         else throw("Strict value is not equal to itself.")
816 -                     }
882 +             let userRecordArray = split(value(userRecordOption), SEP)
883 +             let lockStart = parseIntValue(userRecordArray[IdxLockStart])
884 +             let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
885 +             let lockEnd = (lockStart + lockDuration)
886 +             let remainingDuration = max([(lockEnd - height), 0])
887 +             let maxDeltaDuration = (maxLockDuration - remainingDuration)
888 +             $Tuple2(nil, $Tuple2("increaseLock", maxDeltaDuration))
817 889              }
818 890      }
819 891  
820 892  
821 893  
822 894  @Callable(i)
823 - func gwxUserInfoREADONLY (userAddressStr) = {
824 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
825 -     let gwxAmount = getUserGwxAmountTotal(userAddress)
826 -     $Tuple2(nil, [gwxAmount])
827 -     }
828 - 
829 - 
830 - 
831 - @Callable(i)
832 - func userMaxDurationREADONLY (userAddressStr) = $Tuple2(nil, $Tuple2("increaseLock", maxLockDuration))
833 - 
834 - 
835 - 
836 - @Callable(i)
837 - func getUserGwxAmountAtHeightREADONLY (userAddressStr,targetHeight) = {
838 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
839 -     let gwxAmount = getUserGwxAmountTotal(userAddress)
895 + func getUserGwxAmountAtHeightREADONLY (userAddress,targetHeight) = {
896 +     let gwxAmount = calcUserGwxAmountAtHeight(userAddress, targetHeight)
840 897      $Tuple2(nil, gwxAmount)
841 898      }
842 899  
843 900  
844 901  
845 902  @Callable(i)
846 - func getUserGwxAmount (userAddressStr) = {
847 -     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
848 -     let gwxAmount = getUserGwxAmountTotal(userAddress)
849 -     $Tuple2(nil, gwxAmount)
850 -     }
851 - 
852 - 
853 - 
854 - @Callable(i)
855 - func getGwxTotalREADONLY () = $Tuple2(nil, getGwxAmountTotal())
903 + func getTotalCachedGwxREADONLY () = $Tuple2(nil, getTotalCachedGwx(true))
856 904  
857 905  
858 906  
859 907  @Callable(i)
860 908  func onBoostEmissionUpdate () = {
861 909      let checkCaller = if ((i.caller == emissionContract))
862 910          then true
863 911          else mustManager(i)
864 912      if ((checkCaller == checkCaller))
865 913          then refreshBoostEmissionIntegral()
866 914          else throw("Strict value is not equal to itself.")
867 915      }
868 916  
869 917  
870 918  
871 919  @Callable(i)
872 920  func onStakedVoteUpdate (lpAssetIdStr,userAddressStr,edge) = {
873 921      let checkCaller = if ((i.caller == stakingContract))
874 922          then true
875 923          else mustManager(i)
876 924      if ((checkCaller == checkCaller))
877 925          then {
878 926              let actions = refreshVoteStakedIntegral(lpAssetIdStr, userAddressStr, edge)
879 927              $Tuple2(actions, unit)
880 928              }
881 929          else throw("Strict value is not equal to itself.")
882 930      }
883 931  
884 932  
885 933  
886 934  @Callable(i)
887 935  func getVotingResultStakedREADONLY (lpAssetIdStr) = $Tuple2(nil, getVotingResultStaked(lpAssetIdStr))
888 936  
889 937  
890 938  
891 939  @Callable(i)
892 940  func getVotingResultStakedIntegralREADONLY (lpAssetIdStr) = $Tuple2(nil, getVotingResultStakedIntegral(lpAssetIdStr))
893 941  
894 942  
895 943  
896 944  @Callable(i)
897 945  func getUserVoteFinalizedREADONLY (lpAssetIdStr,userAddressStr) = $Tuple2(nil, getUserVoteFinalized(lpAssetIdStr, userAddressStr))
898 946  
899 947  
900 948  
901 949  @Callable(i)
902 950  func getUserVoteStakedIntegralREADONLY (lpAssetIdStr,userAddressStr) = $Tuple2(nil, getUserVoteStakedIntegral(lpAssetIdStr, userAddressStr))
903 951  
904 952  
905 953  @Verifier(tx)
906 954  func verify () = {
907 955      let targetPublicKey =     match managerPublicKeyOrUnit() {
908 956          case pk: ByteVector => 
909 957              pk
910 958          case _: Unit => 
911 959              tx.senderPublicKey
912 960          case _ => 
913 961              throw("Match error")
914 962      }
915 963      sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
916 964      }
917 965

Old	New		Differences
9	9
10	10		let POOLWEIGHTMULT = MULT8
11	11
12		-	let contractFilename = "boosting.ride"
13		-
14		-	let SCALE18 = 18
15		-
16		-	let MULT18 = 1000000000000000000
17		-
18		-	let MULT18BI = toBigInt(MULT18)
19		-
20		-	let durationMonthsAllowed = [1, 3, 6, 12, 24, 48]
21		-
22		-	let blocksInDay = 1440
23		-
24		-	let blocksInMonth = 43800
25		-
26		-	func wrapErr (msg) = makeString([contractFilename, ": ", msg], "")
	12	+	func wrapErr (msg) = makeString(["boosting.ride:", msg], " ")
27	13
28	14
29	15		func throwErr (msg) = throw(wrapErr(msg))
30	16
31	17
32		-	func ~~getStringOrFail~~ (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
	18	+	func strf (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
33	19
34	20
35		-	func ~~getIntOrZero~~ (address,key) = valueOrElse(getInteger(address, key), 0)
	21	+	func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
36	22
37	23
38		-	func ~~getIntOrDefault~~ (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
	24	+	func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
39	25
40	26
41		-	func ~~getIntOrFail~~ (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
	27	+	func iof (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
42	28
43	29
44	30		func abs (val) = if ((0 > val))

46	32		else val
47	33
48	34
49		-	func ensurePositive (v,m) = if ((v >= 0))
50		-	then v
51		-	else throwErr((valueOrElse(m, "value") + " should be positive"))
	35	+	func aal (val) = match val {
	36	+	case valAnyLyst: List[Any] =>
	37	+	valAnyLyst
	38	+	case _ =>
	39	+	throwErr("fail to cast into List[Any]")
	40	+	}
	41	+
	42	+
	43	+	func ai (val) = match val {
	44	+	case valInt: Int =>
	45	+	valInt
	46	+	case _ =>
	47	+	throwErr("fail to cast into Int")
	48	+	}
52	49
53	50
54	51		func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
55	52
56	53
57		-	let referralsContractAddressOrFail = addressFromStringValue(~~getStringOrFail~~(this, keyReferralsContractAddress()))
	54	+	let referralsContractAddressOrFail = addressFromStringValue(strf(this, keyReferralsContractAddress()))
58	55
59	56		let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
60	57

90	87		func keyFactoryCfg () = "%s__factoryConfig"
91	88
92	89
	90	+	func keyFactoryLpList () = "%s__lpTokensList"
	91	+
	92	+
93	93		func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
94	94
95	95

99	99		func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
100	100
101	101
102		-	func readFactoryAddressOrFail () = addressFromStringValue(~~getStringOrFail~~(this, keyFactoryAddress()))
	102	+	func readFactoryAddressOrFail () = addressFromStringValue(strf(this, keyFactoryAddress()))
103	103
104	104
105		-	func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
	105	+	func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
	106	+
	107	+
	108	+	func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
106	109
107	110
108	111		func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])

144	147		func keyEmissionEndBlock () = "%s%s__emission__endBlock"
145	148
146	149
	150	+	func keyNextPeriod () = "%s__nextPeriod"
	151	+
	152	+
	153	+	func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
	154	+
	155	+
147	156		let IdxCfgAssetId = 1
148	157
149	158		let IdxCfgMinLockAmount = 2

154	163
155	164		let IdxCfgMathContract = 5
156	165
157		-	let IdxCfgBlocksInPeriod = 6
158		-
159	166		func keyConfig () = "%s__config"
160	167
161	168
162		-	func readConfigArrayOrFail () = split(~~getStringOrFail~~(this, keyConfig()), SEP)
	169	+	func readConfigArrayOrFail () = split(strf(this, keyConfig()), SEP)
163	170
164	171
165		-	let ~~cfgArray~~ = readConfigArrayOrFail()
	172	+	let mathContract = addressFromStringValue(readConfigArrayOrFail()[IdxCfgMathContract])
166	173
167		-	let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
168		-
169		-	let minLockAmount = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockAmount]), wrapErr("invalid min lock amount"))
170		-
171		-	let minLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockDuration]), wrapErr("invalid min lock duration"))
172		-
173		-	let maxLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMaxLockDuration]), wrapErr("invalid max lock duration"))
174		-
175		-	let mathContract = valueOrErrorMessage(addressFromString(cfgArray[IdxCfgMathContract]), wrapErr("invalid math contract address"))
176		-
177		-	let blocksInPeriod = valueOrErrorMessage(parseInt(cfgArray[IdxCfgBlocksInPeriod]), wrapErr("invalid blocks in period"))
178		-
179		-	func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d%s", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
	174	+	func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
180	175
181	176
182	177		func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)

220	215		}
221	216
222	217
223		-	let ~~IdxLockAmount~~ = 1
	218	+	let IdxLockUserNum = 1
224	219
225		-	let ~~IdxLockStart~~ = 2
	220	+	let IdxLockAmount = 2
226	221
227		-	let ~~IdxLockDuration~~ = 3
	222	+	let IdxLockStart = 3
228	223
229		-	let ~~IdxLockLastUpdateTimestamp~~ = 4
	224	+	let IdxLockDuration = 4
230	225
231		-	let ~~IdxLockGwxAmount~~ = 5
	226	+	let IdxLockParamK = 5
232	227
233		-	let ~~IdxLockWxClaimed~~ = 6
	228	+	let IdxLockParamB = 6
234	229
235		-	func keyLockParamsRecord (userAddress,txId) = makeString(["%s%s%s__lock", toString(userAddress), match txId {
236		-	case b: ByteVector =>
237		-	toBase58String(b)
238		-	case _: Unit =>
239		-	"legacy"
240		-	case _ =>
241		-	throw("Match error")
242		-	}], SEP)
	230	+	func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
243	231
244	232
245		-	func readLockParamsRecordOrFail (userAddress~~,txId~~) = split(~~getStringOrFail~~(this, keyLockParamsRecord(userAddress~~, txId~~)), SEP)
	233	+	func readLockParamsRecordOrFail (userAddress) = split(strf(this, keyLockParamsRecord(userAddress)), SEP)
246	234
247	235
248		-	func ~~keyUserGwxAmountTotal~~ (~~userAddress~~) = makeString(["%s%~~s__gwxAmountTotal~~", ~~toString(userAddress)~~], SEP)
	236	+	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)
249	237
250	238
251		-	func formatLockParamsRecord (amount,start,duration,gwxAmount~~,wxClaimed~~) = ~~makeString~~(~~["%d%d%d%d%d%d"~~, toString(amount), toString(start), toString(duration), toString(lastBlock.timestamp), toString(gwxAmount)~~, toString(wxClaimed~~)~~], SEP)~~
	239	+	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))
252	240
253	241
254	242		func keyNextUserNum () = "%s__nextUserNum"

258	246
259	247
260	248		func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
	249	+
	250	+
	251	+	func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
	252	+
	253	+
	254	+	func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
	255	+
	256	+
	257	+	func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
	258	+
	259	+
	260	+	func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
	261	+
	262	+
	263	+	func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
	264	+
	265	+
	266	+	func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
	267	+
	268	+
	269	+	func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
261	270
262	271
263	272		func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"

272	281		func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
273	282
274	283
275		-	func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", ~~toString(~~userNum)], SEP)
	284	+	func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum], SEP)
276	285
277	286
278		-	func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", ~~toString(~~userNum), lpAssetId], SEP)
	287	+	func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum, lpAssetId], SEP)
279	288
280	289
281		-	func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", ~~toString(~~userNum)], SEP)
	290	+	func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
282	291
283	292
284	293		func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
285	294
286	295
287		-	func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", ~~toString(~~userNum)], SEP)
	296	+	func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
288	297
289	298
290		-	func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", ~~toString(~~userNum)], SEP)
	299	+	func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
291	300
292	301
293		-	func keyGwxTotal () = "%s%s__gwx__total"
	302	+	func keyTotalCachedGwx () = "%s%s__gwxCached__total"
	303	+
	304	+
	305	+	func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
294	306
295	307
296	308		func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)

342	354
343	355		let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
344	356
345		-	let keyVotingEmissionRateContract = makeString(["%s", "votingEmissionRateContract"], SEP)
346		-
347	357		let boostCoeff = {
348	358		let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
349	359		if ($isInstanceOf(@, "Int"))

351	361		else throw(($getType(@) + " couldn't be cast to Int"))
352	362		}
353	363
354		-	func userNumberByAddressOrFail (userAddress) = match getString(this, keyUser2NumMapping(toString(userAddress))) {
355		-	case s: String =>
356		-	valueOrErrorMessage(parseInt(s), wrapErr("invalid user number"))
357		-	case _: Unit =>
358		-	throwErr("invalid user")
359		-	case _ =>
360		-	throw("Match error")
361		-	}
362		-
363		-
364		-	func getGwxAmountTotal () = valueOrElse(getInteger(this, keyGwxTotal()), 0)
365		-
366		-
367		-	func getLockedGwxAmount (userAddress) = {
368		-	let functionName = "getLockedGwxAmount"
369		-	let votingEmissionRateContract = valueOrErrorMessage( match getString(votingEmissionContract, keyVotingEmissionRateContract) {
370		-	case _: Unit =>
371		-	unit
372		-	case s: String =>
373		-	addressFromString(s)
374		-	case _ =>
375		-	throw("Match error")
376		-	}, wrapErr("invalid voting emission rate address"))
377		-	let lockedVotingEmissionRate = {
378		-	let @ = invoke(votingEmissionContract, functionName, [toString(userAddress)], nil)
379		-	if ($isInstanceOf(@, "Int"))
380		-	then @
381		-	else throw(($getType(@) + " couldn't be cast to Int"))
382		-	}
383		-	let lockedVotingEmission = {
384		-	let @ = invoke(votingEmissionRateContract, functionName, [toString(userAddress)], nil)
385		-	if ($isInstanceOf(@, "Int"))
386		-	then @
387		-	else throw(($getType(@) + " couldn't be cast to Int"))
388		-	}
389		-	let locked = max([lockedVotingEmissionRate, lockedVotingEmission])
390		-	locked
	364	+	func getTotalCachedGwx (correct) = {
	365	+	let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi())
	366	+	let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
	367	+	let targetEpochOption = getInteger(this, keyTargetEpoch)
	368	+	let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
	369	+	let isCorrectionActivated = if (isDefined(targetEpochOption))
	370	+	then (currentEpochUi >= value(targetEpochOption))
	371	+	else false
	372	+	let corrective = if (if (isCorrectionActivated)
	373	+	then correct
	374	+	else false)
	375	+	then valueOrElse(getInteger(this, keyTotalCachedGwxCorrective()), 0)
	376	+	else 0
	377	+	max([0, (totalCachedGwxRaw + corrective)])
391	378		}
392	379
393	380
394		-	func HistoryEntry (type,user,amount,lockStart,duration,~~gwxAmount~~,i) = {
	381	+	func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
395	382		let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
396		-	let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(~~gwxAmount~~)], SEP)
	383	+	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)
397	384		StringEntry(historyKEY, historyDATA)
398	385		}
399	386

403	390		let locksCountKEY = keyStatsLocksCount()
404	391		let usersCountKEY = keyStatsUsersCount()
405	392		let totalAmountKEY = keyLockParamTotalAmount()
406		-	let locksDurationSumInBlocks = ~~getIntOrZero~~(this, locksDurationSumInBlocksKEY)
407		-	let locksCount = ~~getIntOrZero~~(this, locksCountKEY)
408		-	let usersCount = ~~getIntOrZero~~(this, usersCountKEY)
409		-	let totalAmount = ~~getIntOrZero~~(this, totalAmountKEY)
	393	+	let locksDurationSumInBlocks = ioz(this, locksDurationSumInBlocksKEY)
	394	+	let locksCount = ioz(this, locksCountKEY)
	395	+	let usersCount = ioz(this, usersCountKEY)
	396	+	let totalAmount = ioz(this, totalAmountKEY)
410	397		[IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
411	398		}
412	399
413	400
414		-	func LockParamsEntry (userAddress,txId,amount,start,duration,gwxAmount,wxClaimed) = [StringEntry(keyLockParamsRecord(userAddress, txId), formatLockParamsRecord(amount, start, duration, gwxAmount, wxClaimed))]
	401	+	func calcGwxAmount (kRaw,bRaw,h) = {
	402	+	let SCALE = 1000
	403	+	(((kRaw * h) + bRaw) / SCALE)
	404	+	}
	405	+
	406	+
	407	+	func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
	408	+	let userAmountKEY = keyLockParamUserAmount(userNum)
	409	+	let startBlockKEY = keyLockParamStartBlock(userNum)
	410	+	let durationKEY = keyLockParamDuration(userNum)
	411	+	let kKEY = keyLockParamK(userNum)
	412	+	let bKEY = keyLockParamB(userNum)
	413	+	let kByPeriodKEY = keyLockParamByPeriodK(userNum, period)
	414	+	let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
	415	+	let gwxAmount = calcGwxAmount(k, b, height)
	416	+	[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))]
	417	+	}
415	418
416	419
417	420		func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))

426	429		}
427	430
428	431
429		-	func getUserGwxAmountTotal (userAddress) = valueOrElse(getInteger(this, keyUserGwxAmountTotal(userAddress)), 0)
	432	+	func calcUserGwxAmountAtHeight (userAddress,targetHeight) = {
	433	+	let EMPTY = "empty"
	434	+	let user2NumMappingKEY = keyUser2NumMapping(userAddress)
	435	+	let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
	436	+	let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
	437	+	let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
	438	+	let gwxAmountCalc = calcGwxAmount(k, b, targetHeight)
	439	+	let gwxAmount = if ((0 > gwxAmountCalc))
	440	+	then 0
	441	+	else gwxAmountCalc
	442	+	gwxAmount
	443	+	}
	444	+
	445	+
	446	+	func calcCurrentGwxAmount (userAddress) = calcUserGwxAmountAtHeight(userAddress, height)
430	447
431	448
432	449		func getVotingEmissionEpochInfo () = {
433		-	let $~~t01505115341~~ = {
	450	+	let $t01718617476 = {
434	451		let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi()))
435	452		let lastFinalizedEpoch = (currentEpochUi - 1)
436	453		if ((0 > lastFinalizedEpoch))
437	454		then throwErr("invalid epoch")
438	455		else $Tuple2(currentEpochUi, lastFinalizedEpoch)
439	456		}
440		-	let currentEpochUi = $~~t01505115341~~._1
441		-	let lastFinalizedEpoch = $~~t01505115341~~._2
	457	+	let currentEpochUi = $t01718617476._1
	458	+	let lastFinalizedEpoch = $t01718617476._2
442	459		let currentEpochStartHeight = value(getInteger(votingEmissionContract, keyStartHeightByEpoch(currentEpochUi)))
443	460		$Tuple2(lastFinalizedEpoch, currentEpochStartHeight)
444	461		}

471	488
472	489		func getUserVoteFinalized (lpAssetIdStr,userAddressStr) = {
473	490		let userAddress = addressFromStringValue(userAddressStr)
474		-	let $~~t01603216112~~ = getVotingEmissionEpochInfo()
475		-	let lastFinalizedEpoch = $~~t01603216112~~._1
476		-	let currentEpochStartHeight = $~~t01603216112~~._2
477		-	let $~~t01611516190~~ = getPoolAssetsByLpAssetId(lpAssetIdStr)
478		-	let amountAssetId = $~~t01611516190~~._1
479		-	let priceAssetId = $~~t01611516190~~._2
	491	+	let $t01816718247 = getVotingEmissionEpochInfo()
	492	+	let lastFinalizedEpoch = $t01816718247._1
	493	+	let currentEpochStartHeight = $t01816718247._2
	494	+	let $t01825018325 = getPoolAssetsByLpAssetId(lpAssetIdStr)
	495	+	let amountAssetId = $t01825018325._1
	496	+	let priceAssetId = $t01825018325._2
480	497		let userVoteKey = keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)
481	498		let userVote = valueOrElse(getInteger(votingEmissionContract, userVoteKey), 0)
482	499		userVote

493	510
494	511
495	512		func getVotingResultStaked (lpAssetIdStr) = {
496		-	let $~~t01673416814~~ = getVotingEmissionEpochInfo()
497		-	let lastFinalizedEpoch = $~~t01673416814~~._1
498		-	let currentEpochStartHeight = $~~t01673416814~~._2
	513	+	let $t01886918949 = getVotingEmissionEpochInfo()
	514	+	let lastFinalizedEpoch = $t01886918949._1
	515	+	let currentEpochStartHeight = $t01886918949._2
499	516		let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
500	517		let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
501	518		votingResultStaked

503	520
504	521
505	522		func getVotingResultStakedIntegral (lpAssetIdStr) = {
506		-	let $~~t01717617256~~ = getVotingEmissionEpochInfo()
507		-	let lastFinalizedEpoch = $~~t01717617256~~._1
508		-	let currentEpochStartHeight = $~~t01717617256~~._2
	523	+	let $t01931119391 = getVotingEmissionEpochInfo()
	524	+	let lastFinalizedEpoch = $t01931119391._1
	525	+	let currentEpochStartHeight = $t01931119391._2
509	526		let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
510	527		let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)), 0)
511	528		let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)), currentEpochStartHeight)

516	533
517	534
518	535		func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
519		-	let $~~t01809318173~~ = getVotingEmissionEpochInfo()
520		-	let lastFinalizedEpoch = $~~t01809318173~~._1
521		-	let currentEpochStartHeight = $~~t01809318173~~._2
	536	+	let $t02022820308 = getVotingEmissionEpochInfo()
	537	+	let lastFinalizedEpoch = $t02022820308._1
	538	+	let currentEpochStartHeight = $t02022820308._2
522	539		let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
523	540		let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
524	541		let votingResultStakedIntegral = getVotingResultStakedIntegral(lpAssetIdStr)

527	544
528	545
529	546		func getUserVoteStakedIntegral (lpAssetIdStr,userAddressStr) = {
530		-	let $~~t01878418864~~ = getVotingEmissionEpochInfo()
531		-	let lastFinalizedEpoch = $~~t01878418864~~._1
532		-	let currentEpochStartHeight = $~~t01878418864~~._2
	547	+	let $t02091920999 = getVotingEmissionEpochInfo()
	548	+	let lastFinalizedEpoch = $t02091920999._1
	549	+	let currentEpochStartHeight = $t02091920999._2
533	550		let userAddress = addressFromStringValue(userAddressStr)
534	551		let userVoteStaked = getUserVoteStaked(lpAssetIdStr, userAddressStr)
535	552		let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)), 0)

541	558
542	559
543	560		func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
544		-	let $~~t01965219732~~ = getVotingEmissionEpochInfo()
545		-	let lastFinalizedEpoch = $~~t01965219732~~._1
546		-	let currentEpochStartHeight = $~~t01965219732~~._2
	561	+	let $t02178721867 = getVotingEmissionEpochInfo()
	562	+	let lastFinalizedEpoch = $t02178721867._1
	563	+	let currentEpochStartHeight = $t02178721867._2
547	564		let userAddress = addressFromStringValue(userAddressStr)
548	565		let userVoteFinalized = getUserVoteFinalized(lpAssetIdStr, userAddressStr)
549	566		let actions = if ((userVoteFinalized == 0))

562	579
563	580
564	581		func getStakedVotesIntegralsDiff (lpAssetIdStr,userAddressStr) = {
565		-	let $~~t02058620666~~ = getVotingEmissionEpochInfo()
566		-	let lastFinalizedEpoch = $~~t02058620666~~._1
567		-	let currentEpochStartHeight = $~~t02058620666~~._2
	582	+	let $t02272122801 = getVotingEmissionEpochInfo()
	583	+	let lastFinalizedEpoch = $t02272122801._1
	584	+	let currentEpochStartHeight = $t02272122801._2
568	585		let userAddress = addressFromStringValue(userAddressStr)
569	586		let userVoteStakedIntegralLastKey = keyVoteStakedIntegralLast(lpAssetIdStr, userAddress, lastFinalizedEpoch)
570	587		let userVoteStakedIntegralLast = valueOrElse(getInteger(this, userVoteStakedIntegralLastKey), 0)

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let SEP = "__"
5	5
6	6		let SCALE8 = 8
7	7
8	8		let MULT8 = 100000000
9	9
10	10		let POOLWEIGHTMULT = MULT8
11	11
12		-	let contractFilename = "boosting.ride"
13		-
14		-	let SCALE18 = 18
15		-
16		-	let MULT18 = 1000000000000000000
17		-
18		-	let MULT18BI = toBigInt(MULT18)
19		-
20		-	let durationMonthsAllowed = [1, 3, 6, 12, 24, 48]
21		-
22		-	let blocksInDay = 1440
23		-
24		-	let blocksInMonth = 43800
25		-
26		-	func wrapErr (msg) = makeString([contractFilename, ": ", msg], "")
	12	+	func wrapErr (msg) = makeString(["boosting.ride:", msg], " ")
27	13
28	14
29	15		func throwErr (msg) = throw(wrapErr(msg))
30	16
31	17
32		-	func ~~getStringOrFail~~ (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
	18	+	func strf (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
33	19
34	20
35		-	func ~~getIntOrZero~~ (address,key) = valueOrElse(getInteger(address, key), 0)
	21	+	func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
36	22
37	23
38		-	func ~~getIntOrDefault~~ (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
	24	+	func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
39	25
40	26
41		-	func ~~getIntOrFail~~ (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
	27	+	func iof (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
42	28
43	29
44	30		func abs (val) = if ((0 > val))
45	31		then -(val)
46	32		else val
47	33
48	34
49		-	func ensurePositive (v,m) = if ((v >= 0))
50		-	then v
51		-	else throwErr((valueOrElse(m, "value") + " should be positive"))
	35	+	func aal (val) = match val {
	36	+	case valAnyLyst: List[Any] =>
	37	+	valAnyLyst
	38	+	case _ =>
	39	+	throwErr("fail to cast into List[Any]")
	40	+	}
	41	+
	42	+
	43	+	func ai (val) = match val {
	44	+	case valInt: Int =>
	45	+	valInt
	46	+	case _ =>
	47	+	throwErr("fail to cast into Int")
	48	+	}
52	49
53	50
54	51		func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
55	52
56	53
57		-	let referralsContractAddressOrFail = addressFromStringValue(~~getStringOrFail~~(this, keyReferralsContractAddress()))
	54	+	let referralsContractAddressOrFail = addressFromStringValue(strf(this, keyReferralsContractAddress()))
58	55
59	56		let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
60	57
61	58		let referralProgramNameDefault = "wxlock"
62	59
63	60		let referralProgramName = valueOrElse(getString(this, keyReferralProgramName), referralProgramNameDefault)
64	61
65	62		func keyFactoryAddress () = "%s%s__config__factoryAddress"
66	63
67	64
68	65		let IdxFactoryCfgStakingDapp = 1
69	66
70	67		let IdxFactoryCfgBoostingDapp = 2
71	68
72	69		let IdxFactoryCfgIdoDapp = 3
73	70
74	71		let IdxFactoryCfgTeamDapp = 4
75	72
76	73		let IdxFactoryCfgEmissionDapp = 5
77	74
78	75		let IdxFactoryCfgRestDapp = 6
79	76
80	77		let IdxFactoryCfgSlippageDapp = 7
81	78
82	79		let IdxFactoryCfgDaoDapp = 8
83	80
84	81		let IdxFactoryCfgMarketingDapp = 9
85	82
86	83		let IdxFactoryCfgGwxRewardDapp = 10
87	84
88	85		let IdxFactoryCfgBirdsDapp = 11
89	86
90	87		func keyFactoryCfg () = "%s__factoryConfig"
91	88
92	89
	90	+	func keyFactoryLpList () = "%s__lpTokensList"
	91	+
	92	+
93	93		func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
94	94
95	95
96	96		func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
97	97
98	98
99	99		func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
100	100
101	101
102		-	func readFactoryAddressOrFail () = addressFromStringValue(~~getStringOrFail~~(this, keyFactoryAddress()))
	102	+	func readFactoryAddressOrFail () = addressFromStringValue(strf(this, keyFactoryAddress()))
103	103
104	104
105		-	func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
	105	+	func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
	106	+
	107	+
	108	+	func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
106	109
107	110
108	111		func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
109	112
110	113
111	114		func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
112	115
113	116
114	117		func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
115	118
116	119
117	120		func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
118	121
119	122
120	123		func keyManagerPublicKey () = "%s__managerPublicKey"
121	124
122	125
123	126		func keyManagerVaultAddress () = "%s__managerVaultAddress"
124	127
125	128
126	129		func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
127	130
128	131
129	132		func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
130	133
131	134
132	135		func keyEmissionStartBlock () = "%s%s__emission__startBlock"
133	136
134	137
135	138		func keyBoostingV2LastUpdateHeight () = "%s%s__boostingV2__startBlock"
136	139
137	140
138	141		func keyBoostingV2Integral () = "%s%s__boostingV2__integral"
139	142
140	143
141	144		func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
142	145
143	146
144	147		func keyEmissionEndBlock () = "%s%s__emission__endBlock"
145	148
146	149
	150	+	func keyNextPeriod () = "%s__nextPeriod"
	151	+
	152	+
	153	+	func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
	154	+
	155	+
147	156		let IdxCfgAssetId = 1
148	157
149	158		let IdxCfgMinLockAmount = 2
150	159
151	160		let IdxCfgMinLockDuration = 3
152	161
153	162		let IdxCfgMaxLockDuration = 4
154	163
155	164		let IdxCfgMathContract = 5
156	165
157		-	let IdxCfgBlocksInPeriod = 6
158		-
159	166		func keyConfig () = "%s__config"
160	167
161	168
162		-	func readConfigArrayOrFail () = split(~~getStringOrFail~~(this, keyConfig()), SEP)
	169	+	func readConfigArrayOrFail () = split(strf(this, keyConfig()), SEP)
163	170
164	171
165		-	let ~~cfgArray~~ = readConfigArrayOrFail()
	172	+	let mathContract = addressFromStringValue(readConfigArrayOrFail()[IdxCfgMathContract])
166	173
167		-	let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
168		-
169		-	let minLockAmount = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockAmount]), wrapErr("invalid min lock amount"))
170		-
171		-	let minLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMinLockDuration]), wrapErr("invalid min lock duration"))
172		-
173		-	let maxLockDuration = valueOrErrorMessage(parseInt(cfgArray[IdxCfgMaxLockDuration]), wrapErr("invalid max lock duration"))
174		-
175		-	let mathContract = valueOrErrorMessage(addressFromString(cfgArray[IdxCfgMathContract]), wrapErr("invalid math contract address"))
176		-
177		-	let blocksInPeriod = valueOrErrorMessage(parseInt(cfgArray[IdxCfgBlocksInPeriod]), wrapErr("invalid blocks in period"))
178		-
179		-	func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d%s", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
	174	+	func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
180	175
181	176
182	177		func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
183	178
184	179
185	180		func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
186	181		case s: String =>
187	182		addressFromStringValue(s)
188	183		case _ =>
189	184		this
190	185		}
191	186
192	187
193	188		func managerPublicKeyOrUnit () = {
194	189		let managerVaultAddress = getManagerVaultAddressOrThis()
195	190		match getString(managerVaultAddress, keyManagerPublicKey()) {
196	191		case s: String =>
197	192		fromBase58String(s)
198	193		case _: Unit =>
199	194		unit
200	195		case _ =>
201	196		throw("Match error")
202	197		}
203	198		}
204	199
205	200
206	201		func mustManager (i) = {
207	202		let pd = throwErr("Permission denied")
208	203		match managerPublicKeyOrUnit() {
209	204		case pk: ByteVector =>
210	205		if ((i.callerPublicKey == pk))
211	206		then true
212	207		else pd
213	208		case _: Unit =>
214	209		if ((i.caller == this))
215	210		then true
216	211		else pd
217	212		case _ =>
218	213		throw("Match error")
219	214		}
220	215		}
221	216
222	217
223		-	let ~~IdxLockAmount~~ = 1
	218	+	let IdxLockUserNum = 1
224	219
225		-	let ~~IdxLockStart~~ = 2
	220	+	let IdxLockAmount = 2
226	221
227		-	let ~~IdxLockDuration~~ = 3
	222	+	let IdxLockStart = 3
228	223
229		-	let ~~IdxLockLastUpdateTimestamp~~ = 4
	224	+	let IdxLockDuration = 4
230	225
231		-	let ~~IdxLockGwxAmount~~ = 5
	226	+	let IdxLockParamK = 5
232	227
233		-	let ~~IdxLockWxClaimed~~ = 6
	228	+	let IdxLockParamB = 6
234	229
235		-	func keyLockParamsRecord (userAddress,txId) = makeString(["%s%s%s__lock", toString(userAddress), match txId {
236		-	case b: ByteVector =>
237		-	toBase58String(b)
238		-	case _: Unit =>
239		-	"legacy"
240		-	case _ =>
241		-	throw("Match error")
242		-	}], SEP)
	230	+	func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
243	231
244	232
245		-	func readLockParamsRecordOrFail (userAddress~~,txId~~) = split(~~getStringOrFail~~(this, keyLockParamsRecord(userAddress~~, txId~~)), SEP)
	233	+	func readLockParamsRecordOrFail (userAddress) = split(strf(this, keyLockParamsRecord(userAddress)), SEP)
246	234
247	235
248		-	func ~~keyUserGwxAmountTotal~~ (~~userAddress~~) = makeString(["%s%~~s__gwxAmountTotal~~", ~~toString(userAddress)~~], SEP)
	236	+	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)
249	237
250	238
251		-	func formatLockParamsRecord (amount,start,duration,gwxAmount~~,wxClaimed~~) = ~~makeString~~(~~["%d%d%d%d%d%d"~~, toString(amount), toString(start), toString(duration), toString(lastBlock.timestamp), toString(gwxAmount)~~, toString(wxClaimed~~)~~], SEP)~~
	239	+	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))
252	240
253	241
254	242		func keyNextUserNum () = "%s__nextUserNum"
255	243
256	244
257	245		func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
258	246
259	247
260	248		func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
	249	+
	250	+
	251	+	func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
	252	+
	253	+
	254	+	func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
	255	+
	256	+
	257	+	func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
	258	+
	259	+
	260	+	func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
	261	+
	262	+
	263	+	func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
	264	+
	265	+
	266	+	func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
	267	+
	268	+
	269	+	func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
261	270
262	271
263	272		func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
264	273
265	274
266	275		func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
267	276
268	277
269	278		func keyStatsLocksCount () = "%s%s__stats__locksCount"
270	279
271	280
272	281		func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
273	282
274	283
275		-	func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", ~~toString(~~userNum)], SEP)
	284	+	func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum], SEP)
276	285
277	286
278		-	func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", ~~toString(~~userNum), lpAssetId], SEP)
	287	+	func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastIntV2", userNum, lpAssetId], SEP)
279	288
280	289
281		-	func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", ~~toString(~~userNum)], SEP)
	290	+	func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
282	291
283	292
284	293		func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
285	294
286	295
287		-	func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", ~~toString(~~userNum)], SEP)
	296	+	func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
288	297
289	298
290		-	func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", ~~toString(~~userNum)], SEP)
	299	+	func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
291	300
292	301
293		-	func keyGwxTotal () = "%s%s__gwx__total"
	302	+	func keyTotalCachedGwx () = "%s%s__gwxCached__total"
	303	+
	304	+
	305	+	func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
294	306
295	307
296	308		func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
297	309
298	310
299	311		func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], SEP)
300	312
301	313
302	314		func keyCurrentEpochUi () = makeString(["%s", "currentEpochUi"], SEP)
303	315
304	316
305	317		func keyVotingResultStaked (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStaked", lpAssetIdStr, toString(epoch)], SEP)
306	318
307	319
308	320		func keyVotingResultStakedIntegral (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegral", lpAssetIdStr, toString(epoch)], SEP)
309	321
310	322
311	323		func keyVotingResultStakedLastUpdateHeight (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(epoch)], SEP)
312	324
313	325
314	326		func keyVotingResultStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "votingResultStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
315	327
316	328
317	329		func keyVoteStakedIntegral (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegral", lpAssetIdStr, toString(address), toString(epoch)], SEP)
318	330
319	331
320	332		func keyVoteStakedLastUpdateHeight (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(address), toString(epoch)], SEP)
321	333
322	334
323	335		func keyVoteStakedIntegralLast (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLast", lpAssetIdStr, toString(address), toString(epoch)], SEP)
324	336
325	337
326	338		func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s", "staked", userAddressStr, lpAssetIdStr], SEP)
327	339
328	340
329	341		let factoryContract = readFactoryAddressOrFail()
330	342
331	343		let factoryCfg = readFactoryCfgOrFail(factoryContract)
332	344
333	345		let emissionContract = getEmissionAddressOrFail(factoryCfg)
334	346
335	347		let stakingContract = getStakingAddressOrFail(factoryCfg)
336	348
337	349		let gwxRewardContract = getGwxRewardAddressOrFail(factoryCfg)
338	350
339	351		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"))
340	352
341	353		let keyVotingEmissionContract = makeString(["%s", "votingEmissionContract"], SEP)
342	354
343	355		let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
344	356
345		-	let keyVotingEmissionRateContract = makeString(["%s", "votingEmissionRateContract"], SEP)
346		-
347	357		let boostCoeff = {
348	358		let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
349	359		if ($isInstanceOf(@, "Int"))
350	360		then @
351	361		else throw(($getType(@) + " couldn't be cast to Int"))
352	362		}
353	363
354		-	func userNumberByAddressOrFail (userAddress) = match getString(this, keyUser2NumMapping(toString(userAddress))) {
355		-	case s: String =>
356		-	valueOrErrorMessage(parseInt(s), wrapErr("invalid user number"))
357		-	case _: Unit =>
358		-	throwErr("invalid user")
359		-	case _ =>
360		-	throw("Match error")
361		-	}
362		-
363		-
364		-	func getGwxAmountTotal () = valueOrElse(getInteger(this, keyGwxTotal()), 0)
365		-
366		-
367		-	func getLockedGwxAmount (userAddress) = {
368		-	let functionName = "getLockedGwxAmount"
369		-	let votingEmissionRateContract = valueOrErrorMessage( match getString(votingEmissionContract, keyVotingEmissionRateContract) {
370		-	case _: Unit =>
371		-	unit
372		-	case s: String =>
373		-	addressFromString(s)
374		-	case _ =>
375		-	throw("Match error")
376		-	}, wrapErr("invalid voting emission rate address"))
377		-	let lockedVotingEmissionRate = {
378		-	let @ = invoke(votingEmissionContract, functionName, [toString(userAddress)], nil)
379		-	if ($isInstanceOf(@, "Int"))
380		-	then @
381		-	else throw(($getType(@) + " couldn't be cast to Int"))
382		-	}
383		-	let lockedVotingEmission = {
384		-	let @ = invoke(votingEmissionRateContract, functionName, [toString(userAddress)], nil)
385		-	if ($isInstanceOf(@, "Int"))
386		-	then @
387		-	else throw(($getType(@) + " couldn't be cast to Int"))
388		-	}
389		-	let locked = max([lockedVotingEmissionRate, lockedVotingEmission])
390		-	locked
	364	+	func getTotalCachedGwx (correct) = {
	365	+	let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi())
	366	+	let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
	367	+	let targetEpochOption = getInteger(this, keyTargetEpoch)
	368	+	let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
	369	+	let isCorrectionActivated = if (isDefined(targetEpochOption))
	370	+	then (currentEpochUi >= value(targetEpochOption))
	371	+	else false
	372	+	let corrective = if (if (isCorrectionActivated)
	373	+	then correct
	374	+	else false)
	375	+	then valueOrElse(getInteger(this, keyTotalCachedGwxCorrective()), 0)
	376	+	else 0
	377	+	max([0, (totalCachedGwxRaw + corrective)])
391	378		}
392	379
393	380
394		-	func HistoryEntry (type,user,amount,lockStart,duration,~~gwxAmount~~,i) = {
	381	+	func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
395	382		let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
396		-	let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(~~gwxAmount~~)], SEP)
	383	+	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)
397	384		StringEntry(historyKEY, historyDATA)
398	385		}
399	386
400	387
401	388		func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
402	389		let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
403	390		let locksCountKEY = keyStatsLocksCount()
404	391		let usersCountKEY = keyStatsUsersCount()
405	392		let totalAmountKEY = keyLockParamTotalAmount()
406		-	let locksDurationSumInBlocks = ~~getIntOrZero~~(this, locksDurationSumInBlocksKEY)
407		-	let locksCount = ~~getIntOrZero~~(this, locksCountKEY)

github/deemru/w8io/026f985 
183.66 ms ◑