w8 · tx · BTt···YAz

tx · BTtGvVzJXS6XgiBPJhaV2MZ2oFGfaUCFEp9DtgR7cYAz

3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV:  -0.03400000 Waves

2023.03.22 12:56 [3566658] smart account 3PPNhHYkkEy13gRWDCaruQyhNbX2GrjYSyV > SELF 0.00000000 Waves

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

View: original | compacted
Prev: 2P5y8aoUk2tJza7Q1MG57BZG5QPT43XCd8cUos1ZQSPv
Next: 2Wi1uSivnsSkABw8PPWqoCKjHHyWp1J96WPKdR3UtpCb

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

Old	New		Differences
420	420		}
421	421
422	422
	423	+	func stakeActions (i,lpAssetId,poolAddress,userAddress,amount) = {
	424	+	let userAddressStr = toString(userAddress)
	425	+	let lpAssetIdStr = toBase58String(lpAssetId)
	426	+	let poolAddressStr = toString(poolAddress)
	427	+	let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
	428	+	let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
	429	+	let stakedByUser = readStaked(stakedByUserKEY)
	430	+	let refreshStakedVote = if ((stakedByUser == 0))
	431	+	then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
	432	+	else unit
	433	+	if ((refreshStakedVote == refreshStakedVote))
	434	+	then {
	435	+	let stakedTotal = readStaked(stakedTotalKEY)
	436	+	let $t01810718224 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
	437	+	let wxToClaimUserNew = $t01810718224._1
	438	+	let integralSTATE = $t01810718224._2
	439	+	let debug = $t01810718224._3
	440	+	let listName = getUsersListName(lpAssetIdStr)
	441	+	let listActions = if (containsNode(listName, userAddressStr))
	442	+	then nil
	443	+	else insertNodeActions(listName, userAddressStr)
	444	+	(([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
	445	+	}
	446	+	else throw("Strict value is not equal to itself.")
	447	+	}
	448	+
	449	+
423	450		func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
424	451		let userAddressStr = toString(userAddress)
425	452		let lpAssetIdStr = toBase58String(lpAssetId)

523	550		let lpAssetIdStr = toBase58String(lpAssetId)
524	551		let amount = pmt.amount
525	552		let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
526		-	let callerStr = toString(i.caller)
527		-	let userAddressStr = if ((callerStr == poolAddressStr))
528		-	then toString(i.originCaller)
529		-	else callerStr
530		-	let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
531		-	let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
532		-	let stakedByUser = readStaked(stakedByUserKEY)
533		-	let refreshStakedVote = if ((stakedByUser == 0))
534		-	then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
535		-	else unit
536		-	if ((refreshStakedVote == refreshStakedVote))
537		-	then {
538		-	let stakedTotal = readStaked(stakedTotalKEY)
539		-	let $t02161321730 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
540		-	let wxToClaimUserNew = $t02161321730._1
541		-	let integralSTATE = $t02161321730._2
542		-	let debug = $t02161321730._3
543		-	let listName = getUsersListName(lpAssetIdStr)
544		-	let listActions = if (containsNode(listName, userAddressStr))
545		-	then nil
546		-	else insertNodeActions(listName, userAddressStr)
547		-	(([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
548		-	}
549		-	else throw("Strict value is not equal to itself.")
	553	+	let poolAddress = addressFromStringValue(poolAddressStr)
	554	+	let userAddress = if ((i.caller == poolAddress))
	555	+	then i.originCaller
	556	+	else i.caller
	557	+	stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
	558	+	}
	559	+
	560	+
	561	+
	562	+	@Callable(i)
	563	+	func stakeFor (userAddressStr) = if ((size(i.payments) != 1))
	564	+	then throw("invalid payment - exact one payment must be attached")
	565	+	else {
	566	+	let pmt = i.payments[0]
	567	+	let lpAssetId = value(pmt.assetId)
	568	+	let lpAssetIdStr = toBase58String(lpAssetId)
	569	+	let amount = pmt.amount
	570	+	let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
	571	+	let poolAddress = addressFromStringValue(poolAddressStr)
	572	+	let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
	573	+	stakeActions(i, lpAssetId, poolAddress, userAddress, amount)
550	574		}
551	575
552	576

618	642		let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
619	643		let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
620	644		let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
621		-	let $~~t02511625228~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
622		-	let wxToClaimUserNew = $~~t02511625228~~._1
623		-	let integralSTATE = $~~t02511625228~~._2
624		-	let debug = $~~t02511625228~~._3
	645	+	let $t02618626298 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	646	+	let wxToClaimUserNew = $t02618626298._1
	647	+	let integralSTATE = $t02618626298._2
	648	+	let debug = $t02618626298._3
625	649		let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
626	650		if ((zeroBigInt >= availableToClaim))
627	651		then if (throwIfNothingToClaim)

704	728		else (height - emissionStartBlock)
705	729		let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
706	730		let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
707		-	let $~~t02903729149~~ = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
708		-	let wxToClaimUserNew = $~~t02903729149~~._1
709		-	let integralSTATE = $~~t02903729149~~._2
710		-	let debug = $~~t02903729149~~._3
	731	+	let $t03010730219 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
	732	+	let wxToClaimUserNew = $t03010730219._1
	733	+	let integralSTATE = $t03010730219._2
	734	+	let debug = $t03010730219._3
711	735		let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
712	736		let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
713	737		let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])

783	807		func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
784	808		then throw("permissions denied")
785	809		else {
786		-	let $~~t03175531865~~ = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
787		-	let wxPerLpIntegralNew = $~~t03175531865~~._1
788		-	let poolIntegralSTATE = $~~t03175531865~~._2
789		-	let poolDEBUG = $~~t03175531865~~._3
	810	+	let $t03282532935 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
	811	+	let wxPerLpIntegralNew = $t03282532935._1
	812	+	let poolIntegralSTATE = $t03282532935._2
	813	+	let poolDEBUG = $t03282532935._3
790	814		poolIntegralSTATE
791	815		}
792	816

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

github/deemru/w8io/6500d08 
89.51 ms ◑