w8 · tx · 2Wi···pCb

tx · 2Wi1uSivnsSkABw8PPWqoCKjHHyWp1J96WPKdR3UtpCb

3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV:  -0.03400000 Waves

2023.03.28 16:19 [3575479] smart account 3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2Wi1uSivnsSkABw8PPWqoCKjHHyWp1J96WPKdR3UtpCb",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1680009559506,
    "version": 2,
    "chainId": 87,
    "sender": "3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV",
    "senderPublicKey": "EAtbDa63mS5omrvW7Pfr7DKWEVLuReJtu72vfiBLRXsx",
    "proofs": [
        "5fP9Bvzj9Xp1PXeLDdRJBFWWzDcCkdmHnLrs9Xp2UCo3nWijZZhVgaotJqx2qZcVnyLdCgHf5hqW5V6JeryyRGNp"
    ],
    "script": "base64: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",
    "height": 3575479,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: BTtGvVzJXS6XgiBPJhaV2MZ2oFGfaUCFEp9DtgR7cYAz
Next: Gvc7HrXN2fRwSuvs5AX1Lyhne18f8gVuf4iwvNbUdauh

Diff: 
Old New Differences
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let SCALE8 = 8
5 + 
6 + let MULT3 = 1000
5 7  
6 8  let MULT8 = 100000000
7 9  
27 29      case valAnyLyst: List[Any] => 
28 30          valAnyLyst
29 31      case _ => 
30 -         throw("fail to cast into List[Any]")
32 +         throwErr("fail to cast into List[Any]")
31 33  }
32 34  
33 35  
35 37      case valInt: Int => 
36 38          valInt
37 39      case _ => 
38 -         throw("fail to cast into Int")
40 +         throwErr("fail to cast into Int")
39 41  }
40 42  
41 43  
43 45      case valStr: String => 
44 46          valStr
45 47      case _ => 
46 -         throw("fail to cast into Int")
48 +         throwErr("fail to cast into Int")
47 49  }
48 50  
49 51  
51 53      case valBin: ByteVector => 
52 54          valBin
53 55      case _ => 
54 -         throw("fail to cast into Int")
56 +         throwErr("fail to cast into Int")
55 57  }
56 58  
57 59  
58 - func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
60 + func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
59 61  
60 62  
61 - func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
63 + func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
62 64  
63 65  
64 66  func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
67 69  func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
68 70  
69 71  
70 - func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
72 + func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
71 73  
72 74  
73 75  func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
245 247  
246 248  let boostingContract = getBoostingAddressOrFail(factoryCfg)
247 249  
250 + let boostCoeff = {
251 +     let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
252 +     if ($isInstanceOf(@, "Int"))
253 +         then @
254 +         else throw(($getType(@) + " couldn't be cast to Int"))
255 +     }
256 + 
248 257  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"))
249 258  
250 259  func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
282 291      let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
283 292      let checkNode = if (!(containsNode(listName, id)))
284 293          then true
285 -         else throw("Node exists")
294 +         else throwErr("Node exists")
286 295      if ((checkNode == checkNode))
287 296          then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
288 297              then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
306 315                  then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
307 316                  else if ((id == valueOrElse(headOrUnit, "")))
308 317                      then [DeleteEntry(keyListHead(listName))]
309 -                     else throw(((("invalid node: " + listName) + ".") + id))))
318 +                     else throwErr(((("invalid node: " + listName) + ".") + id))))
310 319      }
311 320  
312 321  
320 329              then (stakedByUser > zeroBigInt)
321 330              else false)
322 331              then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
323 -             else throw("calcWxPerLpIntegralUserLast: unexpected state")
332 +             else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
324 333  
325 334  
326 335  func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
331 340          else stakedTotal
332 341      let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
333 342      let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
334 -     let MULT3 = 1000
335 343      let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
336 -     let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
344 +     let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
337 345      let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
338 346      let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
339 347      let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
357 365  
358 366  
359 367  func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
360 -     let $t01475014872 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
361 -     let wxPerLpIntegralNew = $t01475014872._1
362 -     let poolIntegralSTATE = $t01475014872._2
363 -     let poolDEBUG = $t01475014872._3
364 -     let MULT3 = 1000
368 +     let $t01481914941 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
369 +     let wxPerLpIntegralNew = $t01481914941._1
370 +     let poolIntegralSTATE = $t01481914941._2
371 +     let poolDEBUG = $t01481914941._3
365 372      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
366 373      let stakedByUser = readStaked(stakedByUserKEY)
367 374      let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
399 406  }
400 407  
401 408  
402 - let permissionDeniedError = throw("Permission denied")
409 + let permissionDeniedError = throwErr("Permission denied")
403 410  
404 411  func mustThis (i) = if ((i.caller == this))
405 412      then true
433 440      if ((refreshStakedVote == refreshStakedVote))
434 441          then {
435 442              let stakedTotal = readStaked(stakedTotalKEY)
436 -             let $t01810718224 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
437 -             let wxToClaimUserNew = $t01810718224._1
438 -             let integralSTATE = $t01810718224._2
439 -             let debug = $t01810718224._3
443 +             let $t01816018277 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
444 +             let wxToClaimUserNew = $t01816018277._1
445 +             let integralSTATE = $t01816018277._2
446 +             let debug = $t01816018277._3
440 447              let listName = getUsersListName(lpAssetIdStr)
441 448              let listActions = if (containsNode(listName, userAddressStr))
442 449                  then nil
476 483                  else unit
477 484              if ((r == r))
478 485                  then if ((amount > stakedByUser))
479 -                     then throw(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
486 +                     then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
480 487                      else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
481 488                  else throw("Strict value is not equal to itself.")
482 489              }
526 533      let pm = pendingManagerPublicKeyOrUnit()
527 534      let hasPM = if (isDefined(pm))
528 535          then true
529 -         else throw("No pending manager")
536 +         else throwErr("No pending manager")
530 537      if ((hasPM == hasPM))
531 538          then {
532 539              let checkPM = if ((i.callerPublicKey == value(pm)))
533 540                  then true
534 -                 else throw("You are not pending manager")
541 +                 else throwErr("You are not pending manager")
535 542              if ((checkPM == checkPM))
536 543                  then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
537 544                  else throw("Strict value is not equal to itself.")
543 550  
544 551  @Callable(i)
545 552  func stake () = if ((size(i.payments) != 1))
546 -     then throw("invalid payment - exact one payment must be attached")
553 +     then throwErr("invalid payment - exact one payment must be attached")
547 554      else {
548 555          let pmt = i.payments[0]
549 556          let lpAssetId = value(pmt.assetId)
550 557          let lpAssetIdStr = toBase58String(lpAssetId)
551 558          let amount = pmt.amount
552 -         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
559 +         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
553 560          let poolAddress = addressFromStringValue(poolAddressStr)
554 561          let userAddress = if ((i.caller == poolAddress))
555 562              then i.originCaller
561 568  
562 569  @Callable(i)
563 570  func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
564 -     then throw("invalid payment - exact one payment must be attached")
571 +     then throwErr("invalid payment - exact one payment must be attached")
565 572      else {
566 573          let pmt = i.payments[0]
567 574          let lpAssetId = value(pmt.assetId)
568 575          let lpAssetIdStr = toBase58String(lpAssetId)
569 576          let amount = pmt.amount
570 -         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
577 +         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
571 578          let poolAddress = addressFromStringValue(poolAddressStr)
572 579          let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
573 580          stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
578 585  @Callable(i)
579 586  func unstake (lpAssetIdStr,amount) = {
580 587      let lpAssetId = fromBase58String(lpAssetIdStr)
581 -     let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
588 +     let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
582 589      let poolAddress = addressFromStringValue(poolAddressStr)
583 590      let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
584 591      let callerStr = toString(i.caller)
596 603  @Callable(i)
597 604  func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
598 605      let lpAssetIdStr = toBase58String(lpAssetId)
599 -     let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr)))
606 +     let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr))))
600 607      let checkCaller = if ((i.caller == poolAddress))
601 608          then true
602 609          else permissionDeniedError
632 639      let checkCaller = mustThis(i)
633 640      if ((checkCaller == checkCaller))
634 641          then {
635 -             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), "claimWxINTERNAL: invalid user address")
642 +             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
636 643              let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
637 644              let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
638 645              let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
642 649              let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
643 650              let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
644 651              let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
645 -             let $t02618626298 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
646 -             let wxToClaimUserNew = $t02618626298._1
647 -             let integralSTATE = $t02618626298._2
648 -             let debug = $t02618626298._3
652 +             let $t02631426426 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
653 +             let wxToClaimUserNew = $t02631426426._1
654 +             let integralSTATE = $t02631426426._2
655 +             let debug = $t02631426426._3
649 656              let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
650 657              if ((zeroBigInt >= availableToClaim))
651 658                  then if (throwIfNothingToClaim)
652 -                     then throw("nothing to claim")
659 +                     then throwErr("nothing to claim")
653 660                      else $Tuple2(nil, 0)
654 661                  else {
655 662                      let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
656 663                      let minRewardPart = availableToClaim
657 -                     let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
664 +                     let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
658 665                      let totalReward = (minRewardPart + boostRewardPart)
659 666                      let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
660 667                      let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
687 694              }, SEP)
688 695          let unclaimed = info[3]
689 696          let claimed = info[4]
690 -         let res = (resAcc :+ makeString(["%d%d", unclaimed, claimed], SEP))
697 +         let userVoteFinalized = {
698 +             let @ = invoke(boostingContract, "getUserVoteFinalizedREADONLY", [lpAssetId, userAddressStr], nil)
699 +             if ($isInstanceOf(@, "Int"))
700 +                 then @
701 +                 else throw(($getType(@) + " couldn't be cast to Int"))
702 +             }
703 +         let res = (resAcc :+ makeString(["%d%d%d", unclaimed, claimed, toString(userVoteFinalized)], SEP))
691 704          let inv = {
692 705              let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
693 706              if ($isInstanceOf(@, "List[Any]"))
728 741          else (height - emissionStartBlock)
729 742      let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
730 743      let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
731 -     let $t03010730219 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
732 -     let wxToClaimUserNew = $t03010730219._1
733 -     let integralSTATE = $t03010730219._2
734 -     let debug = $t03010730219._3
744 +     let $t03047730589 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
745 +     let wxToClaimUserNew = $t03047730589._1
746 +     let integralSTATE = $t03047730589._2
747 +     let debug = $t03047730589._3
735 748      let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
736 749      let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
737 750      let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
738 751      let boostDebug = asString(boostInvResult[1])
739 752      let minRewardPart = availableToClaim
740 -     let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
753 +     let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
741 754      let totalReward = (minRewardPart + boostRewardPart)
742 755      $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
743 756      }
805 818  
806 819  @Callable(i)
807 820  func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
808 -     then throw("permissions denied")
821 +     then throwErr("permissions denied")
809 822      else {
810 -         let $t03282532935 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
811 -         let wxPerLpIntegralNew = $t03282532935._1
812 -         let poolIntegralSTATE = $t03282532935._2
813 -         let poolDEBUG = $t03282532935._3
823 +         let $t03321333323 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
824 +         let wxPerLpIntegralNew = $t03321333323._1
825 +         let poolIntegralSTATE = $t03321333323._2
826 +         let poolDEBUG = $t03321333323._3
814 827          poolIntegralSTATE
815 828          }
816 829  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let SCALE8 = 8
5 + 
6 + let MULT3 = 1000
5 7  
6 8  let MULT8 = 100000000
7 9  
8 10  let SCALE18 = 18
9 11  
10 12  let MULT18 = toBigInt(1000000000000000000)
11 13  
12 14  let SEP = "__"
13 15  
14 16  let POOLWEIGHTMULT = MULT8
15 17  
16 18  let zeroBigInt = toBigInt(0)
17 19  
18 20  let oneBigInt = toBigInt(1)
19 21  
20 22  func wrapErr (msg) = makeString(["staking.ride:", toString(this), msg], " ")
21 23  
22 24  
23 25  func throwErr (msg) = throw(wrapErr(msg))
24 26  
25 27  
26 28  func asAnyList (val) = match val {
27 29      case valAnyLyst: List[Any] => 
28 30          valAnyLyst
29 31      case _ => 
30 -         throw("fail to cast into List[Any]")
32 +         throwErr("fail to cast into List[Any]")
31 33  }
32 34  
33 35  
34 36  func asInt (val) = match val {
35 37      case valInt: Int => 
36 38          valInt
37 39      case _ => 
38 -         throw("fail to cast into Int")
40 +         throwErr("fail to cast into Int")
39 41  }
40 42  
41 43  
42 44  func asString (val) = match val {
43 45      case valStr: String => 
44 46          valStr
45 47      case _ => 
46 -         throw("fail to cast into Int")
48 +         throwErr("fail to cast into Int")
47 49  }
48 50  
49 51  
50 52  func asByteVector (val) = match val {
51 53      case valBin: ByteVector => 
52 54          valBin
53 55      case _ => 
54 -         throw("fail to cast into Int")
56 +         throwErr("fail to cast into Int")
55 57  }
56 58  
57 59  
58 - func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
60 + func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
59 61  
60 62  
61 - func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
63 + func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
62 64  
63 65  
64 66  func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
65 67  
66 68  
67 69  func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
68 70  
69 71  
70 - func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
72 + func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
71 73  
72 74  
73 75  func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
74 76  
75 77  
76 78  func getBigIntFromStringOrDefault (address,key,defaultVal) = match getString(address, key) {
77 79      case s: String => 
78 80          value(parseBigInt(s))
79 81      case _: Unit => 
80 82          defaultVal
81 83      case _ => 
82 84          throw("Match error")
83 85  }
84 86  
85 87  
86 88  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), MULT18, toBigInt(origScaleMult))
87 89  
88 90  
89 91  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), MULT18))
90 92  
91 93  
92 94  func keyFactoryAddress () = "%s%s__config__factoryAddress"
93 95  
94 96  
95 97  func keyVotingEmissionContract () = "%s__votingEmissionContract"
96 98  
97 99  
98 100  let IdxFactoryCfgStakingDapp = 1
99 101  
100 102  let IdxFactoryCfgBoostingDapp = 2
101 103  
102 104  let IdxFactoryCfgIdoDapp = 3
103 105  
104 106  let IdxFactoryCfgTeamDapp = 4
105 107  
106 108  let IdxFactoryCfgEmissionDapp = 5
107 109  
108 110  let IdxFactoryCfgRestDapp = 6
109 111  
110 112  let IdxFactoryCfgSlippageDapp = 7
111 113  
112 114  func keyFactoryCfg () = "%s__factoryConfig"
113 115  
114 116  
115 117  func keyManagerPublicKey () = "%s__managerPublicKey"
116 118  
117 119  
118 120  func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
119 121  
120 122  
121 123  func keyStablePoolAddonAddr () = "%s__stablePoolAddonAddr"
122 124  
123 125  
124 126  func keyAddonAddr () = "%s__addonAddr"
125 127  
126 128  
127 129  func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
128 130  
129 131  
130 132  func keyFactoryLpList () = "%s__lpTokensList"
131 133  
132 134  
133 135  func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
134 136  
135 137  
136 138  func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
137 139  
138 140  
139 141  func readLpList (factory) = split(valueOrElse(getString(factory, keyFactoryLpList()), ""), SEP)
140 142  
141 143  
142 144  func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
143 145  
144 146  
145 147  func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
146 148  
147 149  
148 150  func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
149 151  
150 152  
151 153  func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
152 154  
153 155  
154 156  func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
155 157  
156 158  
157 159  func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
158 160  
159 161  
160 162  func keyEmissionStartBlock () = "%s%s__emission__startBlock"
161 163  
162 164  
163 165  func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
164 166  
165 167  
166 168  func keyEmissionEndBlock () = "%s%s__emission__endBlock"
167 169  
168 170  
169 171  func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
170 172  
171 173  
172 174  func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
173 175  
174 176  
175 177  func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
176 178  
177 179  
178 180  func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
179 181  
180 182  
181 183  func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
182 184  
183 185  
184 186  func keyClaimedTotal (lpAssetIdStr) = makeString(["%s%s%s__claimed__total", lpAssetIdStr], SEP)
185 187  
186 188  
187 189  func readStaked (key) = valueOrElse(getInteger(this, key), 0)
188 190  
189 191  
190 192  func keyLastTotalLpBalance (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "bal"], SEP)
191 193  
192 194  
193 195  func keyLastUserLpBalance (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "bal"], SEP)
194 196  
195 197  
196 198  func keyTotalLpBalanceIntegral (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "balINT"], SEP)
197 199  
198 200  
199 201  func keyUserLpBalanceIntegral (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "balINT"], SEP)
200 202  
201 203  
202 204  func keyTotalLpBalanceIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "lastUpd"], SEP)
203 205  
204 206  
205 207  func keyUserLpBalanceIntegralLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "lastUpd"], SEP)
206 208  
207 209  
208 210  func keyWxPerLpIntegral (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpInt"], SEP)
209 211  
210 212  
211 213  func keyWxPerLpIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpIntH"], SEP)
212 214  
213 215  
214 216  func keyWxToClaimUser (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpInt"], SEP)
215 217  
216 218  
217 219  func keyWxPerLpIntegralUserLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpIntH"], SEP)
218 220  
219 221  
220 222  func keyWxPerLp (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLp"], SEP)
221 223  
222 224  
223 225  func keyWxPerLpX18 (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLpX18"], SEP)
224 226  
225 227  
226 228  func keyWxPerLpIntegralUserLast (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "uIntL"], SEP)
227 229  
228 230  
229 231  func keyOperationHistoryRecord (type,userAddress,txId58) = makeString(["%s%s%s%s__history", type, userAddress, txId58], SEP)
230 232  
231 233  
232 234  func formatHistoryRecord (userAddress,lpAssetId,type,amount) = makeString(["%s%s%s%d%d%d", userAddress, lpAssetId, type, toString(height), toString(lastBlock.timestamp), toString(amount)], SEP)
233 235  
234 236  
235 237  func OperationHistoryEntry (type,userAddress,lpAssetId,amount,txId) = StringEntry(keyOperationHistoryRecord(type, userAddress, toBase58String(txId)), formatHistoryRecord(userAddress, lpAssetId, type, amount))
236 238  
237 239  
238 240  let factoryAddress = getStringOrFail(this, keyFactoryAddress())
239 241  
240 242  let factoryContract = addressFromStringValue(factoryAddress)
241 243  
242 244  let factoryCfg = readFactoryCfgOrFail(factoryContract)
243 245  
244 246  let emissionContract = getEmissionAddressOrFail(factoryCfg)
245 247  
246 248  let boostingContract = getBoostingAddressOrFail(factoryCfg)
247 249  
250 + let boostCoeff = {
251 +     let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
252 +     if ($isInstanceOf(@, "Int"))
253 +         then @
254 +         else throw(($getType(@) + " couldn't be cast to Int"))
255 +     }
256 + 
248 257  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"))
249 258  
250 259  func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
251 260  
252 261  
253 262  func getUsersListName (lpAssetId) = makeString(["users", lpAssetId], SEP)
254 263  
255 264  
256 265  func keyListHead (listName) = makeString(["%s%s%s", listName, "head"], SEP)
257 266  
258 267  
259 268  func keyListSize (listName) = makeString(["%s%s%s", listName, "size"], SEP)
260 269  
261 270  
262 271  func keyListPrev (listName,id) = makeString(["%s%s%s%s", listName, id, "prev"], SEP)
263 272  
264 273  
265 274  func keyListNext (listName,id) = makeString(["%s%s%s%s", listName, id, "next"], SEP)
266 275  
267 276  
268 277  func containsNode (listName,id) = {
269 278      let headOrUnit = getString(this, keyListHead(listName))
270 279      let prevOrUnit = getString(this, keyListPrev(listName, id))
271 280      let nextOrUnit = getString(this, keyListNext(listName, id))
272 281      if (if ((id == valueOrElse(headOrUnit, "")))
273 282          then true
274 283          else (prevOrUnit != unit))
275 284          then true
276 285          else (nextOrUnit != unit)
277 286      }
278 287  
279 288  
280 289  func insertNodeActions (listName,id) = {
281 290      let headOrUnit = getString(this, keyListHead(listName))
282 291      let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
283 292      let checkNode = if (!(containsNode(listName, id)))
284 293          then true
285 -         else throw("Node exists")
294 +         else throwErr("Node exists")
286 295      if ((checkNode == checkNode))
287 296          then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
288 297              then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
289 298              else nil)) ++ [StringEntry(keyListHead(listName), id)])
290 299          else throw("Strict value is not equal to itself.")
291 300      }
292 301  
293 302  
294 303  func deleteNodeActions (listName,id) = {
295 304      let headOrUnit = getString(this, keyListHead(listName))
296 305      let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
297 306      let prevOrUnit = getString(this, keyListPrev(listName, id))
298 307      let nextOrUnit = getString(this, keyListNext(listName, id))
299 308      ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
300 309          then (nextOrUnit != unit)
301 310          else false)
302 311          then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
303 312          else if ((nextOrUnit != unit))
304 313              then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
305 314              else if ((prevOrUnit != unit))
306 315                  then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
307 316                  else if ((id == valueOrElse(headOrUnit, "")))
308 317                      then [DeleteEntry(keyListHead(listName))]
309 -                     else throw(((("invalid node: " + listName) + ".") + id))))
318 +                     else throwErr(((("invalid node: " + listName) + ".") + id))))
310 319      }
311 320  
312 321  
313 322  func calcWxPerLpIntegralUserLast (stakedByUser,wxPerLpIntegralUserLastUpdHeightOrZero,wxPerLpIntegralNew,wxPerLpIntegralUserLastKEY) = if (if ((wxPerLpIntegralUserLastUpdHeightOrZero == zeroBigInt))
314 323      then (stakedByUser > zeroBigInt)
315 324      else false)
316 325      then zeroBigInt
317 326      else if ((stakedByUser == zeroBigInt))
318 327          then wxPerLpIntegralNew
319 328          else if (if ((wxPerLpIntegralUserLastUpdHeightOrZero > zeroBigInt))
320 329              then (stakedByUser > zeroBigInt)
321 330              else false)
322 331              then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
323 -             else throw("calcWxPerLpIntegralUserLast: unexpected state")
332 +             else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
324 333  
325 334  
326 335  func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
327 336      let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
328 337      let stakedTotal = toBigInt(readStaked(stakedTotalKEY))
329 338      let nonZeroStakedTotal = if ((stakedTotal == zeroBigInt))
330 339          then oneBigInt
331 340          else stakedTotal
332 341      let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
333 342      let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
334 -     let MULT3 = 1000
335 343      let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
336 -     let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
344 +     let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
337 345      let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
338 346      let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
339 347      let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
340 348      let wxPerLpIntegralLastUpdHeight = getIntOrDefault(this, wxPerLpIntegralLastUpdHeightKEY, emissionStartBlock)
341 349      let wxPerLpIntegral = getBigIntFromStringOrZero(this, wxPerLpIntegralKEY)
342 350      let wxPerLpOrZeroX3 = 0
343 351      let dh = max([(height - wxPerLpIntegralLastUpdHeight), 0])
344 352      let wxPerLpX3 = if ((wxPerLpOrZeroX3 != 0))
345 353          then toBigInt(wxPerLpOrZeroX3)
346 354          else fraction(toBigInt(poolWxEmissionPerBlockX3), toBigInt(MULT8), nonZeroStakedTotal)
347 355      let stakedTotalNew = (stakedTotal + toBigInt(lpDeltaAmount))
348 356      let nonZeroStakedTotalNew = if ((stakedTotalNew == zeroBigInt))
349 357          then oneBigInt
350 358          else stakedTotalNew
351 359      let wxPerLpIntegralNew = (wxPerLpIntegral + (wxPerLpX3 * toBigInt(dh)))
352 360      let wxPerLpX3New = (toBigInt(poolWxEmissionPerBlockX3) / nonZeroStakedTotalNew)
353 361      let wxPerLpIntegralLastUpdHeightNew = height
354 362      let debug = makeString([toString(wxPerLpIntegralNew), toString(dh), toString(wxPerLpX3), toString(stakedTotal), toString(poolWxEmissionPerBlockX3), toString(wxEmissionPerBlockX3), toString(poolWeight)], "::")
355 363      $Tuple3(wxPerLpIntegralNew, [StringEntry(wxPerLpIntegralKEY, toString(wxPerLpIntegralNew)), IntegerEntry(wxPerLpIntegralLastUpdHeightKEY, wxPerLpIntegralLastUpdHeightNew), StringEntry(wxPerLpKEY, toString(wxPerLpX3New))], debug)
356 364      }
357 365  
358 366  
359 367  func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
360 -     let $t01475014872 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
361 -     let wxPerLpIntegralNew = $t01475014872._1
362 -     let poolIntegralSTATE = $t01475014872._2
363 -     let poolDEBUG = $t01475014872._3
364 -     let MULT3 = 1000
368 +     let $t01481914941 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
369 +     let wxPerLpIntegralNew = $t01481914941._1
370 +     let poolIntegralSTATE = $t01481914941._2
371 +     let poolDEBUG = $t01481914941._3
365 372      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
366 373      let stakedByUser = readStaked(stakedByUserKEY)
367 374      let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
368 375      let wxPerLpIntegralUserLastUpdHeightKEY = keyWxPerLpIntegralUserLastUpdHeight(lpAssetIdStr, userAddressStr)
369 376      let wxPerLpIntegralUserLastKEY = keyWxPerLpIntegralUserLast(lpAssetIdStr, userAddressStr)
370 377      let wxToClaimUser = getBigIntFromStringOrZero(this, wxToClaimUserKEY)
371 378      let wxPerLpIntegralUserLastUpdHeightOrZero = getIntOrZero(this, wxPerLpIntegralUserLastUpdHeightKEY)
372 379      let wxPerLpIntegralUserLast = calcWxPerLpIntegralUserLast(toBigInt(stakedByUser), toBigInt(wxPerLpIntegralUserLastUpdHeightOrZero), wxPerLpIntegralNew, wxPerLpIntegralUserLastKEY)
373 380      let MULT11 = (MULT8 * MULT3)
374 381      let wxToClaimUserNew = max([(wxToClaimUser + fraction((wxPerLpIntegralNew - wxPerLpIntegralUserLast), toBigInt(stakedByUser), toBigInt(MULT11))), zeroBigInt])
375 382      let wxPerLpIntegralUserLastNew = wxPerLpIntegralNew
376 383      let wxPerLpIntegralUserLastUpdHeightNew = height
377 384      let debug = makeString([toString(wxToClaimUser), toString(wxPerLpIntegralUserLast), toString(stakedByUser), poolDEBUG, toString(height)], "::")
378 385      $Tuple3(wxToClaimUserNew, (poolIntegralSTATE ++ [StringEntry(wxToClaimUserKEY, toString(wxToClaimUserNew)), IntegerEntry(wxPerLpIntegralUserLastUpdHeightKEY, wxPerLpIntegralUserLastUpdHeightNew), StringEntry(wxPerLpIntegralUserLastKEY, toString(wxPerLpIntegralUserLastNew))]), debug)
379 386      }
380 387  
381 388  
382 389  func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
383 390      case s: String => 
384 391          fromBase58String(s)
385 392      case _: Unit => 
386 393          unit
387 394      case _ => 
388 395          throw("Match error")
389 396  }
390 397  
391 398  
392 399  func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
393 400      case s: String => 
394 401          fromBase58String(s)
395 402      case _: Unit => 
396 403          unit
397 404      case _ => 
398 405          throw("Match error")
399 406  }
400 407  
401 408  
402 - let permissionDeniedError = throw("Permission denied")
409 + let permissionDeniedError = throwErr("Permission denied")
403 410  
404 411  func mustThis (i) = if ((i.caller == this))
405 412      then true
406 413      else permissionDeniedError
407 414  
408 415  
409 416  func mustManager (i) = match managerPublicKeyOrUnit() {
410 417      case pk: ByteVector => 
411 418          if ((i.callerPublicKey == pk))
412 419              then true
413 420              else permissionDeniedError
414 421      case _: Unit => 
415 422          if ((i.caller == this))
416 423              then true
417 424              else permissionDeniedError
418 425      case _ => 
419 426          throw("Match error")
420 427  }
421 428  
422 429  
423 430  func stakeActions (i,lpAssetId,poolAddress,userAddress,amount) = {
424 431      let userAddressStr = toString(userAddress)
425 432      let lpAssetIdStr = toBase58String(lpAssetId)
426 433      let poolAddressStr = toString(poolAddress)
427 434      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
428 435      let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
429 436      let stakedByUser = readStaked(stakedByUserKEY)
430 437      let refreshStakedVote = if ((stakedByUser == 0))
431 438          then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
432 439          else unit
433 440      if ((refreshStakedVote == refreshStakedVote))
434 441          then {
435 442              let stakedTotal = readStaked(stakedTotalKEY)
436 -             let $t01810718224 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
437 -             let wxToClaimUserNew = $t01810718224._1
438 -             let integralSTATE = $t01810718224._2
439 -             let debug = $t01810718224._3
443 +             let $t01816018277 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
444 +             let wxToClaimUserNew = $t01816018277._1
445 +             let integralSTATE = $t01816018277._2
446 +             let debug = $t01816018277._3
440 447              let listName = getUsersListName(lpAssetIdStr)
441 448              let listActions = if (containsNode(listName, userAddressStr))
442 449                  then nil
443 450                  else insertNodeActions(listName, userAddressStr)
444 451              (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
445 452              }
446 453          else throw("Strict value is not equal to itself.")
447 454      }
448 455  
449 456  
450 457  func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
451 458      let userAddressStr = toString(userAddress)
452 459      let lpAssetIdStr = toBase58String(lpAssetId)
453 460      let poolAddressStr = toString(poolAddress)
454 461      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
455 462      let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
456 463      let stakedByUser = readStaked(stakedByUserKEY)
457 464      let stakedTotal = readStaked(stakedTotalKEY)
458 465      let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
459 466      let listName = getUsersListName(lpAssetIdStr)
460 467      let listActions = if (if (containsNode(listName, userAddressStr))
461 468          then (amount == stakedByUser)
462 469          else false)
463 470          then deleteNodeActions(listName, userAddressStr)
464 471          else nil
465 472      let refreshStakedVote = if ((amount == stakedByUser))
466 473          then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
467 474          else unit
468 475      if ((refreshStakedVote == refreshStakedVote))
469 476          then {
470 477              let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
471 478              let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
472 479              let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
473 480              let throwIfNothingToClaim = true
474 481              let r = if ((availableToClaim > zeroBigInt))
475 482                  then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
476 483                  else unit
477 484              if ((r == r))
478 485                  then if ((amount > stakedByUser))
479 -                     then throw(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
486 +                     then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
480 487                      else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
481 488                  else throw("Strict value is not equal to itself.")
482 489              }
483 490          else throw("Strict value is not equal to itself.")
484 491      }
485 492  
486 493  
487 494  @Callable(i)
488 495  func constructor (factoryAddressStr) = {
489 496      let checkCaller = mustManager(i)
490 497      if ((checkCaller == checkCaller))
491 498          then [StringEntry(keyFactoryAddress(), factoryAddressStr)]
492 499          else throw("Strict value is not equal to itself.")
493 500      }
494 501  
495 502  
496 503  
497 504  @Callable(i)
498 505  func constructorV2 (votingEmissionContract) = {
499 506      let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
500 507          then true
501 508          else "invalid voting emission contract address"]
502 509      if ((cheks == cheks))
503 510          then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
504 511          else throw("Strict value is not equal to itself.")
505 512      }
506 513  
507 514  
508 515  
509 516  @Callable(i)
510 517  func setManager (pendingManagerPublicKey) = {
511 518      let checkCaller = mustManager(i)
512 519      if ((checkCaller == checkCaller))
513 520          then {
514 521              let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
515 522              if ((checkManagerPublicKey == checkManagerPublicKey))
516 523                  then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
517 524                  else throw("Strict value is not equal to itself.")
518 525              }
519 526          else throw("Strict value is not equal to itself.")
520 527      }
521 528  
522 529  
523 530  
524 531  @Callable(i)
525 532  func confirmManager () = {
526 533      let pm = pendingManagerPublicKeyOrUnit()
527 534      let hasPM = if (isDefined(pm))
528 535          then true
529 -         else throw("No pending manager")
536 +         else throwErr("No pending manager")
530 537      if ((hasPM == hasPM))
531 538          then {
532 539              let checkPM = if ((i.callerPublicKey == value(pm)))
533 540                  then true
534 -                 else throw("You are not pending manager")
541 +                 else throwErr("You are not pending manager")
535 542              if ((checkPM == checkPM))
536 543                  then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
537 544                  else throw("Strict value is not equal to itself.")
538 545              }
539 546          else throw("Strict value is not equal to itself.")
540 547      }
541 548  
542 549  
543 550  
544 551  @Callable(i)
545 552  func stake () = if ((size(i.payments) != 1))
546 -     then throw("invalid payment - exact one payment must be attached")
553 +     then throwErr("invalid payment - exact one payment must be attached")
547 554      else {
548 555          let pmt = i.payments[0]
549 556          let lpAssetId = value(pmt.assetId)
550 557          let lpAssetIdStr = toBase58String(lpAssetId)
551 558          let amount = pmt.amount
552 -         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
559 +         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
553 560          let poolAddress = addressFromStringValue(poolAddressStr)
554 561          let userAddress = if ((i.caller == poolAddress))
555 562              then i.originCaller
556 563              else i.caller
557 564          stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
558 565          }
559 566  
560 567  
561 568  
562 569  @Callable(i)
563 570  func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
564 -     then throw("invalid payment - exact one payment must be attached")
571 +     then throwErr("invalid payment - exact one payment must be attached")
565 572      else {
566 573          let pmt = i.payments[0]
567 574          let lpAssetId = value(pmt.assetId)
568 575          let lpAssetIdStr = toBase58String(lpAssetId)
569 576          let amount = pmt.amount
570 -         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
577 +         let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
571 578          let poolAddress = addressFromStringValue(poolAddressStr)
572 579          let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
573 580          stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
574 581          }
575 582  
576 583  
577 584  
578 585  @Callable(i)
579 586  func unstake (lpAssetIdStr,amount) = {
580 587      let lpAssetId = fromBase58String(lpAssetIdStr)
581 -     let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
588 +     let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
582 589      let poolAddress = addressFromStringValue(poolAddressStr)
583 590      let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
584 591      let callerStr = toString(i.caller)
585 592      let userAddress = if (if ((callerStr == poolAddressStr))
586 593          then true
587 594          else (callerStr == poolAddon))
588 595          then i.originCaller
589 596          else i.caller
590 597      let lpAssetRecipientAddress = i.caller
591 598      unstakeActions(i, lpAssetId, poolAddress, userAddress, lpAssetRecipientAddress, amount)
592 599      }
593 600  
594 601  
595 602  
596 603  @Callable(i)
597 604  func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
598 605      let lpAssetIdStr = toBase58String(lpAssetId)
599 -     let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr)))
606 +     let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr))))
600 607      let checkCaller = if ((i.caller == poolAddress))
601 608          then true
602 609          else permissionDeniedError
603 610      if ((checkCaller == checkCaller))
604 611          then unstakeActions(i, lpAssetId, poolAddress, Address(userAddress), Address(lpAssetRecipientAddress), amount)
605 612          else throw("Strict value is not equal to itself.")
606 613      }
607 614  
608 615  
609 616  
610 617  @Callable(i)
611 618  func claimWx (lpAssetIdStr) = {
612 619      let userAddressStr = toString(i.caller)
613 620      let throwIfNothingToClaim = true
614 621      let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
615 622      $Tuple2(nil, result)
616 623      }
617 624  
618 625  
619 626  
620 627  @Callable(i)
621 628  func claimWxDoNotThrow (lpAssetIdStr) = {
622 629      let userAddressStr = toString(i.caller)
623 630      let throwIfNothingToClaim = false
624 631      let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
625 632      $Tuple2(nil, result)
626 633      }
627 634  
628 635  
629 636  
630 637  @Callable(i)
631 638  func claimWxINTERNAL (lpAssetIdStr,userAddressStr,throwIfNothingToClaim) = {
632 639      let checkCaller = mustThis(i)
633 640      if ((checkCaller == checkCaller))
634 641          then {
635 -             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), "claimWxINTERNAL: invalid user address")
642 +             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
636 643              let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
637 644              let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
638 645              let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
639 646              let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
640 647              let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
641 648              let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
642 649              let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
643 650              let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
644 651              let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
645 -             let $t02618626298 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
646 -             let wxToClaimUserNew = $t02618626298._1
647 -             let integralSTATE = $t02618626298._2
648 -             let debug = $t02618626298._3
652 +             let $t02631426426 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
653 +             let wxToClaimUserNew = $t02631426426._1
654 +             let integralSTATE = $t02631426426._2
655 +             let debug = $t02631426426._3
649 656              let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
650 657              if ((zeroBigInt >= availableToClaim))
651 658                  then if (throwIfNothingToClaim)
652 -                     then throw("nothing to claim")
659 +                     then throwErr("nothing to claim")
653 660                      else $Tuple2(nil, 0)
654 661                  else {
655 662                      let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
656 663                      let minRewardPart = availableToClaim
657 -                     let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
664 +                     let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
658 665                      let totalReward = (minRewardPart + boostRewardPart)
659 666                      let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
660 667                      let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
661 668                      if ((emitBoost == emitBoost))
662 669                          then {
663 670                              let claimedByUserValue = ((claimedByUser + minRewardPart) + boostRewardPart)
664 671                              let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
665 672                              let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserBoostReward + boostRewardPart)
666 673                              let claimedTotalPlusAvailableToClaim = (claimedTotal + availableToClaim)
667 674                              $Tuple2([StringEntry(claimedByUserKEY, toString(claimedByUserValue)), StringEntry(claimedByUserMinRewardKEY, toString(claimedByUserMinRewardPlusPart)), StringEntry(claimedByUserBoostRewardKEY, toString(claimedByUserBoostRewardPlusBoostRewardPart)), StringEntry(claimedTotalKEY, toString(claimedTotalPlusAvailableToClaim)), ScriptTransfer(userAddress, toInt(minRewardPart), wxAssetId), ScriptTransfer(userAddress, toInt(boostRewardPart), wxAssetId), OperationHistoryEntry("claim", userAddressStr, lpAssetIdStr, toInt(availableToClaim), i.transactionId)], toInt(totalReward))
668 675                              }
669 676                          else throw("Strict value is not equal to itself.")
670 677                      }
671 678              }
672 679          else throw("Strict value is not equal to itself.")
673 680      }
674 681  
675 682  
676 683  
677 684  @Callable(i)
678 685  func claimWxBulkInternalREADONLY (currentIter,lpAssetIds,userAddressStr,resAcc) = if ((currentIter == size(lpAssetIds)))
679 686      then $Tuple2(nil, resAcc)
680 687      else {
681 688          let lpAssetId = lpAssetIds[currentIter]
682 689          let info = split({
683 690              let @ = invoke(this, "claimWxREADONLY", [lpAssetId, userAddressStr], nil)
684 691              if ($isInstanceOf(@, "String"))
685 692                  then @
686 693                  else throw(($getType(@) + " couldn't be cast to String"))
687 694              }, SEP)
688 695          let unclaimed = info[3]
689 696          let claimed = info[4]
690 -         let res = (resAcc :+ makeString(["%d%d", unclaimed, claimed], SEP))
697 +         let userVoteFinalized = {
698 +             let @ = invoke(boostingContract, "getUserVoteFinalizedREADONLY", [lpAssetId, userAddressStr], nil)
699 +             if ($isInstanceOf(@, "Int"))
700 +                 then @
701 +                 else throw(($getType(@) + " couldn't be cast to Int"))
702 +             }
703 +         let res = (resAcc :+ makeString(["%d%d%d", unclaimed, claimed, toString(userVoteFinalized)], SEP))
691 704          let inv = {
692 705              let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
693 706              if ($isInstanceOf(@, "List[Any]"))
694 707                  then @
695 708                  else throw(($getType(@) + " couldn't be cast to List[Any]"))
696 709              }
697 710          if ((inv == inv))
698 711              then $Tuple2(nil, inv)
699 712              else throw("Strict value is not equal to itself.")
700 713          }
701 714  
702 715  
703 716  
704 717  @Callable(i)
705 718  func claimWxBulkREADONLY (lpAssetIds,userAddressStr) = {
706 719      let res = invoke(this, "claimWxBulkInternalREADONLY", [0, lpAssetIds, userAddressStr, nil], nil)
707 720      $Tuple2(nil, res)
708 721      }
709 722  
710 723  
711 724  
712 725  @Callable(i)
713 726  func claimWxREADONLY (lpAssetIdStr,userAddressStr) = {
714 727      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
715 728      let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
716 729      let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
717 730      let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
718 731      let stakedByUser = readStaked(stakedByUserKEY)
719 732      let stakedTotal = readStaked(stakedTotalKEY)
720 733      let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
721 734      let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
722 735      let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
723 736      let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
724 737      let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
725 738      let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
726 739      let passedBlocks = if ((emissionStartBlock > height))
727 740          then 0
728 741          else (height - emissionStartBlock)
729 742      let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
730 743      let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
731 -     let $t03010730219 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
732 -     let wxToClaimUserNew = $t03010730219._1
733 -     let integralSTATE = $t03010730219._2
734 -     let debug = $t03010730219._3
744 +     let $t03047730589 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
745 +     let wxToClaimUserNew = $t03047730589._1
746 +     let integralSTATE = $t03047730589._2
747 +     let debug = $t03047730589._3
735 748      let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
736 749      let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
737 750      let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
738 751      let boostDebug = asString(boostInvResult[1])
739 752      let minRewardPart = availableToClaim
740 -     let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
753 +     let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
741 754      let totalReward = (minRewardPart + boostRewardPart)
742 755      $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
743 756      }
744 757  
745 758  
746 759  
747 760  @Callable(i)
748 761  func stakedByUserREADONLY (lpAssetIdStr,userAddressStr) = {
749 762      let stakedByUser = valueOrElse(getInteger(keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
750 763      $Tuple2(nil, stakedByUser)
751 764      }
752 765  
753 766  
754 767  
755 768  @Callable(i)
756 769  func usersListTraversal (lpAssetId) = {
757 770      let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
758 771          then true
759 772          else mustManager(i)
760 773      if ((checkCaller == checkCaller))
761 774          then {
762 775              let listName = getUsersListName(lpAssetId)
763 776              let userOrUnit = getString(keyNextUser(lpAssetId))
764 777              let headOrUnit = getString(keyListHead(listName))
765 778              match userOrUnit {
766 779                  case _: Unit => 
767 780                      match headOrUnit {
768 781                          case _: Unit => 
769 782                              $Tuple2(nil, false)
770 783                          case head: String => 
771 784                              $Tuple2([StringEntry(keyNextUser(lpAssetId), head)], true)
772 785                          case _ => 
773 786                              throw("Match error")
774 787                      }
775 788                  case userAddress: String => 
776 789                      let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetId, userAddress))
777 790                      let poolAddress = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
778 791                      let wxToClaimUserNew = refreshINTEGRALS(lpAssetId, userAddress, poolAddress, 0)._1
779 792                      let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
780 793                      let throwIfNothingToClaim = true
781 794                      let r = if ((availableToClaim > zeroBigInt))
782 795                          then invoke(this, "claimWxINTERNAL", [lpAssetId, userAddress, throwIfNothingToClaim], nil)
783 796                          else unit
784 797                      if ((r == r))
785 798                          then {
786 799                              let nextUserOrUnit = getString(keyListNext(listName, userAddress))
787 800                              match nextUserOrUnit {
788 801                                  case _: Unit => 
789 802                                      $Tuple2([DeleteEntry(keyNextUser(lpAssetId))], false)
790 803                                  case nextUser: String => 
791 804                                      $Tuple2([StringEntry(keyNextUser(lpAssetId), nextUser)], true)
792 805                                  case _ => 
793 806                                      throw("Match error")
794 807                              }
795 808                              }
796 809                          else throw("Strict value is not equal to itself.")
797 810                  case _ => 
798 811                      throw("Match error")
799 812              }
800 813              }
801 814          else throw("Strict value is not equal to itself.")
802 815      }
803 816  
804 817  
805 818  
806 819  @Callable(i)
807 820  func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
808 -     then throw("permissions denied")
821 +     then throwErr("permissions denied")
809 822      else {
810 -         let $t03282532935 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
811 -         let wxPerLpIntegralNew = $t03282532935._1
812 -         let poolIntegralSTATE = $t03282532935._2
813 -         let poolDEBUG = $t03282532935._3
823 +         let $t03321333323 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
824 +         let wxPerLpIntegralNew = $t03321333323._1
825 +         let poolIntegralSTATE = $t03321333323._2
826 +         let poolDEBUG = $t03321333323._3
814 827          poolIntegralSTATE
815 828          }
816 829  
817 830  
818 831  @Verifier(tx)
819 832  func verify () = {
820 833      let targetPublicKey =     match managerPublicKeyOrUnit() {
821 834          case pk: ByteVector => 
822 835              pk
823 836          case _: Unit => 
824 837              tx.senderPublicKey
825 838          case _ => 
826 839              throw("Match error")
827 840      }
828 841      sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
829 842      }
830 843

