w8 · tx · vcY···YNe

tx · vcYZPj9vVJvMJpERNzANuuj6hUjAfioCoq3nJrXFYNe

3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz:  -0.03700000 Waves

2022.06.23 10:20 [2108745] smart account 3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "vcYZPj9vVJvMJpERNzANuuj6hUjAfioCoq3nJrXFYNe",
    "fee": 3700000,
    "feeAssetId": null,
    "timestamp": 1655968870113,
    "version": 1,
    "sender": "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz",
    "senderPublicKey": "D28XoueZWsMfm8Y5pa6C5ZFuYoWgre2Wm8tzJANJgMnq",
    "proofs": [
        "5hjmo2H3Wh2aKmtq1Pg8DUjTDrCAjwetF5Fm9vbsBD3goM7s1kLZQVAhvFSs9tqwJGr6ehQ6VYLPM3s5EYNeg7Bc"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2108745,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 784Qy6fJe7f6oYqpVne9HBZp6nTn3cUhaePbQMk8uUop
Next: 7CoNvwN1vHcEVPuobf4fTVx5xNAoF5A4G93c8pRBDkWv

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

Old	New		Differences
609	609		else (height - emissionStartBlock)
610	610		let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
611	611		let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
612		-	let $~~t02571725829~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
613		-	let wxToClaimUserNew = $~~t02571725829~~._1
614		-	let integralSTATE = $~~t02571725829~~._2
615		-	let debug = $~~t02571725829~~._3
	612	+	let $t02565425766 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	613	+	let wxToClaimUserNew = $t02565425766._1
	614	+	let integralSTATE = $t02565425766._2
	615	+	let debug = $t02565425766._3
616	616		let availableToClaim = (wxToClaimUserNew - toBigInt(claimedByUser))
617	617		let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
618	618		let wxAmountBoostTotal = asInt(boostInvResult[0])

673	673		func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
674	674		then throw("permissions denied")
675	675		else {
676		-	let $~~t02773027840~~ = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
677		-	let wxPerLpIntegralNew = $~~t02773027840~~._1
678		-	let poolIntegralSTATE = $~~t02773027840~~._2
679		-	let poolDEBUG = $~~t02773027840~~._3
	676	+	let $t02766727777 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
	677	+	let wxPerLpIntegralNew = $t02766727777._1
	678	+	let poolIntegralSTATE = $t02766727777._2
	679	+	let poolDEBUG = $t02766727777._3
680	680		poolIntegralSTATE
681	681		}
682	682

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

github/deemru/w8io/873ac7e 
75.66 ms ◑