w8 · tx · 8Mx···B4d

tx · 8MxAtLqVjF8mQbBUFdkRTyJioWQ21dhHDymQ5HUwmB4d

3MsNhK6uve98J6DeqbuwGFBRh9GoHPGUFgp:  -0.03000000 Waves

2022.08.24 12:33 [2198387] smart account 3MsNhK6uve98J6DeqbuwGFBRh9GoHPGUFgp > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8MxAtLqVjF8mQbBUFdkRTyJioWQ21dhHDymQ5HUwmB4d",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1661333653422,
    "version": 1,
    "sender": "3MsNhK6uve98J6DeqbuwGFBRh9GoHPGUFgp",
    "senderPublicKey": "86RHVxKovtU7yKnepY8wKsd8niDxGAsiwuA1XA1DNqrS",
    "proofs": [
        "4E4Xk1vByi5SuNVrFrSjY3SEVPpqW4Z93eHxAuQKfmXYar5LJLPRFbEdojzBp6qoMmJMztjvsgn8hY7YfJoXXNVd"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2198387,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 7Th8QPrMcZe1NZYpuFz4gFFsb6GTQDF3rHDbhsxPn5BW
Next: G28EzNHP6orvXMcYiVied6QEnvyf28v4JtZhYj2qkaRe

Diff: 
Old New Differences
226 226  
227 227  
228 228  func keyAddonAddr () = "%s__addonAddr"
229 + 
230 + 
231 + func keyFeePermille () = "%s__feePermille"
229 232  
230 233  
231 234  let factoryDapp = readFactoryAddressOrFail()
512 515      let lpAmtAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[1], MULT8], nil))
513 516      let lpPriceAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[2], MULT8], nil))
514 517      let poolWeight = getIntegerValue(factoryDapp, keyFactoryPoolWeight(toString(poolAddress)))
515 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
518 +     let feePermille = getIntOrZero(poolAddress, keyFeePermille())
519 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight), toString(feePermille)], SEP))
516 520      }
517 521  
518 522  
542 546      let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, MULT18)
543 547      let inPrAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inPrAssetAmtX18), priceAssetDcm], nil))
544 548      let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
545 -     let $t02297323326 =     match res {
549 +     let $t02312823481 =     match res {
546 550          case _ => 
547 551              if (if (if ($isInstanceOf($match0._1, "Int"))
548 552                  then if ($isInstanceOf($match0._3, "Int"))
565 569                      }
566 570                  else throw("Couldn't cast types")
567 571      }
568 -     let calcLpAmt = $t02297323326._1
569 -     let curPriceCalc = $t02297323326._2
570 -     let amBalance = $t02297323326._3
571 -     let prBalance = $t02297323326._4
572 -     let lpEmission = $t02297323326._5
572 +     let calcLpAmt = $t02312823481._1
573 +     let curPriceCalc = $t02312823481._2
574 +     let amBalance = $t02312823481._3
575 +     let prBalance = $t02312823481._4
576 +     let lpEmission = $t02312823481._5
573 577      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
574 578      }
575 579  
600 604      let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, MULT18, curPriceX18)
601 605      let inAmAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inAmAssetAmtX18), amtAssetDcm], nil))
602 606      let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
603 -     let $t02589926252 =     match res {
607 +     let $t02605426407 =     match res {
604 608          case _ => 
605 609              if (if (if ($isInstanceOf($match0._1, "Int"))
606 610                  then if ($isInstanceOf($match0._3, "Int"))
623 627                      }
624 628                  else throw("Couldn't cast types")
625 629      }
626 -     let calcLpAmt = $t02589926252._1
627 -     let curPriceCalc = $t02589926252._2
628 -     let amBalance = $t02589926252._3
629 -     let prBalance = $t02589926252._4
630 -     let lpEmission = $t02589926252._5
630 +     let calcLpAmt = $t02605426407._1
631 +     let curPriceCalc = $t02605426407._2
632 +     let amBalance = $t02605426407._3
633 +     let prBalance = $t02605426407._4
634 +     let lpEmission = $t02605426407._5
631 635      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
632 636      }
633 637  
637 641  func poolEvaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
638 642      let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(paymentLpAssetId)))
639 643      let res = invoke(poolAddress, "estimateGetOperationWrapperREADONLY", ["", paymentLpAssetId, paymentLpAmt, toString(poolAddress)], nil)
640 -     let $t02694727364 =     match res {
644 +     let $t02710227519 =     match res {
641 645          case _ => 
642 646              if (if (if ($isInstanceOf($match0._1, "Int"))
643 647                  then if ($isInstanceOf($match0._2, "Int"))
666 670                      }
667 671                  else throw("Couldn't cast types")
668 672      }
669 -     let outAmAmt = $t02694727364._1
670 -     let outPrAmt = $t02694727364._2
671 -     let amBalance = $t02694727364._3
672 -     let prBalance = $t02694727364._4
673 -     let lpEmission = $t02694727364._5
674 -     let curPrice = $t02694727364._6
675 -     let poolStatus = $t02694727364._7
673 +     let outAmAmt = $t02710227519._1
674 +     let outPrAmt = $t02710227519._2
675 +     let amBalance = $t02710227519._3
676 +     let prBalance = $t02710227519._4
677 +     let lpEmission = $t02710227519._5
678 +     let curPrice = $t02710227519._6
679 +     let poolStatus = $t02710227519._7
676 680      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), curPrice, poolStatus], SEP))
677 681      }
678 682  
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 MULT8 = 100000000
7 7  
8 8  let SCALE18 = 18
9 9  
10 10  let MULT18 = toBigInt(1000000000000000000)
11 11  
12 12  let SEP = "__"
13 13  
14 14  let POOLWEIGHTMULT = MULT8
15 15  
16 16  let zeroBigInt = toBigInt(0)
17 17  
18 18  let idxPoolAddress = 1
19 19  
20 20  let idxPoolStatus = 2
21 21  
22 22  let idxPoolLPAssetId = 3
23 23  
24 24  let idxAmtAssetId = 4
25 25  
26 26  let idxPriceAssetId = 5
27 27  
28 28  let idxAmtAssetDcm = 6
29 29  
30 30  let idxPriceAssetDcm = 7
31 31  
32 32  let idxIAmtAssetId = 8
33 33  
34 34  let idxIPriceAssetId = 9
35 35  
36 36  let idxLPAssetDcm = 10
37 37  
38 38  func getStringOrFail (key) = valueOrErrorMessage(getString(key), (("mandatory this." + key) + " is not defined"))
39 39  
40 40  
41 41  func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
42 42  
43 43  
44 44  func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
45 45  
46 46  
47 47  func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
48 48  
49 49  
50 50  func asAnyList (val) = match val {
51 51      case valAnyLyst: List[Any] => 
52 52          valAnyLyst
53 53      case _ => 
54 54          throw("fail to cast into List[Any]")
55 55  }
56 56  
57 57  
58 58  func asInt (val) = match val {
59 59      case valInt: Int => 
60 60          valInt
61 61      case _ => 
62 62          throw("fail to cast into Int")
63 63  }
64 64  
65 65  
66 66  func asString (val) = match val {
67 67      case valStr: String => 
68 68          valStr
69 69      case _ => 
70 70          throw("fail to cast into String")
71 71  }
72 72  
73 73  
74 74  func keyFactoryAddress () = "%s%s__config__factoryAddress"
75 75  
76 76  
77 77  func keyManagerPublicKey () = "%s__managerPublicKey"
78 78  
79 79  
80 80  func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
81 81  
82 82  
83 83  let IdxFactoryCfgStakingDapp = 1
84 84  
85 85  let IdxFactoryCfgBoostingDapp = 2
86 86  
87 87  let IdxFactoryCfgIdoDapp = 3
88 88  
89 89  let IdxFactoryCfgTeamDapp = 4
90 90  
91 91  let IdxFactoryCfgEmissionDapp = 5
92 92  
93 93  let IdxFactoryCfgRestDapp = 6
94 94  
95 95  let IdxFactoryCfgSlippageDapp = 7
96 96  
97 97  let IdxFactoryCfgGwxRewardDapp = 8
98 98  
99 99  func keyFactoryCfg () = "%s__factoryConfig"
100 100  
101 101  
102 102  func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
103 103  
104 104  
105 105  func keyFactoryLpList () = "%s__lpTokensList"
106 106  
107 107  
108 108  func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
109 109  
110 110  
111 111  func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
112 112  
113 113  
114 114  func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(keyFactoryAddress()))
115 115  
116 116  
117 117  func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
118 118  
119 119  
120 120  func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
121 121  
122 122  
123 123  func getBoostingAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgBoostingDapp])
124 124  
125 125  
126 126  func getEmissionAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgEmissionDapp])
127 127  
128 128  
129 129  func getStakingAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgStakingDapp])
130 130  
131 131  
132 132  func getGwxRewardAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgGwxRewardDapp])
133 133  
134 134  
135 135  func keyBoostCfg () = "%s__config"
136 136  
137 137  
138 138  func keyBoostingLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
139 139  
140 140  
141 141  func keyBoostingStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
142 142  
143 143  
144 144  func keyBoostingStatsLocksCount () = "%s%s__stats__locksCount"
145 145  
146 146  
147 147  func keyBoostingStatsUsersCount () = "%s%s__stats__activeUsersCount"
148 148  
149 149  
150 150  func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
151 151  
152 152  
153 153  func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
154 154  
155 155  
156 156  func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
157 157  
158 158  
159 159  func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
160 160  
161 161  
162 162  func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
163 163  
164 164  
165 165  func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
166 166  
167 167  
168 168  func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
169 169  
170 170  
171 171  func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
172 172  
173 173  
174 174  func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
175 175  
176 176  
177 177  func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
178 178  
179 179  
180 180  func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
181 181  
182 182  
183 183  func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
184 184  
185 185  
186 186  func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
187 187  
188 188  
189 189  func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
190 190  
191 191  
192 192  func keyTotalCachedGwx () = "%s%s__gwxCached__total"
193 193  
194 194  
195 195  func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
196 196  
197 197  
198 198  func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
199 199  
200 200  
201 201  func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
202 202  
203 203  
204 204  func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
205 205  
206 206  
207 207  func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
208 208  
209 209  
210 210  func readStaked (stakingDapp,key) = valueOrElse(getInteger(stakingDapp, key), 0)
211 211  
212 212  
213 213  func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
214 214  
215 215  
216 216  func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
217 217  
218 218  
219 219  func keyEmissionStartBlock () = "%s%s__emission__startBlock"
220 220  
221 221  
222 222  func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
223 223  
224 224  
225 225  func keyEmissionEndBlock () = "%s%s__emission__endBlock"
226 226  
227 227  
228 228  func keyAddonAddr () = "%s__addonAddr"
229 + 
230 + 
231 + func keyFeePermille () = "%s__feePermille"
229 232  
230 233  
231 234  let factoryDapp = readFactoryAddressOrFail()
232 235  
233 236  let factoryCfg = readFactoryCfgOrFail(factoryDapp)
234 237  
235 238  let emissionDapp = getEmissionAddressOrFail(factoryCfg)
236 239  
237 240  let stakingDapp = getStakingAddressOrFail(factoryCfg)
238 241  
239 242  let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
240 243  
241 244  let boostingDapp = getBoostingAddressOrFail(factoryCfg)
242 245  
243 246  func internalCurrentRewardRate (lpAssetId) = {
244 247      let poolAddressStr = getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
245 248      let poolWeightMult = MULT8
246 249      let poolWeight = getIntegerValue(factoryDapp, keyFactoryPoolWeight(poolAddressStr))
247 250      let wxEmissionPerBlock = getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent())
248 251      let wxEmissionPerBlockMax = getIntOrFail(emissionDapp, keyEmissionRatePerBlockMaxCurrent())
249 252      let boostMaxCoeff = 3
250 253      let poolWxEmissionPerBlock = (fraction(wxEmissionPerBlock, poolWeight, poolWeightMult) / boostMaxCoeff)
251 254      let poolWxEmissionPerBlockMax = fraction(wxEmissionPerBlockMax, poolWeight, poolWeightMult)
252 255      let maxFactor = (boostMaxCoeff * MULT8)
253 256      let totalLpStaked = getIntOrZero(stakingDapp, keyStakedTotal(lpAssetId))
254 257  [poolWxEmissionPerBlock, maxFactor, totalLpStaked]
255 258      }
256 259  
257 260  
258 261  func calcGwxAmountStartREADONLY (lockAmount,lockDuration,maxLockDuration) = {
259 262      let coeffX8 = fraction(lockDuration, MULT8, maxLockDuration)
260 263      let gWxAmountStart = fraction(lockAmount, coeffX8, MULT8)
261 264  [gWxAmountStart]
262 265      }
263 266  
264 267  
265 268  func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
266 269      case s: String => 
267 270          fromBase58String(s)
268 271      case _: Unit => 
269 272          unit
270 273      case _ => 
271 274          throw("Match error")
272 275  }
273 276  
274 277  
275 278  func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
276 279      case s: String => 
277 280          fromBase58String(s)
278 281      case _: Unit => 
279 282          unit
280 283      case _ => 
281 284          throw("Match error")
282 285  }
283 286  
284 287  
285 288  func mustManager (i) = {
286 289      let pd = throw("Permission denied")
287 290      match managerPublicKeyOrUnit() {
288 291          case pk: ByteVector => 
289 292              if ((i.callerPublicKey == pk))
290 293                  then true
291 294                  else pd
292 295          case _: Unit => 
293 296              if ((i.caller == this))
294 297                  then true
295 298                  else pd
296 299          case _ => 
297 300              throw("Match error")
298 301      }
299 302      }
300 303  
301 304  
302 305  @Callable(i)
303 306  func constructor (factoryAddress) = {
304 307      let checkCaller = mustManager(i)
305 308      if ((checkCaller == checkCaller))
306 309          then [StringEntry(keyFactoryAddress(), factoryAddress)]
307 310          else throw("Strict value is not equal to itself.")
308 311      }
309 312  
310 313  
311 314  
312 315  @Callable(i)
313 316  func currentRewardRateREADONLY (lpAssetId) = {
314 317      let rewardData = internalCurrentRewardRate(lpAssetId)
315 318      let wxEmissionPerBlock = rewardData[0]
316 319      let maxFactor = rewardData[1]
317 320      let totalLpStaked = rewardData[2]
318 321      $Tuple2(nil, makeString(["%d%d%d", toString(wxEmissionPerBlock), toString(maxFactor), toString(totalLpStaked)], SEP))
319 322      }
320 323  
321 324  
322 325  
323 326  @Callable(i)
324 327  func currentUserRewardRateREADONLY (lpAssetId,userAddress) = {
325 328      let rewardData = internalCurrentRewardRate(lpAssetId)
326 329      let wxEmissionPerBlock = rewardData[0]
327 330      let maxFactor = rewardData[1]
328 331      let totalLpStaked = rewardData[2]
329 332      let lpStakedByUser = getIntOrZero(stakingDapp, keyStakedByUser(userAddress, lpAssetId))
330 333      let userClaimInfo = split(asString(invoke(stakingDapp, "claimWxREADONLY", [lpAssetId, userAddress], nil)), SEP)
331 334      let minRewardPart = valueOrErrorMessage(parseInt(userClaimInfo[5]), "couldn't parse minRewardPart")
332 335      let boostRewardPart = valueOrErrorMessage(parseInt(userClaimInfo[6]), "couldn't parse boostRewardPart")
333 336      let debug = userClaimInfo[7]
334 337      let boostingPower = if ((boostRewardPart == 0))
335 338          then (1 * MULT8)
336 339          else fraction((minRewardPart + boostRewardPart), MULT8, minRewardPart)
337 340      $Tuple2(nil, makeString(["%d%d%d%d%d%s", toString(wxEmissionPerBlock), toString(maxFactor), toString(totalLpStaked), toString(lpStakedByUser), toString(boostingPower), debug], SEP))
338 341      }
339 342  
340 343  
341 344  
342 345  @Callable(i)
343 346  func claimedRewardREADONLY (userAddress) = {
344 347      let lpList = readLpList()
345 348      let prefix = "%s%d%d%d%s"
346 349      func claimedRewardByLpAggregator (resultStr,nextLp) =     {
347 350          let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(nextLp, userAddress)
348 351          let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(nextLp, userAddress)
349 352          let minRewardClaimed = valueOrElse(getInteger(stakingDapp, claimedByUserMinRewardKEY), 0)
350 353          let boostRewardClaimed = valueOrElse(getInteger(stakingDapp, claimedByUserBoostRewardKEY), 0)
351 354          let gFeeClaimed = 0
352 355          makeString([(prefix + resultStr), nextLp, toString(minRewardClaimed), toString(boostRewardClaimed), toString(gFeeClaimed), "end"], SEP)
353 356          }
354 357  
355 358      let result = {
356 359          let $l = lpList
357 360          let $s = size($l)
358 361          let $acc0 = "%s"
359 362          func $f0_1 ($a,$i) =         if (($i >= $s))
360 363              then $a
361 364              else claimedRewardByLpAggregator($a, $l[$i])
362 365  
363 366          func $f0_2 ($a,$i) =         if (($i >= $s))
364 367              then $a
365 368              else throw("List size exceeds 10")
366 369  
367 370          $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
368 371          }
369 372      $Tuple2(nil, ((result + SEP) + userAddress))
370 373      }
371 374  
372 375  
373 376  
374 377  @Callable(i)
375 378  func calcBoostBulkInternalREADONLY (currentIter,deltaWxAmountBulk,deltaLockPeriodInBlocksBulk,deltaLpAmountBulk,lpAssetIdOptBulk,userAddressOpt,resAcc) = if ((currentIter == size(deltaWxAmountBulk)))
376 379      then $Tuple2(nil, resAcc)
377 380      else {
378 381          let deltaWxAmount = deltaWxAmountBulk[currentIter]
379 382          let deltaLockPeriodInBlocks = deltaLockPeriodInBlocksBulk[currentIter]
380 383          let deltaLpAmount = deltaLpAmountBulk[currentIter]
381 384          let lpAssetIdOpt = lpAssetIdOptBulk[currentIter]
382 385          let info = {
383 386              let @ = invoke(this, "calcBoostREADONLY", [deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt], nil)
384 387              if ($isInstanceOf(@, "String"))
385 388                  then @
386 389                  else throw(($getType(invoke(this, "calcBoostREADONLY", [deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt], nil)) + " couldn't be cast to String"))
387 390              }
388 391          let res = (resAcc :+ info)
389 392          let inv = {
390 393              let @ = invoke(this, "calcBoostBulkInternalREADONLY", [(currentIter + 1), deltaWxAmountBulk, deltaLockPeriodInBlocksBulk, deltaLpAmountBulk, lpAssetIdOptBulk, userAddressOpt, res], nil)
391 394              if ($isInstanceOf(@, "List[Any]"))
392 395                  then @
393 396                  else throw(($getType(invoke(this, "calcBoostBulkInternalREADONLY", [(currentIter + 1), deltaWxAmountBulk, deltaLockPeriodInBlocksBulk, deltaLpAmountBulk, lpAssetIdOptBulk, userAddressOpt, res], nil)) + " couldn't be cast to List[Any]"))
394 397              }
395 398          if ((inv == inv))
396 399              then $Tuple2(nil, inv)
397 400              else throw("Strict value is not equal to itself.")
398 401          }
399 402  
400 403  
401 404  
402 405  @Callable(i)
403 406  func calcBoostBulkREADONLY (deltaWxAmount,deltaLockPeriodInBlocks,deltaLpAmount,lpAssetIdOpt,userAddressOpt) = {
404 407      let res = invoke(this, "calcBoostBulkInternalREADONLY", [0, deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt, nil], nil)
405 408      $Tuple2(nil, res)
406 409      }
407 410  
408 411  
409 412  
410 413  @Callable(i)
411 414  func calcBoostREADONLY (deltaWxAmount,deltaLockPeriodInBlocks,deltaLpAmount,lpAssetIdOpt,userAddressOpt) = {
412 415      let mathDapp = gwxRewardDapp
413 416      let EMPTYSTR = "empty"
414 417      let maxLockDurationInBlocks = parseIntValue(split(getStringByAddressOrFail(boostingDapp, keyBoostCfg()), SEP)[4])
415 418      let lpAssetIdStr = if ((lpAssetIdOpt == ""))
416 419          then EMPTYSTR
417 420          else lpAssetIdOpt
418 421      let userAddressStr = if ((userAddressOpt == ""))
419 422          then EMPTYSTR
420 423          else userAddressOpt
421 424      let userNumStr = valueOrElse(getString(boostingDapp, keyUser2NumMapping(userAddressOpt)), EMPTYSTR)
422 425      let userAmount = valueOrElse(getInteger(boostingDapp, keyLockParamUserAmount(userNumStr)), 0)
423 426      let lockStart = valueOrElse(getInteger(boostingDapp, keyLockParamStartBlock(userNumStr)), height)
424 427      let lockDuration = valueOrElse(getInteger(boostingDapp, keyLockParamDuration(userNumStr)), 0)
425 428      let lockEnd = (lockStart + lockDuration)
426 429      let remainingDuration = max([(lockEnd - height), 0])
427 430      let userAmountNew = (userAmount + deltaWxAmount)
428 431      let lockDurationNew = min([(remainingDuration + deltaLockPeriodInBlocks), maxLockDurationInBlocks])
429 432      let userCurrgWxAmount = asInt(asAnyList(invoke(boostingDapp, "gwxUserInfoREADONLY", [userAddressStr], nil))[0])
430 433      let gWxAmountStartNew = calcGwxAmountStartREADONLY(userAmountNew, lockDurationNew, maxLockDurationInBlocks)[0]
431 434      let gWxParamsResultList = asAnyList(invoke(mathDapp, "calcGwxParamsREADONLY", [gWxAmountStartNew, height, lockDurationNew], nil))
432 435      let gWxAmountDiff = (gWxAmountStartNew - userCurrgWxAmount)
433 436      let k = asInt(gWxParamsResultList[0])
434 437      let b = asInt(gWxParamsResultList[1])
435 438      let period = toString(asInt(gWxParamsResultList[2]))
436 439      let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
437 440      let totalCachedGwxKEY = keyTotalCachedGwx()
438 441      let userMaxBoostIntNew = ((gWxAmountStartNew * lockDurationNew) / 2)
439 442      let totalMaxBoostInt = getIntOrZero(boostingDapp, totalMaxBoostIntegralKEY)
440 443      let totalCachedGwx = valueOrElse(getInteger(boostingDapp, totalCachedGwxKEY), 0)
441 444      let MULT3 = 1000
442 445      let wxEmissionPerBlockX3 = (getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent()) * MULT3)
443 446      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
444 447      let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
445 448      let stakedByUser = readStaked(stakingDapp, stakedByUserKEY)
446 449      let stakedTotal = readStaked(stakingDapp, stakedTotalKEY)
447 450      let stakedByUserNew = (stakedByUser + deltaLpAmount)
448 451      let stakedTotalNew = (stakedTotal + deltaLpAmount)
449 452      let poolWeight = if ((lpAssetIdStr != EMPTYSTR))
450 453          then {
451 454              let poolAddressStr = valueOrErrorMessage(getString(factoryDapp, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
452 455              getIntegerValue(factoryDapp, keyFactoryPoolWeight(poolAddressStr))
453 456              }
454 457          else 0
455 458      let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
456 459      let wxPerLpX3 = if ((stakedTotalNew != 0))
457 460          then fraction(poolWxEmissionPerBlockX3, MULT8, stakedTotalNew)
458 461          else 0
459 462      let userWxPerBlockX3 = fraction(wxPerLpX3, stakedByUserNew, MULT8)
460 463      let boostEmissionPerBlockX3 = (poolWxEmissionPerBlockX3 * 2)
461 464      let tmpUserBoostPerBlockX3 = fraction(gWxAmountStartNew, boostEmissionPerBlockX3, (totalCachedGwx + gWxAmountDiff))
462 465      let userBoostPerBlockX3 = min([tmpUserBoostPerBlockX3, (userWxPerBlockX3 * 2)])
463 466      let boostCoeff = if ((userWxPerBlockX3 == 0))
464 467          then (1 * MULT8)
465 468          else fraction((userBoostPerBlockX3 + userWxPerBlockX3), MULT8, userWxPerBlockX3)
466 469      $Tuple2(nil, makeString(["%d%d%s", toString(gWxAmountStartNew), toString(boostCoeff), "d"], SEP))
467 470      }
468 471  
469 472  
470 473  
471 474  @Callable(i)
472 475  func wxEmissionStatsREADONLY () = {
473 476      let ONEMULT = toString(MULT8)
474 477      let ONE = "1"
475 478      let wxEmissionPerBlock = getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent())
476 479      let emissionStartBlock = getIntOrFail(emissionDapp, keyEmissionStartBlock())
477 480      let passedBlocks = if ((emissionStartBlock > height))
478 481          then 0
479 482          else (height - emissionStartBlock)
480 483      let teamEmDuration = (1440 * 365)
481 484      let teamEmMax = (201000000 * MULT8)
482 485      let teamEm = if ((passedBlocks > teamEmDuration))
483 486          then teamEmMax
484 487          else fraction(teamEmMax, passedBlocks, teamEmDuration)
485 488      let totalWxReleased = ((wxEmissionPerBlock * passedBlocks) + teamEm)
486 489      let totalWxLocked = getIntOrZero(boostingDapp, keyBoostingLockParamTotalAmount())
487 490      let locksDurationSumInBlocks = getIntOrZero(boostingDapp, keyBoostingStatsLocksDurationSumInBlocks())
488 491      let locksCount = getIntOrZero(boostingDapp, keyBoostingStatsLocksCount())
489 492      $Tuple2(nil, makeString(["%d%d%d%d", toString(totalWxReleased), toString(totalWxLocked), toString(locksDurationSumInBlocks), toString(locksCount)], SEP))
490 493      }
491 494  
492 495  
493 496  
494 497  @Callable(i)
495 498  func poolStatsREADONLY (lpAsset) = {
496 499      let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAsset)))
497 500      let cfg = asAnyList(invoke(poolAddress, "getPoolConfigWrapperREADONLY", nil, nil))
498 501      let lpAssetId = fromBase58String(asString(cfg[idxPoolLPAssetId]))
499 502      let amtAssetId = asString(cfg[idxAmtAssetId])
500 503      let priceAssetId = asString(cfg[idxPriceAssetId])
501 504      let iAmtAssetId = asString(cfg[idxIAmtAssetId])
502 505      let iPriceAssetId = asString(cfg[idxIPriceAssetId])
503 506      let amtAssetDcm = parseIntValue(asString(cfg[idxAmtAssetDcm]))
504 507      let priceAssetDcm = parseIntValue(asString(cfg[idxPriceAssetDcm]))
505 508      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
506 509      let accAmtAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [amtAssetId], nil))
507 510      let accPriceAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [priceAssetId], nil))
508 511      let pricesList = if ((poolLPBalance == 0))
509 512          then [toString(zeroBigInt), toString(zeroBigInt), toString(zeroBigInt)]
510 513          else asAnyList(invoke(poolAddress, "calcPricesWrapperREADONLY", [accAmtAssetBalance, accPriceAssetBalance, poolLPBalance], nil))
511 514      let curPrice = 0
512 515      let lpAmtAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[1], MULT8], nil))
513 516      let lpPriceAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[2], MULT8], nil))
514 517      let poolWeight = getIntegerValue(factoryDapp, keyFactoryPoolWeight(toString(poolAddress)))
515 -     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
518 +     let feePermille = getIntOrZero(poolAddress, keyFeePermille())
519 +     $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight), toString(feePermille)], SEP))
516 520      }
517 521  
518 522  
519 523  
520 524  @Callable(i)
521 525  func poolEvaluatePutByAmountAssetREADONLY (lpAsset,inAmAssetAmt) = {
522 526      let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAsset)))
523 527      let cfg = asAnyList(invoke(poolAddress, "getPoolConfigWrapperREADONLY", nil, nil))
524 528      let lpAssetId = fromBase58String(asString(cfg[idxPoolLPAssetId]))
525 529      let amAssetIdStr = asString(cfg[idxAmtAssetId])
526 530      let amAssetId = fromBase58String(amAssetIdStr)
527 531      let prAssetIdStr = asString(cfg[idxPriceAssetId])
528 532      let prAssetId = fromBase58String(prAssetIdStr)
529 533      let amtAssetDcm = parseIntValue(asString(cfg[idxAmtAssetDcm]))
530 534      let priceAssetDcm = parseIntValue(asString(cfg[idxPriceAssetDcm]))
531 535      let poolStatus = asString(cfg[idxPoolStatus])
532 536      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
533 537      let accAmtAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [amAssetIdStr], nil))
534 538      let accPriceAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [prAssetIdStr], nil))
535 539      let amtAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [accAmtAssetBalance, amtAssetDcm], nil)))
536 540      let priceAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [accPriceAssetBalance, priceAssetDcm], nil)))
537 541      let curPriceX18 = if ((poolLPBalance == 0))
538 542          then zeroBigInt
539 543          else parseBigIntValue(asString(invoke(poolAddress, "calcPriceBigIntWrapperREADONLY", [toString(priceAssetAmtX18), toString(amtAssetAmtX18)], nil)))
540 544      let curPrice = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(curPriceX18), MULT8], nil))
541 545      let inAmAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [inAmAssetAmt, amtAssetDcm], nil)))
542 546      let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, MULT18)
543 547      let inPrAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inPrAssetAmtX18), priceAssetDcm], nil))
544 548      let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
545 -     let $t02297323326 =     match res {
549 +     let $t02312823481 =     match res {
546 550          case _ => 
547 551              if (if (if ($isInstanceOf($match0._1, "Int"))
548 552                  then if ($isInstanceOf($match0._3, "Int"))
549 553                      then if ($isInstanceOf($match0._4, "Int"))
550 554                          then if ($isInstanceOf($match0._5, "Int"))
551 555                              then $isInstanceOf($match0._6, "Int")
552 556                              else false
553 557                          else false
554 558                      else false
555 559                  else false)
556 560                  then (size($match0) == 13)
557 561                  else false)
558 562                  then {
559 563                      let calcLpAmt = $match0._1
560 564                      let curPriceCalc = $match0._3
561 565                      let amBalance = $match0._4
562 566                      let prBalance = $match0._5
563 567                      let lpEmission = $match0._6
564 568                      $Tuple5(calcLpAmt, curPriceCalc, amBalance, prBalance, lpEmission)
565 569                      }
566 570                  else throw("Couldn't cast types")
567 571      }
568 -     let calcLpAmt = $t02297323326._1
569 -     let curPriceCalc = $t02297323326._2
570 -     let amBalance = $t02297323326._3
571 -     let prBalance = $t02297323326._4
572 -     let lpEmission = $t02297323326._5
572 +     let calcLpAmt = $t02312823481._1
573 +     let curPriceCalc = $t02312823481._2
574 +     let amBalance = $t02312823481._3
575 +     let prBalance = $t02312823481._4
576 +     let lpEmission = $t02312823481._5
573 577      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
574 578      }
575 579  
576 580  
577 581  
578 582  @Callable(i)
579 583  func poolEvaluatePutByPriceAssetREADONLY (lpAsset,inPrAssetAmt) = {
580 584      let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAsset)))
581 585      let cfg = asAnyList(invoke(poolAddress, "getPoolConfigWrapperREADONLY", nil, nil))
582 586      let lpAssetId = fromBase58String(asString(cfg[idxPoolLPAssetId]))
583 587      let amAssetIdStr = asString(cfg[idxAmtAssetId])
584 588      let amAssetId = fromBase58String(amAssetIdStr)
585 589      let prAssetIdStr = asString(cfg[idxPriceAssetId])
586 590      let prAssetId = fromBase58String(prAssetIdStr)
587 591      let amtAssetDcm = parseIntValue(asString(cfg[idxAmtAssetDcm]))
588 592      let priceAssetDcm = parseIntValue(asString(cfg[idxPriceAssetDcm]))
589 593      let poolStatus = asString(cfg[idxPoolStatus])
590 594      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
591 595      let amBalanceRaw = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [amAssetIdStr], nil))
592 596      let prBalanceRaw = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [prAssetIdStr], nil))
593 597      let amBalanceRawX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [amBalanceRaw, amtAssetDcm], nil)))
594 598      let prBalanceRawX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [prBalanceRaw, priceAssetDcm], nil)))
595 599      let curPriceX18 = if ((poolLPBalance == 0))
596 600          then zeroBigInt
597 601          else parseBigIntValue(asString(invoke(poolAddress, "calcPriceBigIntWrapperREADONLY", [toString(prBalanceRawX18), toString(amBalanceRawX18)], nil)))
598 602      let curPrice = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(curPriceX18), MULT8], nil))
599 603      let inPrAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [inPrAssetAmt, priceAssetDcm], nil)))
600 604      let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, MULT18, curPriceX18)
601 605      let inAmAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inAmAssetAmtX18), amtAssetDcm], nil))
602 606      let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
603 -     let $t02589926252 =     match res {
607 +     let $t02605426407 =     match res {
604 608          case _ => 
605 609              if (if (if ($isInstanceOf($match0._1, "Int"))
606 610                  then if ($isInstanceOf($match0._3, "Int"))
607 611                      then if ($isInstanceOf($match0._4, "Int"))
608 612                          then if ($isInstanceOf($match0._5, "Int"))
609 613                              then $isInstanceOf($match0._6, "Int")
610 614                              else false
611 615                          else false
612 616                      else false
613 617                  else false)
614 618                  then (size($match0) == 13)
615 619                  else false)
616 620                  then {
617 621                      let calcLpAmt = $match0._1
618 622                      let curPriceCalc = $match0._3
619 623                      let amBalance = $match0._4
620 624                      let prBalance = $match0._5
621 625                      let lpEmission = $match0._6
622 626                      $Tuple5(calcLpAmt, curPriceCalc, amBalance, prBalance, lpEmission)
623 627                      }
624 628                  else throw("Couldn't cast types")
625 629      }
626 -     let calcLpAmt = $t02589926252._1
627 -     let curPriceCalc = $t02589926252._2
628 -     let amBalance = $t02589926252._3
629 -     let prBalance = $t02589926252._4
630 -     let lpEmission = $t02589926252._5
630 +     let calcLpAmt = $t02605426407._1
631 +     let curPriceCalc = $t02605426407._2
632 +     let amBalance = $t02605426407._3
633 +     let prBalance = $t02605426407._4
634 +     let lpEmission = $t02605426407._5
631 635      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
632 636      }
633 637  
634 638  
635 639  
636 640  @Callable(i)
637 641  func poolEvaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
638 642      let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(paymentLpAssetId)))
639 643      let res = invoke(poolAddress, "estimateGetOperationWrapperREADONLY", ["", paymentLpAssetId, paymentLpAmt, toString(poolAddress)], nil)
640 -     let $t02694727364 =     match res {
644 +     let $t02710227519 =     match res {
641 645          case _ => 
642 646              if (if (if ($isInstanceOf($match0._1, "Int"))
643 647                  then if ($isInstanceOf($match0._2, "Int"))
644 648                      then if ($isInstanceOf($match0._5, "Int"))
645 649                          then if ($isInstanceOf($match0._6, "Int"))
646 650                              then if ($isInstanceOf($match0._7, "Int"))
647 651                                  then if ($isInstanceOf($match0._8, "String"))
648 652                                      then $isInstanceOf($match0._9, "String")
649 653                                      else false
650 654                                  else false
651 655                              else false
652 656                          else false
653 657                      else false
654 658                  else false)
655 659                  then (size($match0) == 10)
656 660                  else false)
657 661                  then {
658 662                      let outAmAmt = $match0._1
659 663                      let outPrAmt = $match0._2
660 664                      let amBalance = $match0._5
661 665                      let prBalance = $match0._6
662 666                      let lpEmission = $match0._7
663 667                      let curPrice = $match0._8
664 668                      let poolStatus = $match0._9
665 669                      $Tuple7(outAmAmt, outPrAmt, amBalance, prBalance, lpEmission, curPrice, poolStatus)
666 670                      }
667 671                  else throw("Couldn't cast types")
668 672      }
669 -     let outAmAmt = $t02694727364._1
670 -     let outPrAmt = $t02694727364._2
671 -     let amBalance = $t02694727364._3
672 -     let prBalance = $t02694727364._4
673 -     let lpEmission = $t02694727364._5
674 -     let curPrice = $t02694727364._6
675 -     let poolStatus = $t02694727364._7
673 +     let outAmAmt = $t02710227519._1
674 +     let outPrAmt = $t02710227519._2
675 +     let amBalance = $t02710227519._3
676 +     let prBalance = $t02710227519._4
677 +     let lpEmission = $t02710227519._5
678 +     let curPrice = $t02710227519._6
679 +     let poolStatus = $t02710227519._7
676 680      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), curPrice, poolStatus], SEP))
677 681      }
678 682  
679 683  
680 684  
681 685  @Callable(i)
682 686  func gwxUserInfoREADONLY (userAddress) = {
683 687      let gwxUserInfoLIST = asAnyList(invoke(boostingDapp, "gwxUserInfoREADONLY", [userAddress], nil))
684 688      let gwxAmount = asInt(gwxUserInfoLIST[0])
685 689      $Tuple2(nil, makeString(["%d", toString(gwxAmount)], SEP))
686 690      }
687 691  
688 692  
689 693  
690 694  @Callable(i)
691 695  func unstakeAndGetOneTkn (poolAddress,amount,exchResult,notUsed,outAmount,outAssetId,slippage) = {
692 696      let inv = invoke(addressFromStringValue(value(getString(addressFromStringValue(poolAddress), keyAddonAddr()))), "unstakeAndGetOneTkn", [amount, exchResult, notUsed, outAmount, outAssetId, slippage], nil)
693 697      if ((inv == inv))
694 698          then $Tuple2(nil, unit)
695 699          else throw("Strict value is not equal to itself.")
696 700      }
697 701  
698 702  
699 703  
700 704  @Callable(i)
701 705  func setManager (pendingManagerPublicKey) = {
702 706      let checkCaller = mustManager(i)
703 707      if ((checkCaller == checkCaller))
704 708          then {
705 709              let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
706 710              if ((checkManagerPublicKey == checkManagerPublicKey))
707 711                  then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
708 712                  else throw("Strict value is not equal to itself.")
709 713              }
710 714          else throw("Strict value is not equal to itself.")
711 715      }
712 716  
713 717  
714 718  
715 719  @Callable(i)
716 720  func confirmManager () = {
717 721      let pm = pendingManagerPublicKeyOrUnit()
718 722      let hasPM = if (isDefined(pm))
719 723          then true
720 724          else throw("No pending manager")
721 725      if ((hasPM == hasPM))
722 726          then {
723 727              let checkPM = if ((i.callerPublicKey == value(pm)))
724 728                  then true
725 729                  else throw("You are not pending manager")
726 730              if ((checkPM == checkPM))
727 731                  then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
728 732                  else throw("Strict value is not equal to itself.")
729 733              }
730 734          else throw("Strict value is not equal to itself.")
731 735      }
732 736  
733 737  
734 738  @Verifier(tx)
735 739  func verify () = {
736 740      let targetPublicKey =     match managerPublicKeyOrUnit() {
737 741          case pk: ByteVector => 
738 742              pk
739 743          case _: Unit => 
740 744              tx.senderPublicKey
741 745          case _ => 
742 746              throw("Match error")
743 747      }
744 748      sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
745 749      }
746 750