Old	New		Differences
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let SCALE8 = 8
	5	+
	6	+	let MULT3 = 1000
5	7
6	8		let MULT8 = 100000000
7	9

27	29		case valAnyLyst: List[Any] =>
28	30		valAnyLyst
29	31		case _ =>
30		-	~~throw~~("fail to cast into List[Any]")
	32	+	throwErr("fail to cast into List[Any]")
31	33		}
32	34
33	35

35	37		case valInt: Int =>
36	38		valInt
37	39		case _ =>
38		-	~~throw~~("fail to cast into Int")
	40	+	throwErr("fail to cast into Int")
39	41		}
40	42
41	43

43	45		case valStr: String =>
44	46		valStr
45	47		case _ =>
46		-	~~throw~~("fail to cast into Int")
	48	+	throwErr("fail to cast into Int")
47	49		}
48	50
49	51

51	53		case valBin: ByteVector =>
52	54		valBin
53	55		case _ =>
54		-	~~throw~~("fail to cast into Int")
	56	+	throwErr("fail to cast into Int")
55	57		}
56	58
57	59
58		-	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
	60	+	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
59	61
60	62
61		-	func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
	63	+	func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
62	64
63	65
64	66		func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)

67	69		func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
68	70
69	71
70		-	func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
	72	+	func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
