2023.03.28 16:18 [3575478] smart account 3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6K7YQXsmRPa2Vcc9kpVkwoKrJgEygZtp3LUiKoXqxbTm",
    "fee": 3800000,
    "feeAssetId": null,
    "timestamp": 1680009529469,
    "version": 2,
    "chainId": 87,
    "sender": "3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP",
    "senderPublicKey": "6PdA345SW1zresPEKuWiLPsh9Ku14mFDW6cZtpCQrp3E",
    "proofs": [
        "5eAeJtTAz674eAJpBVAUzxX7aJfSfVaqKPPGQm2TJPhfszat1PqRLWYrB7iTnN4LQPGPZ27X6XWZbhGcM2boGwfS"
    ],
    "script": "base64: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",
    "height": 3575478,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6bVdHt53mDvEzZdvCS7VRJdu5QsBsyT1APGyjaWNgMJq
Next: JamxMqWg1puHQuwtUh3AeJ3wcx5dMxZc3JMnhAdusS3

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