Old	New		Differences
226	226
227	227
228	228		func keyAddonAddr () = "%s__addonAddr"
	229	+
	230	+
	231	+	func keyFeePermille () = "%s__feePermille"
229	232
230	233
231	234		let factoryDapp = readFactoryAddressOrFail()

512	515		let lpAmtAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[1], MULT8], nil))
513	516		let lpPriceAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[2], MULT8], nil))
514	517		let poolWeight = getIntegerValue(factoryDapp, keyFactoryPoolWeight(toString(poolAddress)))
515		-	$Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
	518	+	let feePermille = getIntOrZero(poolAddress, keyFeePermille())
	519	+	$Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight), toString(feePermille)], SEP))
516	520		}
517	521
518	522

542	546		let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, MULT18)
543	547		let inPrAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inPrAssetAmtX18), priceAssetDcm], nil))
544	548		let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
545		-	let $~~t02297323326~~ = match res {
	549	+	let $t02312823481 = match res {
546	550		case _ =>
547	551		if (if (if ($isInstanceOf($match0._1, "Int"))
548	552		then if ($isInstanceOf($match0._3, "Int"))

565	569		}
566	570		else throw("Couldn't cast types")
567	571		}
568		-	let calcLpAmt = $~~t02297323326~~._1
569		-	let curPriceCalc = $~~t02297323326~~._2
570		-	let amBalance = $~~t02297323326~~._3
571		-	let prBalance = $~~t02297323326~~._4
572		-	let lpEmission = $~~t02297323326~~._5
	572	+	let calcLpAmt = $t02312823481._1
	573	+	let curPriceCalc = $t02312823481._2
	574	+	let amBalance = $t02312823481._3
	575	+	let prBalance = $t02312823481._4
	576	+	let lpEmission = $t02312823481._5
573	577		$Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
574	578		}
575	579

600	604		let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, MULT18, curPriceX18)
601	605		let inAmAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inAmAssetAmtX18), amtAssetDcm], nil))
602	606		let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
603		-	let $~~t02589926252~~ = match res {
	607	+	let $t02605426407 = match res {
604	608		case _ =>
605	609		if (if (if ($isInstanceOf($match0._1, "Int"))
606	610		then if ($isInstanceOf($match0._3, "Int"))

623	627		}
624	628		else throw("Couldn't cast types")
625	629		}
626		-	let calcLpAmt = $~~t02589926252~~._1
627		-	let curPriceCalc = $~~t02589926252~~._2
628		-	let amBalance = $~~t02589926252~~._3
629		-	let prBalance = $~~t02589926252~~._4
630		-	let lpEmission = $~~t02589926252~~._5
	630	+	let calcLpAmt = $t02605426407._1
	631	+	let curPriceCalc = $t02605426407._2
	632	+	let amBalance = $t02605426407._3
	633	+	let prBalance = $t02605426407._4
	634	+	let lpEmission = $t02605426407._5
631	635		$Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
632	636		}
633	637

637	641		func poolEvaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
638	642		let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(paymentLpAssetId)))
639	643		let res = invoke(poolAddress, "estimateGetOperationWrapperREADONLY", ["", paymentLpAssetId, paymentLpAmt, toString(poolAddress)], nil)
640		-	let $~~t02694727364~~ = match res {
	644	+	let $t02710227519 = match res {
641	645		case _ =>
642	646		if (if (if ($isInstanceOf($match0._1, "Int"))
643	647		then if ($isInstanceOf($match0._2, "Int"))

666	670		}
667	671		else throw("Couldn't cast types")
668	672		}
669		-	let outAmAmt = $~~t02694727364~~._1
670		-	let outPrAmt = $~~t02694727364~~._2
671		-	let amBalance = $~~t02694727364~~._3
672		-	let prBalance = $~~t02694727364~~._4
673		-	let lpEmission = $~~t02694727364~~._5
674		-	let curPrice = $~~t02694727364~~._6
675		-	let poolStatus = $~~t02694727364~~._7
	673	+	let outAmAmt = $t02710227519._1
	674	+	let outPrAmt = $t02710227519._2
	675	+	let amBalance = $t02710227519._3
	676	+	let prBalance = $t02710227519._4
	677	+	let lpEmission = $t02710227519._5
	678	+	let curPrice = $t02710227519._6
	679	+	let poolStatus = $t02710227519._7
676	680		$Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), curPrice, poolStatus], SEP))
677	681		}
678	682

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 MULT8 = 100000000
7	7
8	8		let SCALE18 = 18
9	9
10	10		let MULT18 = toBigInt(1000000000000000000)
11	11
12	12		let SEP = "__"
13	13
14	14		let POOLWEIGHTMULT = MULT8
15	15
16	16		let zeroBigInt = toBigInt(0)
17	17
18	18		let idxPoolAddress = 1
19	19
20	20		let idxPoolStatus = 2
21	21
22	22		let idxPoolLPAssetId = 3
23	23
24	24		let idxAmtAssetId = 4
25	25
26	26		let idxPriceAssetId = 5
27	27
28	28		let idxAmtAssetDcm = 6
29	29
30	30		let idxPriceAssetDcm = 7
31	31
32	32		let idxIAmtAssetId = 8
33	33
34	34		let idxIPriceAssetId = 9
35	35
36	36		let idxLPAssetDcm = 10
37	37
38	38		func getStringOrFail (key) = valueOrErrorMessage(getString(key), (("mandatory this." + key) + " is not defined"))
39	39
40	40
41	41		func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
42	42
43	43
44	44		func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
45	45
46	46
47	47		func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
48	48
49	49
50	50		func asAnyList (val) = match val {
51	51		case valAnyLyst: List[Any] =>
52	52		valAnyLyst
53	53		case _ =>
54	54		throw("fail to cast into List[Any]")
55	55		}
56	56
57	57
58	58		func asInt (val) = match val {
59	59		case valInt: Int =>
60	60		valInt
61	61		case _ =>
62	62		throw("fail to cast into Int")
63	63		}
64	64
65	65
66	66		func asString (val) = match val {
67	67		case valStr: String =>
68	68		valStr
69	69		case _ =>
70	70		throw("fail to cast into String")
71	71		}
72	72
73	73
74	74		func keyFactoryAddress () = "%s%s__config__factoryAddress"
75	75
76	76
77	77		func keyManagerPublicKey () = "%s__managerPublicKey"
78	78
79	79
80	80		func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
81	81
82	82
83	83		let IdxFactoryCfgStakingDapp = 1
84	84
85	85		let IdxFactoryCfgBoostingDapp = 2
86	86
87	87		let IdxFactoryCfgIdoDapp = 3
88	88
89	89		let IdxFactoryCfgTeamDapp = 4
90	90
91	91		let IdxFactoryCfgEmissionDapp = 5
92	92
93	93		let IdxFactoryCfgRestDapp = 6
94	94
95	95		let IdxFactoryCfgSlippageDapp = 7
96	96
97	97		let IdxFactoryCfgGwxRewardDapp = 8
98	98
99	99		func keyFactoryCfg () = "%s__factoryConfig"
100	100
101	101
102	102		func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
103	103
104	104
105	105		func keyFactoryLpList () = "%s__lpTokensList"
106	106
107	107
108	108		func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
109	109
110	110
111	111		func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
112	112
113	113
114	114		func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(keyFactoryAddress()))
115	115
116	116
117	117		func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
118	118
119	119
120	120		func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
121	121
122	122
123	123		func getBoostingAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgBoostingDapp])
124	124
125	125
126	126		func getEmissionAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgEmissionDapp])
127	127
128	128
129	129		func getStakingAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgStakingDapp])
130	130
131	131
132	132		func getGwxRewardAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgGwxRewardDapp])
133	133
134	134
135	135		func keyBoostCfg () = "%s__config"
136	136
137	137
138	138		func keyBoostingLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
139	139
140	140
141	141		func keyBoostingStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
142	142
143	143
144	144		func keyBoostingStatsLocksCount () = "%s%s__stats__locksCount"
145	145
146	146
147	147		func keyBoostingStatsUsersCount () = "%s%s__stats__activeUsersCount"
148	148
149	149
150	150		func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
151	151
152	152
153	153		func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
154	154
155	155
156	156		func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
157	157
158	158
159	159		func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
160	160
161	161
162	162		func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
163	163
164	164
165	165		func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
166	166
167	167
168	168		func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
169	169
170	170
171	171		func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
172	172
173	173
174	174		func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
175	175
176	176
177	177		func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
178	178
179	179
180	180		func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
181	181
182	182
183	183		func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
184	184
185	185
186	186		func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
187	187
188	188
189	189		func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
190	190
191	191
192	192		func keyTotalCachedGwx () = "%s%s__gwxCached__total"
193	193
194	194
195	195		func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
196	196
197	197
198	198		func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
199	199
200	200
201	201		func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
202	202
203	203
204	204		func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
205	205
206	206
207	207		func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
208	208
209	209
210	210		func readStaked (stakingDapp,key) = valueOrElse(getInteger(stakingDapp, key), 0)
211	211
212	212
213	213		func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
214	214
215	215
216	216		func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
217	217
218	218
219	219		func keyEmissionStartBlock () = "%s%s__emission__startBlock"
220	220
221	221
222	222		func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
223	223
224	224
225	225		func keyEmissionEndBlock () = "%s%s__emission__endBlock"
226	226
227	227
228	228		func keyAddonAddr () = "%s__addonAddr"
	229	+
	230	+
	231	+	func keyFeePermille () = "%s__feePermille"