71	73
72	74
73	75		func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))

245	247
246	248		let boostingContract = getBoostingAddressOrFail(factoryCfg)
247	249
	250	+	let boostCoeff = {
	251	+	let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
	252	+	if ($isInstanceOf(@, "Int"))
	253	+	then @
	254	+	else throw(($getType(@) + " couldn't be cast to Int"))
	255	+	}
	256	+
248	257		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"))
249	258
250	259		func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)

282	291		let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
283	292		let checkNode = if (!(containsNode(listName, id)))
284	293		then true
285		-	else ~~throw~~("Node exists")
	294	+	else throwErr("Node exists")
286	295		if ((checkNode == checkNode))
287	296		then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
288	297		then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]

306	315		then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
307	316		else if ((id == valueOrElse(headOrUnit, "")))
308	317		then [DeleteEntry(keyListHead(listName))]
309		-	else ~~throw~~(((("invalid node: " + listName) + ".") + id))))
	318	+	else throwErr(((("invalid node: " + listName) + ".") + id))))
310	319		}
311	320
312	321

320	329		then (stakedByUser > zeroBigInt)
321	330		else false)
322	331		then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
323		-	else ~~throw~~("calcWxPerLpIntegralUserLast: unexpected state")
	332	+	else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
324	333
325	334
326	335		func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {

331	340		else stakedTotal
332	341		let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
333	342		let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
334		-	let MULT3 = 1000
335	343		let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
336		-	let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
	344	+	let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
337	345		let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
338	346		let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
339	347		let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)

