w8 · tx · AuG···PFJ

tx · AuGR23H1WV8mAjnRLoKH5dQnxjNH7SeF9ifWm75DfPFJ

3Myn55vLkduxbX3ZXfiDCZhaQsLxYp1kmCy:  -0.02600000 Waves

2023.08.16 14:12 [2713052] smart account 3Myn55vLkduxbX3ZXfiDCZhaQsLxYp1kmCy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AuGR23H1WV8mAjnRLoKH5dQnxjNH7SeF9ifWm75DfPFJ",
    "fee": 2600000,
    "feeAssetId": null,
    "timestamp": 1692184224408,
    "version": 2,
    "chainId": 84,
    "sender": "3Myn55vLkduxbX3ZXfiDCZhaQsLxYp1kmCy",
    "senderPublicKey": "9W33iCCNfmFxUbiC6XZcH5x7f6xfwC7Jb3BoExT5q2PV",
    "proofs": [
        "2Pyw3gijmHDb2siDxBzz5dAqSHDWSDcNfM52sRFifePsVG7GWZtVdtPfQug3yh3kWTTDkDbZ1qcNUZ8SGguJKuw"
    ],
    "script": "base64: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",
    "height": 2713052,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 319rJAAw9xqhiwHhkf2aoRxkpy2JsiWLU9sKv1ym55HG
Next: D69Z5DoJ8y2c7My6s56dB7LJoKKvSwqd1SW8kvjhttMP

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

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

32	46		else val
33	47
34	48
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		-	}
	49	+	func ensurePositive (v,m) = if ((v >= 0))
	50	+	then v
	51	+	else throwErr((valueOrElse(m, "value") + " should be positive"))
49	52
50	53
51	54		func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
52	55
53	56
54		-	let referralsContractAddressOrFail = addressFromStringValue(~~strf~~(this, keyReferralsContractAddress()))
	57	+	let referralsContractAddressOrFail = addressFromStringValue(getStringOrFail(this, keyReferralsContractAddress()))
55	58
56	59		let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
57	60

87	90		func keyFactoryCfg () = "%s__factoryConfig"
88	91
89	92
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(~~strf~~(this, keyFactoryAddress()))
	102	+	func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(this, keyFactoryAddress()))
103	103
104	104
105		-	func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
106		-
107		-
108		-	func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
	105	+	func readFactoryCfgOrFail (factory) = split(getStringOrFail(factory, keyFactoryCfg()), SEP)
109	106
110	107
111	108		func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])

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

163	154
164	155		let IdxCfgMathContract = 5
165	156
	157	+	let IdxCfgBlocksInPeriod = 6
	158	+
166	159		func keyConfig () = "%s__config"
167	160
168	161
169		-	func readConfigArrayOrFail () = split(~~strf~~(this, keyConfig()), SEP)
	162	+	func readConfigArrayOrFail () = split(getStringOrFail(this, keyConfig()), SEP)
170	163
171	164
172		-	let ~~mathContract~~ = ~~addressFromStringValue(~~readConfigArrayOrFail()~~[IdxCfgMathContract])~~
	165	+	let cfgArray = readConfigArrayOrFail()
173	166
174		-	func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
	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)
175	180
176	181
177	182		func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)

215	220		}
216	221
217	222
218		-	let ~~IdxLockUserNum~~ = 1
	223	+	let IdxLockAmount = 1
219	224
220		-	let ~~IdxLockAmount~~ = 2
	225	+	let IdxLockStart = 2
221	226
222		-	let ~~IdxLockStart~~ = 3
	227	+	let IdxLockDuration = 3
223	228
224		-	let ~~IdxLockDuration~~ = 4
	229	+	let IdxLockLastUpdateTimestamp = 4
225	230
226		-	let ~~IdxLockParamK~~ = 5
	231	+	let IdxLockGwxAmount = 5
227	232
228		-	let ~~IdxLockParamB~~ = 6
	233	+	let IdxLockWxClaimed = 6
229	234
230		-	func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
	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)
