w8 · tx · 6ST···r8p

tx · 6ST3R7oAds1sqwyPD7hgcnwuz3VwoQXYE2fdK8tegr8p

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.02400000 Waves

2023.03.24 14:59 [2504060] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6ST3R7oAds1sqwyPD7hgcnwuz3VwoQXYE2fdK8tegr8p",
    "fee": 2400000,
    "feeAssetId": null,
    "timestamp": 1679659199365,
    "version": 2,
    "chainId": 84,
    "sender": "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz",
    "senderPublicKey": "D28XoueZWsMfm8Y5pa6C5ZFuYoWgre2Wm8tzJANJgMnq",
    "proofs": [
        "4vC2chHZ1rMgovp4xNh7JrcxP3LjVLDDqiZxvkTW4feWWEc9DAAsJGwezPgkuDxWHr5kzgYgrNMqTZZpewWAo211"
    ],
    "script": "base64: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",
    "height": 2504060,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Ha2VyedYJfJzftgbk1YUW5XuRHJBwvYvitGFNbYHdHH4
Next: EbsRBQWZa8sJRpSdEuAtvhhzAdcEMshah6YSyeDUYVwo

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

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

245	247
246	248		let boostingContract = getBoostingAddressOrFail(factoryCfg)
247	249
	250	+	let boostCoeff = {
	251	+	let @ = invoke(emissionContract, "getBoostCoeffREADONLY", nil, nil)
	252	+	if ($isInstanceOf(@, "Int"))
	253	+	then @
	254	+	else throw(($getType(@) + " couldn't be cast to Int"))
	255	+	}
	256	+
248	257		let lpStakingPoolsContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(makeString(["%s", "lpStakingPoolsContract"], SEP)), wrapErr("lp_staking_pools contract address is undefined"))), wrapErr("invalid lp_staking_pools contract address"))
249	258
250	259		func keyNextUser (lpAssetId) = makeString(["%s%s", lpAssetId, "nextUser"], SEP)

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

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

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

642	649		let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
643	650		let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
644	651		let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
645		-	let $~~t02618626298~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
646		-	let wxToClaimUserNew = $~~t02618626298~~._1
647		-	let integralSTATE = $~~t02618626298~~._2
648		-	let debug = $~~t02618626298~~._3
	652	+	let $t02617926291 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	653	+	let wxToClaimUserNew = $t02617926291._1
	654	+	let integralSTATE = $t02617926291._2
	655	+	let debug = $t02617926291._3
649	656		let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
650	657		if ((zeroBigInt >= availableToClaim))
651	658		then if (throwIfNothingToClaim)

654	661		else {
655	662		let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
656	663		let minRewardPart = availableToClaim
657		-	let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
	664	+	let boostRewardPart = min([(minRewardPart * toBigInt((boostCoeff - 1))), toBigInt(wxAmountBoostTotal)])
658	665		let totalReward = (minRewardPart + boostRewardPart)
659	666		let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
660	667		let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))

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

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

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

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

github/deemru/w8io/873ac7e 
144.79 ms ◑