357	365
358	366
359	367		func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
360		-	let $t01475014872 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
361		-	let wxPerLpIntegralNew = $t01475014872._1
362		-	let poolIntegralSTATE = $t01475014872._2
363		-	let poolDEBUG = $t01475014872._3
364		-	let MULT3 = 1000
	368	+	let $t01481914941 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
	369	+	let wxPerLpIntegralNew = $t01481914941._1
	370	+	let poolIntegralSTATE = $t01481914941._2
	371	+	let poolDEBUG = $t01481914941._3
365	372		let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
366	373		let stakedByUser = readStaked(stakedByUserKEY)
367	374		let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)

399	406		}
400	407
401	408
402		-	let permissionDeniedError = ~~throw~~("Permission denied")
	409	+	let permissionDeniedError = throwErr("Permission denied")
403	410
404	411		func mustThis (i) = if ((i.caller == this))
405	412		then true

433	440		if ((refreshStakedVote == refreshStakedVote))
434	441		then {
435	442		let stakedTotal = readStaked(stakedTotalKEY)
436		-	let $~~t01810718224~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
437		-	let wxToClaimUserNew = $~~t01810718224~~._1
438		-	let integralSTATE = $~~t01810718224~~._2
439		-	let debug = $~~t01810718224~~._3
	443	+	let $t01816018277 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
	444	+	let wxToClaimUserNew = $t01816018277._1
	445	+	let integralSTATE = $t01816018277._2
	446	+	let debug = $t01816018277._3
440	447		let listName = getUsersListName(lpAssetIdStr)
441	448		let listActions = if (containsNode(listName, userAddressStr))
442	449		then nil

476	483		else unit
477	484		if ((r == r))
478	485		then if ((amount > stakedByUser))
479		-	then ~~throw~~(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
	486	+	then throwErr(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
480	487		else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
481	488		else throw("Strict value is not equal to itself.")
482	489		}

526	533		let pm = pendingManagerPublicKeyOrUnit()
527	534		let hasPM = if (isDefined(pm))
528	535		then true
529		-	else ~~throw~~("No pending manager")
	536	+	else throwErr("No pending manager")
530	537		if ((hasPM == hasPM))
531	538		then {
532	539		let checkPM = if ((i.callerPublicKey == value(pm)))
533	540		then true
534		-	else ~~throw~~("You are not pending manager")
	541	+	else throwErr("You are not pending manager")
535	542		if ((checkPM == checkPM))
536	543		then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
537	544		else throw("Strict value is not equal to itself.")

543	550
544	551		@Callable(i)
545	552		func stake () = if ((size(i.payments) != 1))
546		-	then ~~throw~~("invalid payment - exact one payment must be attached")
	553	+	then throwErr("invalid payment - exact one payment must be attached")
547	554		else {
548	555		let pmt = i.payments[0]
549	556		let lpAssetId = value(pmt.assetId)
550	557		let lpAssetIdStr = toBase58String(lpAssetId)
551	558		let amount = pmt.amount
552		-	let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
	559	+	let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
553	560		let poolAddress = addressFromStringValue(poolAddressStr)
554	561		let userAddress = if ((i.caller == poolAddress))
555	562		then i.originCaller

561	568
562	569		@Callable(i)
563	570		func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
564		-	then ~~throw~~("invalid payment - exact one payment must be attached")
	571	+	then throwErr("invalid payment - exact one payment must be attached")
565	572		else {
566	573		let pmt = i.payments[0]
567	574		let lpAssetId = value(pmt.assetId)
568	575		let lpAssetIdStr = toBase58String(lpAssetId)
569	576		let amount = pmt.amount
570		-	let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
	577	+	let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
571	578		let poolAddress = addressFromStringValue(poolAddressStr)
572	579		let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
573	580		stakeActions(i, lpAssetId, poolAddress, userAddress, amount)

578	585		@Callable(i)
579	586		func unstake (lpAssetIdStr,amount) = {
580	587		let lpAssetId = fromBase58String(lpAssetIdStr)
581		-	let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
	588	+	let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr)))
582	589		let poolAddress = addressFromStringValue(poolAddressStr)
583	590		let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
584	591		let callerStr = toString(i.caller)

596	603		@Callable(i)
597	604		func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
598	605		let lpAssetIdStr = toBase58String(lpAssetId)
599		-	let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr)))
	606	+	let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), wrapErr(("unsupported lp asset " + lpAssetIdStr))))
