w8 · tx · 3Hz···FQt

tx · 3HzmJhCQEtWw3UA9RkuCzsYHWkJghLBMj6vX4Pd6eFQt

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.02400000 Waves

2023.05.25 09:15 [2593128] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3HzmJhCQEtWw3UA9RkuCzsYHWkJghLBMj6vX4Pd6eFQt",
    "fee": 2400000,
    "feeAssetId": null,
    "timestamp": 1684995360602,
    "version": 2,
    "chainId": 84,
    "sender": "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz",
    "senderPublicKey": "D28XoueZWsMfm8Y5pa6C5ZFuYoWgre2Wm8tzJANJgMnq",
    "proofs": [
        "26eTMhLqkeA1ENhNmMq4juxfMRBa4VipMXxH17FQGKtHawc7tQcCymK2QkKsXGBXj91btDGGjG5hERnEqvoUhKxS"
    ],
    "script": "base64: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",
    "height": 2593128,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Fp9S4mHAk6oQxjVSe7C5FBJ6uucYCeMqQ3UiMxoXMZz3
Next: 97pBBzSPacL7VX4tkvFFMsTe22HJwn3weKxhyKPtGvNE

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

Old	New		Differences
622	622		then {
623	623		let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("claimWxINTERNAL: invalid user address"))
624	624		let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
625		-	let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
626		-	let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
627		-	let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
628		-	let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
629		-	let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
630		-	let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
631		-	let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
632		-	let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
633		-	let $t02598426096 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
634		-	let wxToClaimUserNew = $t02598426096._1
635		-	let integralSTATE = $t02598426096._2
636		-	let debug = $t02598426096._3
637		-	let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
638		-	if ((zeroBigInt >= availableToClaim))
639		-	then if (throwIfNothingToClaim)
640		-	then throwErr("nothing to claim")
641		-	else $Tuple2(nil, 0)
642		-	else {
643		-	let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
644		-	let minRewardPart = availableToClaim
645		-	let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
646		-	let totalReward = (minRewardPart + boostRewardPart)
647		-	let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
648		-	let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
649		-	if ((emitBoost == emitBoost))
650		-	then {
651		-	let claimedByUserValue = ((claimedByUser + minRewardPart) + boostRewardPart)
652		-	let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
653		-	let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserBoostReward + boostRewardPart)
654		-	let claimedTotalPlusAvailableToClaim = (claimedTotal + availableToClaim)
655		-	$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))
	625	+	let onModifyWeightInv = invoke(this, "onModifyWeight", [lpAssetIdStr, poolAddressStr], nil)
	626	+	if ((onModifyWeightInv == onModifyWeightInv))
	627	+	then {
	628	+	let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
	629	+	let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
	630	+	let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
	631	+	let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
	632	+	let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
	633	+	let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
	634	+	let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
	635	+	let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
	636	+	let $t02608226194 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	637	+	let wxToClaimUserNew = $t02608226194._1
	638	+	let integralSTATE = $t02608226194._2
	639	+	let debug = $t02608226194._3
	640	+	let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
	641	+	if ((zeroBigInt >= availableToClaim))
	642	+	then if (throwIfNothingToClaim)
	643	+	then throwErr("nothing to claim")
	644	+	else $Tuple2(nil, 0)
	645	+	else {
	646	+	let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
	647	+	let minRewardPart = availableToClaim
	648	+	let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
	649	+	let totalReward = (minRewardPart + boostRewardPart)
	650	+	let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
	651	+	let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
	652	+	if ((emitBoost == emitBoost))
	653	+	then {
	654	+	let claimedByUserValue = ((claimedByUser + minRewardPart) + boostRewardPart)
	655	+	let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
	656	+	let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserBoostReward + boostRewardPart)
	657	+	let claimedTotalPlusAvailableToClaim = (claimedTotal + availableToClaim)
	658	+	$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))
	659	+	}
	660	+	else throw("Strict value is not equal to itself.")
656	661		}
657		-	else throw("Strict value is not equal to itself.")
658	662		}
	663	+	else throw("Strict value is not equal to itself.")
659	664		}
660	665		else throw("Strict value is not equal to itself.")
661	666		}

715	720		let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
716	721		let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
717	722		let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
718		-	let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
719		-	let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
720		-	let passedBlocks = if ((emissionStartBlock > height))
721		-	then 0
722		-	else (height - emissionStartBlock)
723		-	let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
724		-	let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
725		-	let $t03014730259 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
726		-	let wxToClaimUserNew = $t03014730259._1
727		-	let integralSTATE = $t03014730259._2
728		-	let debug = $t03014730259._3
729		-	let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
730		-	let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
731		-	let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
732		-	let boostDebug = asString(boostInvResult[1])
733		-	let minRewardPart = availableToClaim
734		-	let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
735		-	let totalReward = (minRewardPart + boostRewardPart)
736		-	$Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
	723	+	let onModifyWeightInv = invoke(this, "onModifyWeight", [lpAssetIdStr, poolAddressStr], nil)
	724	+	if ((onModifyWeightInv == onModifyWeightInv))
	725	+	then {
	726	+	let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
	727	+	let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
	728	+	let passedBlocks = if ((emissionStartBlock > height))
	729	+	then 0
	730	+	else (height - emissionStartBlock)
	731	+	let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
	732	+	let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
	733	+	let $t03034030452 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	734	+	let wxToClaimUserNew = $t03034030452._1
	735	+	let integralSTATE = $t03034030452._2
	736	+	let debug = $t03034030452._3
	737	+	let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
	738	+	let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
	739	+	let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
	740	+	let boostDebug = asString(boostInvResult[1])
	741	+	let minRewardPart = availableToClaim
	742	+	let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
	743	+	let totalReward = (minRewardPart + boostRewardPart)
	744	+	$Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
	745	+	}
	746	+	else throw("Strict value is not equal to itself.")
737	747		}
738	748
739	749

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

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

github/deemru/w8io/3ef1775 
122.17 ms ◑