229	232
230	233
231	234		let factoryDapp = readFactoryAddressOrFail()
232	235
233	236		let factoryCfg = readFactoryCfgOrFail(factoryDapp)
234	237
235	238		let emissionDapp = getEmissionAddressOrFail(factoryCfg)
236	239
237	240		let stakingDapp = getStakingAddressOrFail(factoryCfg)
238	241
239	242		let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
240	243
241	244		let boostingDapp = getBoostingAddressOrFail(factoryCfg)
242	245
243	246		func internalCurrentRewardRate (lpAssetId) = {
244	247		let poolAddressStr = getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
245	248		let poolWeightMult = MULT8
246	249		let poolWeight = getIntegerValue(factoryDapp, keyFactoryPoolWeight(poolAddressStr))
247	250		let wxEmissionPerBlock = getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent())
248	251		let wxEmissionPerBlockMax = getIntOrFail(emissionDapp, keyEmissionRatePerBlockMaxCurrent())
249	252		let boostMaxCoeff = 3
250	253		let poolWxEmissionPerBlock = (fraction(wxEmissionPerBlock, poolWeight, poolWeightMult) / boostMaxCoeff)
251	254		let poolWxEmissionPerBlockMax = fraction(wxEmissionPerBlockMax, poolWeight, poolWeightMult)
252	255		let maxFactor = (boostMaxCoeff * MULT8)
253	256		let totalLpStaked = getIntOrZero(stakingDapp, keyStakedTotal(lpAssetId))
254	257		[poolWxEmissionPerBlock, maxFactor, totalLpStaked]
255	258		}
256	259
257	260
258	261		func calcGwxAmountStartREADONLY (lockAmount,lockDuration,maxLockDuration) = {
259	262		let coeffX8 = fraction(lockDuration, MULT8, maxLockDuration)
260	263		let gWxAmountStart = fraction(lockAmount, coeffX8, MULT8)
261	264		[gWxAmountStart]
262	265		}
263	266
264	267
265	268		func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
266	269		case s: String =>
267	270		fromBase58String(s)
268	271		case _: Unit =>
269	272		unit
270	273		case _ =>
271	274		throw("Match error")
272	275		}
273	276
274	277
275	278		func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
276	279		case s: String =>
277	280		fromBase58String(s)
278	281		case _: Unit =>
279	282		unit
280	283		case _ =>
281	284		throw("Match error")
282	285		}
283	286
284	287
285	288		func mustManager (i) = {
286	289		let pd = throw("Permission denied")
287	290		match managerPublicKeyOrUnit() {
288	291		case pk: ByteVector =>
289	292		if ((i.callerPublicKey == pk))
290	293		then true
291	294		else pd
292	295		case _: Unit =>
293	296		if ((i.caller == this))
294	297		then true
295	298		else pd
296	299		case _ =>
297	300		throw("Match error")
298	301		}
299	302		}
300	303
301	304
302	305		@Callable(i)
303	306		func constructor (factoryAddress) = {
304	307		let checkCaller = mustManager(i)
305	308		if ((checkCaller == checkCaller))
306	309		then [StringEntry(keyFactoryAddress(), factoryAddress)]
307	310		else throw("Strict value is not equal to itself.")
308	311		}
309	312
310	313
311	314
312	315		@Callable(i)
313	316		func currentRewardRateREADONLY (lpAssetId) = {
314	317		let rewardData = internalCurrentRewardRate(lpAssetId)
315	318		let wxEmissionPerBlock = rewardData[0]
316	319		let maxFactor = rewardData[1]
317	320		let totalLpStaked = rewardData[2]
318	321		$Tuple2(nil, makeString(["%d%d%d", toString(wxEmissionPerBlock), toString(maxFactor), toString(totalLpStaked)], SEP))
319	322		}
320	323
321	324
322	325
323	326		@Callable(i)
324	327		func currentUserRewardRateREADONLY (lpAssetId,userAddress) = {
325	328		let rewardData = internalCurrentRewardRate(lpAssetId)
326	329		let wxEmissionPerBlock = rewardData[0]
327	330		let maxFactor = rewardData[1]
328	331		let totalLpStaked = rewardData[2]
329	332		let lpStakedByUser = getIntOrZero(stakingDapp, keyStakedByUser(userAddress, lpAssetId))
330	333		let userClaimInfo = split(asString(invoke(stakingDapp, "claimWxREADONLY", [lpAssetId, userAddress], nil)), SEP)
331	334		let minRewardPart = valueOrErrorMessage(parseInt(userClaimInfo[5]), "couldn't parse minRewardPart")
332	335		let boostRewardPart = valueOrErrorMessage(parseInt(userClaimInfo[6]), "couldn't parse boostRewardPart")
333	336		let debug = userClaimInfo[7]
334	337		let boostingPower = if ((boostRewardPart == 0))
335	338		then (1 * MULT8)
336	339		else fraction((minRewardPart + boostRewardPart), MULT8, minRewardPart)
337	340		$Tuple2(nil, makeString(["%d%d%d%d%d%s", toString(wxEmissionPerBlock), toString(maxFactor), toString(totalLpStaked), toString(lpStakedByUser), toString(boostingPower), debug], SEP))
338	341		}
339	342
340	343
341	344
342	345		@Callable(i)
343	346		func claimedRewardREADONLY (userAddress) = {
344	347		let lpList = readLpList()
345	348		let prefix = "%s%d%d%d%s"
346	349		func claimedRewardByLpAggregator (resultStr,nextLp) = {
347	350		let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(nextLp, userAddress)
348	351		let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(nextLp, userAddress)
349	352		let minRewardClaimed = valueOrElse(getInteger(stakingDapp, claimedByUserMinRewardKEY), 0)
350	353		let boostRewardClaimed = valueOrElse(getInteger(stakingDapp, claimedByUserBoostRewardKEY), 0)
351	354		let gFeeClaimed = 0
352	355		makeString([(prefix + resultStr), nextLp, toString(minRewardClaimed), toString(boostRewardClaimed), toString(gFeeClaimed), "end"], SEP)
353	356		}
354	357
355	358		let result = {
356	359		let $l = lpList
357	360		let $s = size($l)
358	361		let $acc0 = "%s"
359	362		func $f0_1 ($a,$i) = if (($i >= $s))
360	363		then $a
361	364		else claimedRewardByLpAggregator($a, $l[$i])
362	365
363	366		func $f0_2 ($a,$i) = if (($i >= $s))
364	367		then $a
365	368		else throw("List size exceeds 10")
366	369
367	370		$f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
368	371		}
369	372		$Tuple2(nil, ((result + SEP) + userAddress))
370	373		}
371	374
372	375
373	376
374	377		@Callable(i)
375	378		func calcBoostBulkInternalREADONLY (currentIter,deltaWxAmountBulk,deltaLockPeriodInBlocksBulk,deltaLpAmountBulk,lpAssetIdOptBulk,userAddressOpt,resAcc) = if ((currentIter == size(deltaWxAmountBulk)))
376	379		then $Tuple2(nil, resAcc)
377	380		else {
378	381		let deltaWxAmount = deltaWxAmountBulk[currentIter]
379	382		let deltaLockPeriodInBlocks = deltaLockPeriodInBlocksBulk[currentIter]
380	383		let deltaLpAmount = deltaLpAmountBulk[currentIter]
381	384		let lpAssetIdOpt = lpAssetIdOptBulk[currentIter]
382	385		let info = {
383	386		let @ = invoke(this, "calcBoostREADONLY", [deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt], nil)
384	387		if ($isInstanceOf(@, "String"))
385	388		then @
386	389		else throw(($getType(invoke(this, "calcBoostREADONLY", [deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt], nil)) + " couldn't be cast to String"))
387	390		}
388	391		let res = (resAcc :+ info)
389	392		let inv = {
390	393		let @ = invoke(this, "calcBoostBulkInternalREADONLY", [(currentIter + 1), deltaWxAmountBulk, deltaLockPeriodInBlocksBulk, deltaLpAmountBulk, lpAssetIdOptBulk, userAddressOpt, res], nil)
391	394		if ($isInstanceOf(@, "List[Any]"))
392	395		then @
393	396		else throw(($getType(invoke(this, "calcBoostBulkInternalREADONLY", [(currentIter + 1), deltaWxAmountBulk, deltaLockPeriodInBlocksBulk, deltaLpAmountBulk, lpAssetIdOptBulk, userAddressOpt, res], nil)) + " couldn't be cast to List[Any]"))
394	397		}
395	398		if ((inv == inv))
396	399		then $Tuple2(nil, inv)
397	400		else throw("Strict value is not equal to itself.")
398	401		}
399	402
400	403
401	404
402	405		@Callable(i)
403	406		func calcBoostBulkREADONLY (deltaWxAmount,deltaLockPeriodInBlocks,deltaLpAmount,lpAssetIdOpt,userAddressOpt) = {
404	407		let res = invoke(this, "calcBoostBulkInternalREADONLY", [0, deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt, nil], nil)
405	408		$Tuple2(nil, res)
406	409		}
407	410
408	411
409	412
410	413		@Callable(i)
411	414		func calcBoostREADONLY (deltaWxAmount,deltaLockPeriodInBlocks,deltaLpAmount,lpAssetIdOpt,userAddressOpt) = {
412	415		let mathDapp = gwxRewardDapp
413	416		let EMPTYSTR = "empty"
414	417		let maxLockDurationInBlocks = parseIntValue(split(getStringByAddressOrFail(boostingDapp, keyBoostCfg()), SEP)[4])
415	418		let lpAssetIdStr = if ((lpAssetIdOpt == ""))
416	419		then EMPTYSTR
417	420		else lpAssetIdOpt
418	421		let userAddressStr = if ((userAddressOpt == ""))
419	422		then EMPTYSTR
420	423		else userAddressOpt
421	424		let userNumStr = valueOrElse(getString(boostingDapp, keyUser2NumMapping(userAddressOpt)), EMPTYSTR)
422	425		let userAmount = valueOrElse(getInteger(boostingDapp, keyLockParamUserAmount(userNumStr)), 0)
423	426		let lockStart = valueOrElse(getInteger(boostingDapp, keyLockParamStartBlock(userNumStr)), height)
424	427		let lockDuration = valueOrElse(getInteger(boostingDapp, keyLockParamDuration(userNumStr)), 0)
425	428		let lockEnd = (lockStart + lockDuration)
426	429		let remainingDuration = max([(lockEnd - height), 0])
427	430		let userAmountNew = (userAmount + deltaWxAmount)
428	431		let lockDurationNew = min([(remainingDuration + deltaLockPeriodInBlocks), maxLockDurationInBlocks])
429	432		let userCurrgWxAmount = asInt(asAnyList(invoke(boostingDapp, "gwxUserInfoREADONLY", [userAddressStr], nil))[0])
430	433		let gWxAmountStartNew = calcGwxAmountStartREADONLY(userAmountNew, lockDurationNew, maxLockDurationInBlocks)[0]
431	434		let gWxParamsResultList = asAnyList(invoke(mathDapp, "calcGwxParamsREADONLY", [gWxAmountStartNew, height, lockDurationNew], nil))
432	435		let gWxAmountDiff = (gWxAmountStartNew - userCurrgWxAmount)
433	436		let k = asInt(gWxParamsResultList[0])
434	437		let b = asInt(gWxParamsResultList[1])
435	438		let period = toString(asInt(gWxParamsResultList[2]))
436	439		let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
437	440		let totalCachedGwxKEY = keyTotalCachedGwx()
438	441		let userMaxBoostIntNew = ((gWxAmountStartNew * lockDurationNew) / 2)
439	442		let totalMaxBoostInt = getIntOrZero(boostingDapp, totalMaxBoostIntegralKEY)
440	443		let totalCachedGwx = valueOrElse(getInteger(boostingDapp, totalCachedGwxKEY), 0)
441	444		let MULT3 = 1000
442	445		let wxEmissionPerBlockX3 = (getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent()) * MULT3)
443	446		let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
444	447		let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
445	448		let stakedByUser = readStaked(stakingDapp, stakedByUserKEY)
446	449		let stakedTotal = readStaked(stakingDapp, stakedTotalKEY)
447	450		let stakedByUserNew = (stakedByUser + deltaLpAmount)
448	451		let stakedTotalNew = (stakedTotal + deltaLpAmount)
449	452		let poolWeight = if ((lpAssetIdStr != EMPTYSTR))
450	453		then {
451	454		let poolAddressStr = valueOrErrorMessage(getString(factoryDapp, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
452	455		getIntegerValue(factoryDapp, keyFactoryPoolWeight(poolAddressStr))
453	456		}
454	457		else 0
455	458		let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * 3))
456	459		let wxPerLpX3 = if ((stakedTotalNew != 0))
457	460		then fraction(poolWxEmissionPerBlockX3, MULT8, stakedTotalNew)
458	461		else 0
459	462		let userWxPerBlockX3 = fraction(wxPerLpX3, stakedByUserNew, MULT8)
460	463		let boostEmissionPerBlockX3 = (poolWxEmissionPerBlockX3 * 2)
461	464		let tmpUserBoostPerBlockX3 = fraction(gWxAmountStartNew, boostEmissionPerBlockX3, (totalCachedGwx + gWxAmountDiff))
462	465		let userBoostPerBlockX3 = min([tmpUserBoostPerBlockX3, (userWxPerBlockX3 * 2)])
463	466		let boostCoeff = if ((userWxPerBlockX3 == 0))
464	467		then (1 * MULT8)
465	468		else fraction((userBoostPerBlockX3 + userWxPerBlockX3), MULT8, userWxPerBlockX3)
466	469		$Tuple2(nil, makeString(["%d%d%s", toString(gWxAmountStartNew), toString(boostCoeff), "d"], SEP))
467	470		}
468	471
469	472
470	473
471	474		@Callable(i)
472	475		func wxEmissionStatsREADONLY () = {
473	476		let ONEMULT = toString(MULT8)
474	477		let ONE = "1"
475	478		let wxEmissionPerBlock = getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent())
476	479		let emissionStartBlock = getIntOrFail(emissionDapp, keyEmissionStartBlock())
477	480		let passedBlocks = if ((emissionStartBlock > height))
478	481		then 0
479	482		else (height - emissionStartBlock)
480	483		let teamEmDuration = (1440 * 365)
481	484		let teamEmMax = (201000000 * MULT8)
482	485		let teamEm = if ((passedBlocks > teamEmDuration))
483	486		then teamEmMax
484	487		else fraction(teamEmMax, passedBlocks, teamEmDuration)
485	488		let totalWxReleased = ((wxEmissionPerBlock * passedBlocks) + teamEm)
486	489		let totalWxLocked = getIntOrZero(boostingDapp, keyBoostingLockParamTotalAmount())
487	490		let locksDurationSumInBlocks = getIntOrZero(boostingDapp, keyBoostingStatsLocksDurationSumInBlocks())
488	491		let locksCount = getIntOrZero(boostingDapp, keyBoostingStatsLocksCount())
489	492		$Tuple2(nil, makeString(["%d%d%d%d", toString(totalWxReleased), toString(totalWxLocked), toString(locksDurationSumInBlocks), toString(locksCount)], SEP))
490	493		}
491	494
492	495
493	496
494	497		@Callable(i)
495	498		func poolStatsREADONLY (lpAsset) = {
496	499		let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAsset)))
497	500		let cfg = asAnyList(invoke(poolAddress, "getPoolConfigWrapperREADONLY", nil, nil))

github/deemru/w8io/c3f4982 
597.47 ms ◑