600	607		let checkCaller = if ((i.caller == poolAddress))
601	608		then true
602	609		else permissionDeniedError

632	639		let checkCaller = mustThis(i)
633	640		if ((checkCaller == checkCaller))
634	641		then {
635		-	let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), "claimWxINTERNAL: invalid user address")
	642	+	let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
636	643		let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
637	644		let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
638	645		let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)

642	649		let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
643	650		let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
644	651		let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
645		-	let $~~t02618626298~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
646		-	let wxToClaimUserNew = $~~t02618626298~~._1
647		-	let integralSTATE = $~~t02618626298~~._2
648		-	let debug = $~~t02618626298~~._3
	652	+	let $t02631426426 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	653	+	let wxToClaimUserNew = $t02631426426._1
	654	+	let integralSTATE = $t02631426426._2
	655	+	let debug = $t02631426426._3
649	656		let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
650	657		if ((zeroBigInt >= availableToClaim))
651	658		then if (throwIfNothingToClaim)
652		-	then ~~throw~~("nothing to claim")
	659	+	then throwErr("nothing to claim")
653	660		else $Tuple2(nil, 0)
654	661		else {
655	662		let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
656	663		let minRewardPart = availableToClaim
657		-	let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
	664	+	let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
658	665		let totalReward = (minRewardPart + boostRewardPart)
659	666		let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
660	667		let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))