231	243
232	244
233		-	func readLockParamsRecordOrFail (userAddress) = split(~~strf~~(this, keyLockParamsRecord(userAddress)), SEP)
	245	+	func readLockParamsRecordOrFail (userAddress,txId) = split(getStringOrFail(this, keyLockParamsRecord(userAddress, txId)), SEP)
234	246
235	247
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)
	248	+	func keyUserGwxAmountTotal (userAddress) = makeString(["%s%s__gwxAmountTotal", toString(userAddress)], SEP)
237	249
238	250
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))
	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)
240	252
241	253
242	254		func keyNextUserNum () = "%s__nextUserNum"

246	258
247	259
248	260		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)
270	261
271	262
272	263		func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"

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

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

361	351		else throw(($getType(@) + " couldn't be cast to Int"))
362	352		}
363	353
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)])
	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
378	391		}
379	392
380	393
381		-	func HistoryEntry (type,user,amount,lockStart,duration,~~k,b~~,i) = {
	394	+	func HistoryEntry (type,user,amount,lockStart,duration,gwxAmount,i) = {
382	395		let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], 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)
	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)
384	397		StringEntry(historyKEY, historyDATA)
385	398		}
386	399

390	403		let locksCountKEY = keyStatsLocksCount()
391	404		let usersCountKEY = keyStatsUsersCount()
392	405		let totalAmountKEY = keyLockParamTotalAmount()
393		-	let locksDurationSumInBlocks = ~~ioz~~(this, locksDurationSumInBlocksKEY)
394		-	let locksCount = ~~ioz~~(this, locksCountKEY)
395		-	let usersCount = ~~ioz~~(this, usersCountKEY)
396		-	let totalAmount = ~~ioz~~(this, totalAmountKEY)
	406	+	let locksDurationSumInBlocks = getIntOrZero(this, locksDurationSumInBlocksKEY)
	407	+	let locksCount = getIntOrZero(this, locksCountKEY)
	408	+	let usersCount = getIntOrZero(this, usersCountKEY)
	409	+	let totalAmount = getIntOrZero(this, totalAmountKEY)
397	410		[IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
398	411		}
399	412
400	413
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		-	}
	414	+	func LockParamsEntry (userAddress,txId,amount,start,duration,gwxAmount,wxClaimed) = [StringEntry(keyLockParamsRecord(userAddress, txId), formatLockParamsRecord(amount, start, duration, gwxAmount, wxClaimed))]
418	415
419	416
420	417		func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))

429	426		}
430	427
431	428
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)
	429	+	func getUserGwxAmountTotal (userAddress) = valueOrElse(getInteger(this, keyUserGwxAmountTotal(userAddress)), 0)
447	430
448	431
449	432		func getVotingEmissionEpochInfo () = {
450		-	let $~~t01718617476~~ = {
	433	+	let $t01505115341 = {
451	434		let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi()))
452	435		let lastFinalizedEpoch = (currentEpochUi - 1)
453	436		if ((0 > lastFinalizedEpoch))
454	437		then throwErr("invalid epoch")
455	438		else $Tuple2(currentEpochUi, lastFinalizedEpoch)
456	439		}
457		-	let currentEpochUi = $~~t01718617476~~._1
458		-	let lastFinalizedEpoch = $~~t01718617476~~._2
	440	+	let currentEpochUi = $t01505115341._1
	441	+	let lastFinalizedEpoch = $t01505115341._2
459	442		let currentEpochStartHeight = value(getInteger(votingEmissionContract, keyStartHeightByEpoch(currentEpochUi)))
460	443		$Tuple2(lastFinalizedEpoch, currentEpochStartHeight)
461	444		}

488	471
489	472		func getUserVoteFinalized (lpAssetIdStr,userAddressStr) = {
490	473		let userAddress = addressFromStringValue(userAddressStr)
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
	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
497	480		let userVoteKey = keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)
498	481		let userVote = valueOrElse(getInteger(votingEmissionContract, userVoteKey), 0)
499	482		userVote

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

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

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

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

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

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

github/deemru/w8io/026f985 
179.03 ms ◑