687	694		}, SEP)
688	695		let unclaimed = info[3]
689	696		let claimed = info[4]
690		-	let res = (resAcc :+ makeString(["%d%d", unclaimed, claimed], SEP))
	697	+	let userVoteFinalized = {
	698	+	let @ = invoke(boostingContract, "getUserVoteFinalizedREADONLY", [lpAssetId, userAddressStr], nil)
	699	+	if ($isInstanceOf(@, "Int"))
	700	+	then @
	701	+	else throw(($getType(@) + " couldn't be cast to Int"))
	702	+	}
	703	+	let res = (resAcc :+ makeString(["%d%d%d", unclaimed, claimed, toString(userVoteFinalized)], SEP))
691	704		let inv = {
692	705		let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
693	706		if ($isInstanceOf(@, "List[Any]"))

728	741		else (height - emissionStartBlock)
729	742		let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
730	743		let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
731		-	let $~~t03010730219~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
732		-	let wxToClaimUserNew = $~~t03010730219~~._1
733		-	let integralSTATE = $~~t03010730219~~._2
734		-	let debug = $~~t03010730219~~._3
	744	+	let $t03047730589 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	745	+	let wxToClaimUserNew = $t03047730589._1
	746	+	let integralSTATE = $t03047730589._2
	747	+	let debug = $t03047730589._3
735	748		let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
736	749		let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
737	750		let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
738	751		let boostDebug = asString(boostInvResult[1])
739	752		let minRewardPart = availableToClaim
740		-	let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
	753	+	let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
741	754		let totalReward = (minRewardPart + boostRewardPart)
742	755		$Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
743	756		}

805	818
806	819		@Callable(i)
807	820		func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
808		-	then ~~throw~~("permissions denied")
	821	+	then throwErr("permissions denied")
809	822		else {
810		-	let $~~t03282532935~~ = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
811		-	let wxPerLpIntegralNew = $~~t03282532935~~._1
812		-	let poolIntegralSTATE = $~~t03282532935~~._2
813		-	let poolDEBUG = $~~t03282532935~~._3
	823	+	let $t03321333323 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
	824	+	let wxPerLpIntegralNew = $t03321333323._1
	825	+	let poolIntegralSTATE = $t03321333323._2
	826	+	let poolDEBUG = $t03321333323._3
814	827		poolIntegralSTATE
815	828		}
816	829

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let SCALE8 = 8
	5	+
	6	+	let MULT3 = 1000
5	7
6	8		let MULT8 = 100000000
7	9
8	10		let SCALE18 = 18
9	11
10	12		let MULT18 = toBigInt(1000000000000000000)
11	13
12	14		let SEP = "__"
13	15
14	16		let POOLWEIGHTMULT = MULT8
15	17
16	18		let zeroBigInt = toBigInt(0)
17	19
18	20		let oneBigInt = toBigInt(1)
19	21
20	22		func wrapErr (msg) = makeString(["staking.ride:", toString(this), msg], " ")
21	23
22	24
23	25		func throwErr (msg) = throw(wrapErr(msg))
24	26
25	27
26	28		func asAnyList (val) = match val {
27	29		case valAnyLyst: List[Any] =>
28	30		valAnyLyst
29	31		case _ =>
30		-	~~throw~~("fail to cast into List[Any]")
	32	+	throwErr("fail to cast into List[Any]")
31	33		}
32	34
33	35
34	36		func asInt (val) = match val {
35	37		case valInt: Int =>
36	38		valInt
37	39		case _ =>
38		-	~~throw~~("fail to cast into Int")
	40	+	throwErr("fail to cast into Int")
39	41		}
40	42
41	43
42	44		func asString (val) = match val {
43	45		case valStr: String =>
44	46		valStr
45	47		case _ =>
46		-	~~throw~~("fail to cast into Int")
	48	+	throwErr("fail to cast into Int")
47	49		}
48	50
49	51
50	52		func asByteVector (val) = match val {
51	53		case valBin: ByteVector =>
52	54		valBin
53	55		case _ =>
54		-	~~throw~~("fail to cast into Int")
	56	+	throwErr("fail to cast into Int")
55	57		}
56	58
57	59
58		-	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
	60	+	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
59	61
60	62
61		-	func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
	63	+	func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((((("mandatory " + toString(address)) + ".") + key) + " is not defined")))
62	64
63	65
64	66		func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
65	67
66	68
67	69		func getIntOrDefault (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
68	70
69	71
70		-	func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
	72	+	func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((("mandatory this." + key) + " is not defined")))
71	73
72	74
73	75		func getBigIntFromStringOrZero (address,key) = value(parseBigInt(valueOrElse(getString(address, key), "0")))
74	76
75	77
76	78		func getBigIntFromStringOrDefault (address,key,defaultVal) = match getString(address, key) {
77	79		case s: String =>
78	80		value(parseBigInt(s))
79	81		case _: Unit =>
80	82		defaultVal
81	83		case _ =>
82	84		throw("Match error")
83	85		}
84	86
85	87
86	88		func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), MULT18, toBigInt(origScaleMult))
87	89
88	90
89	91		func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), MULT18))
90	92
91	93
92	94		func keyFactoryAddress () = "%s%s__config__factoryAddress"
93	95
94	96
95	97		func keyVotingEmissionContract () = "%s__votingEmissionContract"
96	98
97	99
98	100		let IdxFactoryCfgStakingDapp = 1
99	101
100	102		let IdxFactoryCfgBoostingDapp = 2
101	103
102	104		let IdxFactoryCfgIdoDapp = 3
103	105
104	106		let IdxFactoryCfgTeamDapp = 4
105	107
106	108		let IdxFactoryCfgEmissionDapp = 5
107	109
108	110		let IdxFactoryCfgRestDapp = 6
109	111
110	112		let IdxFactoryCfgSlippageDapp = 7
111	113
112	114		func keyFactoryCfg () = "%s__factoryConfig"
113	115
114	116
115	117		func keyManagerPublicKey () = "%s__managerPublicKey"
116	118
117	119
118	120		func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
119	121
120	122
121	123		func keyStablePoolAddonAddr () = "%s__stablePoolAddonAddr"
122	124
123	125
124	126		func keyAddonAddr () = "%s__addonAddr"
125	127
126	128
127	129		func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
128	130
129	131
130	132		func keyFactoryLpList () = "%s__lpTokensList"
131	133
132	134
133	135		func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
134	136
135	137
136	138		func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
137	139
138	140
139	141		func readLpList (factory) = split(valueOrElse(getString(factory, keyFactoryLpList()), ""), SEP)
140	142
141	143
142	144		func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
143	145
144	146
145	147		func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
146	148
147	149
148	150		func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
149	151
150	152
151	153		func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
152	154
153	155
154	156		func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
155	157
156	158
157	159		func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
158	160
159	161
160	162		func keyEmissionStartBlock () = "%s%s__emission__startBlock"
161	163
162	164
163	165		func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
164	166
165	167
166	168		func keyEmissionEndBlock () = "%s%s__emission__endBlock"
167	169
168	170
169	171		func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
170	172
171	173
172	174		func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
173	175
174	176
175	177		func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
176	178
177	179
178	180		func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
179	181
180	182
181	183		func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
182	184
183	185
184	186		func keyClaimedTotal (lpAssetIdStr) = makeString(["%s%s%s__claimed__total", lpAssetIdStr], SEP)
185	187
186	188
187	189		func readStaked (key) = valueOrElse(getInteger(this, key), 0)
188	190
189	191
190	192		func keyLastTotalLpBalance (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "bal"], SEP)
191	193
192	194
193	195		func keyLastUserLpBalance (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "bal"], SEP)
194	196
195	197
196	198		func keyTotalLpBalanceIntegral (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "balINT"], SEP)
197	199
198	200
199	201		func keyUserLpBalanceIntegral (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "balINT"], SEP)
200	202
201	203
202	204		func keyTotalLpBalanceIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s", lpAssetId, "total", "lastUpd"], SEP)
203	205
204	206
205	207		func keyUserLpBalanceIntegralLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s", lpAssetId, userAddress, "lastUpd"], SEP)
206	208
207	209
208	210		func keyWxPerLpIntegral (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpInt"], SEP)
209	211
210	212
211	213		func keyWxPerLpIntegralLastUpdHeight (lpAssetId) = makeString(["%s%s%s%s", lpAssetId, "common", "lpIntH"], SEP)
212	214
213	215
214	216		func keyWxToClaimUser (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpInt"], SEP)
215	217
216	218
217	219		func keyWxPerLpIntegralUserLastUpdHeight (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "lpIntH"], SEP)
218	220
219	221
220	222		func keyWxPerLp (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLp"], SEP)
221	223
222	224
223	225		func keyWxPerLpX18 (lpAssetId) = makeString(["%s", lpAssetId, "wxPerLpX18"], SEP)
224	226
225	227
226	228		func keyWxPerLpIntegralUserLast (lpAssetId,userAddress) = makeString(["%s%s%s%s", lpAssetId, userAddress, "uIntL"], SEP)
227	229
228	230
229	231		func keyOperationHistoryRecord (type,userAddress,txId58) = makeString(["%s%s%s%s__history", type, userAddress, txId58], SEP)
230	232
231	233
232	234		func formatHistoryRecord (userAddress,lpAssetId,type,amount) = makeString(["%s%s%s%d%d%d", userAddress, lpAssetId, type, toString(height), toString(lastBlock.timestamp), toString(amount)], SEP)
233	235
234	236
235	237		func OperationHistoryEntry (type,userAddress,lpAssetId,amount,txId) = StringEntry(keyOperationHistoryRecord(type, userAddress, toBase58String(txId)), formatHistoryRecord(userAddress, lpAssetId, type, amount))
236	238
237	239
238	240		let factoryAddress = getStringOrFail(this, keyFactoryAddress())
239	241
240	242		let factoryContract = addressFromStringValue(factoryAddress)
241	243
242	244		let factoryCfg = readFactoryCfgOrFail(factoryContract)
243	245
244	246		let emissionContract = getEmissionAddressOrFail(factoryCfg)
245	247
246	248		let boostingContract = getBoostingAddressOrFail(factoryCfg)
247	249
	250	+	let boostCoeff = {
	251	+	let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
	252	+	if ($isInstanceOf(@, "Int"))
	253	+	then @
	254	+	else throw(($getType(@) + " couldn't be cast to Int"))
	255	+	}
	256	+
248	257		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"))
249	258
250	259		func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)
251	260
252	261
253	262		func getUsersListName (lpAssetId) = makeString(["users", lpAssetId], SEP)
254	263
255	264
256	265		func keyListHead (listName) = makeString(["%s%s%s", listName, "head"], SEP)
257	266
258	267
259	268		func keyListSize (listName) = makeString(["%s%s%s", listName, "size"], SEP)
260	269
261	270
262	271		func keyListPrev (listName,id) = makeString(["%s%s%s%s", listName, id, "prev"], SEP)
263	272
264	273
265	274		func keyListNext (listName,id) = makeString(["%s%s%s%s", listName, id, "next"], SEP)
266	275
267	276
268	277		func containsNode (listName,id) = {
269	278		let headOrUnit = getString(this, keyListHead(listName))
270	279		let prevOrUnit = getString(this, keyListPrev(listName, id))
271	280		let nextOrUnit = getString(this, keyListNext(listName, id))
272	281		if (if ((id == valueOrElse(headOrUnit, "")))
273	282		then true
274	283		else (prevOrUnit != unit))
275	284		then true
276	285		else (nextOrUnit != unit)
277	286		}
278	287
279	288
280	289		func insertNodeActions (listName,id) = {
281	290		let headOrUnit = getString(this, keyListHead(listName))
282	291		let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
283	292		let checkNode = if (!(containsNode(listName, id)))
284	293		then true
285		-	else ~~throw~~("Node exists")
	294	+	else throwErr("Node exists")
286	295		if ((checkNode == checkNode))
287	296		then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
288	297		then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
289	298		else nil)) ++ [StringEntry(keyListHead(listName), id)])
290	299		else throw("Strict value is not equal to itself.")
291	300		}
292	301
293	302
294	303		func deleteNodeActions (listName,id) = {
295	304		let headOrUnit = getString(this, keyListHead(listName))
296	305		let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
297	306		let prevOrUnit = getString(this, keyListPrev(listName, id))
298	307		let nextOrUnit = getString(this, keyListNext(listName, id))
299	308		([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
300	309		then (nextOrUnit != unit)
301	310		else false)
302	311		then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
303	312		else if ((nextOrUnit != unit))
304	313		then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
305	314		else if ((prevOrUnit != unit))
306	315		then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
307	316		else if ((id == valueOrElse(headOrUnit, "")))
308	317		then [DeleteEntry(keyListHead(listName))]
309		-	else ~~throw~~(((("invalid node: " + listName) + ".") + id))))
	318	+	else throwErr(((("invalid node: " + listName) + ".") + id))))
310	319		}
311	320
312	321
313	322		func calcWxPerLpIntegralUserLast (stakedByUser,wxPerLpIntegralUserLastUpdHeightOrZero,wxPerLpIntegralNew,wxPerLpIntegralUserLastKEY) = if (if ((wxPerLpIntegralUserLastUpdHeightOrZero == zeroBigInt))
314	323		then (stakedByUser > zeroBigInt)
315	324		else false)
316	325		then zeroBigInt
317	326		else if ((stakedByUser == zeroBigInt))
318	327		then wxPerLpIntegralNew
319	328		else if (if ((wxPerLpIntegralUserLastUpdHeightOrZero > zeroBigInt))
320	329		then (stakedByUser > zeroBigInt)
321	330		else false)
322	331		then value(parseBigInt(getStringOrFail(this, wxPerLpIntegralUserLastKEY)))
323		-	else ~~throw~~("calcWxPerLpIntegralUserLast: unexpected state")
	332	+	else throwErr("calcWxPerLpIntegralUserLast: unexpected state")
324	333
325	334
326	335		func refreshPoolINTEGRALS (lpAssetIdStr,poolAddressStr,lpDeltaAmount) = {
327	336		let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
328	337		let stakedTotal = toBigInt(readStaked(stakedTotalKEY))
329	338		let nonZeroStakedTotal = if ((stakedTotal == zeroBigInt))
330	339		then oneBigInt
331	340		else stakedTotal
332	341		let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
333	342		let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
334		-	let MULT3 = 1000
335	343		let wxEmissionPerBlockX3 = (getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent()) * MULT3)
336		-	let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
	344	+	let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
337	345		let wxPerLpIntegralKEY = keyWxPerLpIntegral(lpAssetIdStr)
338	346		let wxPerLpIntegralLastUpdHeightKEY = keyWxPerLpIntegralLastUpdHeight(lpAssetIdStr)
339	347		let wxPerLpKEY = keyWxPerLp(lpAssetIdStr)
340	348		let wxPerLpIntegralLastUpdHeight = getIntOrDefault(this, wxPerLpIntegralLastUpdHeightKEY, emissionStartBlock)
341	349		let wxPerLpIntegral = getBigIntFromStringOrZero(this, wxPerLpIntegralKEY)
342	350		let wxPerLpOrZeroX3 = 0
343	351		let dh = max([(height - wxPerLpIntegralLastUpdHeight), 0])
344	352		let wxPerLpX3 = if ((wxPerLpOrZeroX3 != 0))
345	353		then toBigInt(wxPerLpOrZeroX3)
346	354		else fraction(toBigInt(poolWxEmissionPerBlockX3), toBigInt(MULT8), nonZeroStakedTotal)
347	355		let stakedTotalNew = (stakedTotal + toBigInt(lpDeltaAmount))
348	356		let nonZeroStakedTotalNew = if ((stakedTotalNew == zeroBigInt))
349	357		then oneBigInt
350	358		else stakedTotalNew
351	359		let wxPerLpIntegralNew = (wxPerLpIntegral + (wxPerLpX3 * toBigInt(dh)))
352	360		let wxPerLpX3New = (toBigInt(poolWxEmissionPerBlockX3) / nonZeroStakedTotalNew)
353	361		let wxPerLpIntegralLastUpdHeightNew = height
354	362		let debug = makeString([toString(wxPerLpIntegralNew), toString(dh), toString(wxPerLpX3), toString(stakedTotal), toString(poolWxEmissionPerBlockX3), toString(wxEmissionPerBlockX3), toString(poolWeight)], "::")
355	363		$Tuple3(wxPerLpIntegralNew, [StringEntry(wxPerLpIntegralKEY, toString(wxPerLpIntegralNew)), IntegerEntry(wxPerLpIntegralLastUpdHeightKEY, wxPerLpIntegralLastUpdHeightNew), StringEntry(wxPerLpKEY, toString(wxPerLpX3New))], debug)
356	364		}
357	365
358	366
359	367		func refreshINTEGRALS (lpAssetIdStr,userAddressStr,poolAddressStr,lpDeltaAmount) = {
360		-	let $t01475014872 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
361		-	let wxPerLpIntegralNew = $t01475014872._1
362		-	let poolIntegralSTATE = $t01475014872._2
363		-	let poolDEBUG = $t01475014872._3
364		-	let MULT3 = 1000
	368	+	let $t01481914941 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, lpDeltaAmount)
	369	+	let wxPerLpIntegralNew = $t01481914941._1
	370	+	let poolIntegralSTATE = $t01481914941._2
	371	+	let poolDEBUG = $t01481914941._3
365	372		let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
366	373		let stakedByUser = readStaked(stakedByUserKEY)
367	374		let wxToClaimUserKEY = keyWxToClaimUser(lpAssetIdStr, userAddressStr)
368	375		let wxPerLpIntegralUserLastUpdHeightKEY = keyWxPerLpIntegralUserLastUpdHeight(lpAssetIdStr, userAddressStr)
369	376		let wxPerLpIntegralUserLastKEY = keyWxPerLpIntegralUserLast(lpAssetIdStr, userAddressStr)
370	377		let wxToClaimUser = getBigIntFromStringOrZero(this, wxToClaimUserKEY)
371	378		let wxPerLpIntegralUserLastUpdHeightOrZero = getIntOrZero(this, wxPerLpIntegralUserLastUpdHeightKEY)
372	379		let wxPerLpIntegralUserLast = calcWxPerLpIntegralUserLast(toBigInt(stakedByUser), toBigInt(wxPerLpIntegralUserLastUpdHeightOrZero), wxPerLpIntegralNew, wxPerLpIntegralUserLastKEY)
373	380		let MULT11 = (MULT8 * MULT3)
374	381		let wxToClaimUserNew = max([(wxToClaimUser + fraction((wxPerLpIntegralNew - wxPerLpIntegralUserLast), toBigInt(stakedByUser), toBigInt(MULT11))), zeroBigInt])
375	382		let wxPerLpIntegralUserLastNew = wxPerLpIntegralNew
376	383		let wxPerLpIntegralUserLastUpdHeightNew = height
377	384		let debug = makeString([toString(wxToClaimUser), toString(wxPerLpIntegralUserLast), toString(stakedByUser), poolDEBUG, toString(height)], "::")
378	385		$Tuple3(wxToClaimUserNew, (poolIntegralSTATE ++ [StringEntry(wxToClaimUserKEY, toString(wxToClaimUserNew)), IntegerEntry(wxPerLpIntegralUserLastUpdHeightKEY, wxPerLpIntegralUserLastUpdHeightNew), StringEntry(wxPerLpIntegralUserLastKEY, toString(wxPerLpIntegralUserLastNew))]), debug)
379	386		}
380	387
381	388
382	389		func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
383	390		case s: String =>
384	391		fromBase58String(s)
385	392		case _: Unit =>
386	393		unit
387	394		case _ =>
388	395		throw("Match error")
389	396		}
390	397
391	398
392	399		func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
393	400		case s: String =>
394	401		fromBase58String(s)
395	402		case _: Unit =>
396	403		unit
397	404		case _ =>
398	405		throw("Match error")
399	406		}
400	407
401	408
402		-	let permissionDeniedError = ~~throw~~("Permission denied")
	409	+	let permissionDeniedError = throwErr("Permission denied")
403	410
404	411		func mustThis (i) = if ((i.caller == this))
405	412		then true
406	413		else permissionDeniedError
407	414
408	415
409	416		func mustManager (i) = match managerPublicKeyOrUnit() {
410	417		case pk: ByteVector =>
411	418		if ((i.callerPublicKey == pk))
412	419		then true
413	420		else permissionDeniedError
414	421		case _: Unit =>
415	422		if ((i.caller == this))
416	423		then true
417	424		else permissionDeniedError
418	425		case _ =>
419	426		throw("Match error")
420	427		}
421	428
422	429
423	430		func stakeActions (i,lpAssetId,poolAddress,userAddress,amount) = {
424	431		let userAddressStr = toString(userAddress)
425	432		let lpAssetIdStr = toBase58String(lpAssetId)
426	433		let poolAddressStr = toString(poolAddress)
427	434		let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
428	435		let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
429	436		let stakedByUser = readStaked(stakedByUserKEY)
430	437		let refreshStakedVote = if ((stakedByUser == 0))
431	438		then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
432	439		else unit
433	440		if ((refreshStakedVote == refreshStakedVote))
434	441		then {
435	442		let stakedTotal = readStaked(stakedTotalKEY)
436		-	let $~~t01810718224~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
437		-	let wxToClaimUserNew = $~~t01810718224~~._1
438		-	let integralSTATE = $~~t01810718224~~._2
439		-	let debug = $~~t01810718224~~._3
	443	+	let $t01816018277 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
	444	+	let wxToClaimUserNew = $t01816018277._1
	445	+	let integralSTATE = $t01816018277._2
	446	+	let debug = $t01816018277._3
440	447		let listName = getUsersListName(lpAssetIdStr)
441	448		let listActions = if (containsNode(listName, userAddressStr))
442	449		then nil
443	450		else insertNodeActions(listName, userAddressStr)
444	451		(([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
445	452		}
446	453		else throw("Strict value is not equal to itself.")
447	454		}
448	455
449	456
450	457		func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
451	458		let userAddressStr = toString(userAddress)
452	459		let lpAssetIdStr = toBase58String(lpAssetId)
453	460		let poolAddressStr = toString(poolAddress)
454	461		let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
455	462		let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
456	463		let stakedByUser = readStaked(stakedByUserKEY)
457	464		let stakedTotal = readStaked(stakedTotalKEY)
458	465		let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
459	466		let listName = getUsersListName(lpAssetIdStr)
460	467		let listActions = if (if (containsNode(listName, userAddressStr))
461	468		then (amount == stakedByUser)
462	469		else false)
463	470		then deleteNodeActions(listName, userAddressStr)
464	471		else nil
465	472		let refreshStakedVote = if ((amount == stakedByUser))
466	473		then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
467	474		else unit
468	475		if ((refreshStakedVote == refreshStakedVote))
469	476		then {
470	477		let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
471	478		let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1

github/deemru/w8io/3ef1775 
134.34 ms ◑