w8 · tx · UaH···hB1

tx · UaHE4eEWLGBCjSmRa3Fx43KGDiCXqnu34e2z1mv5hB1

3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3:  -0.03300000 Waves

2023.03.16 17:04 [2492670] smart account 3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "UaHE4eEWLGBCjSmRa3Fx43KGDiCXqnu34e2z1mv5hB1",
    "fee": 3300000,
    "feeAssetId": null,
    "timestamp": 1678975505154,
    "version": 2,
    "chainId": 84,
    "sender": "3MzYrKxGR6BZcwdHQDDXDRGn7c63zQsqyu3",
    "senderPublicKey": "7GvzKupc5EwAeuw6BXayiGswG3LEmw6artCvXaZzaGKp",
    "proofs": [
        "2KrvuBEnQtTMDTxs5XibUjeuMv4CRnCvhxUCJ2YZ17fxrhvSAq2fCJ7YMt4BDV1iZPe2nPQCKWyCYKE6CM1Lfmax"
    ],
    "script": "base64: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",
    "height": 2492670,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: DwtGcsaMoS1mMLq1wcvzQj27LiCVB3tbqei5ZEnDamY4
Next: GREoUiztZu1cjmLjvssmYUBdRkwga58j37QTkEQdByUJ

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 423  func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
424 424      let userAddressStr = toString(userAddress)
425 425      let lpAssetIdStr = toBase58String(lpAssetId)
426 426      let poolAddressStr = toString(poolAddress)
427 427      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
428 428      let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
429 429      let stakedByUser = readStaked(stakedByUserKEY)
430 430      let stakedTotal = readStaked(stakedTotalKEY)
431 431      let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
432 432      let listName = getUsersListName(lpAssetIdStr)
433 433      let listActions = if (if (containsNode(listName, userAddressStr))
434 434          then (amount == stakedByUser)
435 435          else false)
436 436          then deleteNodeActions(listName, userAddressStr)
437 437          else nil
438 438      let refreshStakedVote = if ((amount == stakedByUser))
439 439          then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
440 440          else unit
441 441      if ((refreshStakedVote == refreshStakedVote))
442 442          then {
443 443              let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
444 444              let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
445 445              let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
446 446              let throwIfNothingToClaim = true
447 447              let r = if ((availableToClaim > zeroBigInt))
448 448                  then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
449 449                  else unit
450 450              if ((r == r))
451 451                  then if ((amount > stakedByUser))
452 452                      then throw(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
453 453                      else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
454 454                  else throw("Strict value is not equal to itself.")
455 455              }
456 456          else throw("Strict value is not equal to itself.")
457 457      }
458 458  
459 459  
460 460  @Callable(i)
461 461  func constructor (factoryAddressStr) = {
462 462      let checkCaller = mustManager(i)
463 463      if ((checkCaller == checkCaller))
464 464          then [StringEntry(keyFactoryAddress(), factoryAddressStr)]
465 465          else throw("Strict value is not equal to itself.")
466 466      }
467 467  
468 468  
469 469  
470 470  @Callable(i)
471 471  func constructorV2 (votingEmissionContract) = {
472 472      let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
473 473          then true
474 474          else "invalid voting emission contract address"]
475 475      if ((cheks == cheks))
476 476          then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
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 setManager (pendingManagerPublicKey) = {
484 484      let checkCaller = mustManager(i)
485 485      if ((checkCaller == checkCaller))
486 486          then {
487 487              let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
488 488              if ((checkManagerPublicKey == checkManagerPublicKey))
489 489                  then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
490 490                  else throw("Strict value is not equal to itself.")
491 491              }
492 492          else throw("Strict value is not equal to itself.")
493 493      }
494 494  
495 495  
496 496  
497 497  @Callable(i)
498 498  func confirmManager () = {
499 499      let pm = pendingManagerPublicKeyOrUnit()
500 500      let hasPM = if (isDefined(pm))
501 501          then true
502 502          else throw("No pending manager")
503 503      if ((hasPM == hasPM))
504 504          then {
505 505              let checkPM = if ((i.callerPublicKey == value(pm)))
506 506                  then true
507 507                  else throw("You are not pending manager")
508 508              if ((checkPM == checkPM))
509 509                  then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
510 510                  else throw("Strict value is not equal to itself.")
511 511              }
512 512          else throw("Strict value is not equal to itself.")
513 513      }
514 514  
515 515  
516 516  
517 517  @Callable(i)
518 518  func stake () = if ((size(i.payments) != 1))
519 519      then throw("invalid payment - exact one payment must be attached")
520 520      else {
521 521          let pmt = i.payments[0]
522 522          let lpAssetId = value(pmt.assetId)
523 523          let lpAssetIdStr = toBase58String(lpAssetId)
524 524          let amount = pmt.amount
525 525          let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
526 526          let callerStr = toString(i.caller)
527 527          let userAddressStr = if ((callerStr == poolAddressStr))
528 528              then toString(i.originCaller)
529 529              else callerStr
530 530          let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
531 531          let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
532 532          let stakedByUser = readStaked(stakedByUserKEY)
533 533          let refreshStakedVote = if ((stakedByUser == 0))
534 534              then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, true], nil)
535 535              else unit
536 536          if ((refreshStakedVote == refreshStakedVote))
537 537              then {
538 538                  let stakedTotal = readStaked(stakedTotalKEY)
539 539                  let $t02161321730 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, amount)
540 540                  let wxToClaimUserNew = $t02161321730._1
541 541                  let integralSTATE = $t02161321730._2
542 542                  let debug = $t02161321730._3
543 543                  let listName = getUsersListName(lpAssetIdStr)
544 544                  let listActions = if (containsNode(listName, userAddressStr))
545 545                      then nil
546 546                      else insertNodeActions(listName, userAddressStr)
547 547                  (([IntegerEntry(stakedByUserKEY, (stakedByUser + amount)), IntegerEntry(stakedTotalKEY, (stakedTotal + amount)), OperationHistoryEntry("stake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
548 548                  }
549 549              else throw("Strict value is not equal to itself.")
550 550          }
551 551  
552 552  
553 553  
554 554  @Callable(i)
555 555  func unstake (lpAssetIdStr,amount) = {
556 556      let lpAssetId = fromBase58String(lpAssetIdStr)
557 557      let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
558 558      let poolAddress = addressFromStringValue(poolAddressStr)
559 559      let poolAddon = valueOrElse(getString(poolAddress, keyAddonAddr()), poolAddressStr)
560 560      let callerStr = toString(i.caller)
561 561      let userAddress = if (if ((callerStr == poolAddressStr))
562 562          then true
563 563          else (callerStr == poolAddon))
564 564          then i.originCaller
565 565          else i.caller
566 566      let lpAssetRecipientAddress = i.caller
567 567      unstakeActions(i, lpAssetId, poolAddress, userAddress, lpAssetRecipientAddress, amount)
568 568      }
569 569  
570 570  
571 571  
572 572  @Callable(i)
573 573  func unstakeINTERNAL (lpAssetId,amount,userAddress,lpAssetRecipientAddress) = {
574 574      let lpAssetIdStr = toBase58String(lpAssetId)
575 575      let poolAddress = addressFromStringValue(valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr)))
576 576      let checkCaller = if ((i.caller == poolAddress))
577 577          then true
578 578          else permissionDeniedError
579 579      if ((checkCaller == checkCaller))
580 580          then unstakeActions(i, lpAssetId, poolAddress, Address(userAddress), Address(lpAssetRecipientAddress), amount)
581 581          else throw("Strict value is not equal to itself.")
582 582      }
583 583  
584 584  
585 585  
586 586  @Callable(i)
587 587  func claimWx (lpAssetIdStr) = {
588 588      let userAddressStr = toString(i.caller)
589 589      let throwIfNothingToClaim = true
590 590      let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
591 591      $Tuple2(nil, result)
592 592      }
593 593  
594 594  
595 595  
596 596  @Callable(i)
597 597  func claimWxDoNotThrow (lpAssetIdStr) = {
598 598      let userAddressStr = toString(i.caller)
599 599      let throwIfNothingToClaim = false
600 600      let result = invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
601 601      $Tuple2(nil, result)
602 602      }
603 603  
604 604  
605 605  
606 606  @Callable(i)
607 607  func claimWxINTERNAL (lpAssetIdStr,userAddressStr,throwIfNothingToClaim) = {
608 608      let checkCaller = mustThis(i)
609 609      if ((checkCaller == checkCaller))
610 610          then {
611 611              let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), "claimWxINTERNAL: invalid user address")
612 612              let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
613 613              let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
614 614              let claimedTotalKEY = keyClaimedTotal(lpAssetIdStr)
615 615              let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
616 616              let claimedByUserBoostRewardKEY = keyClaimedByUserBoostReward(lpAssetIdStr, userAddressStr)
617 617              let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
618 618              let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
619 619              let claimedByUserBoostReward = getBigIntFromStringOrZero(this, claimedByUserBoostRewardKEY)
620 620              let claimedTotal = getBigIntFromStringOrZero(this, claimedTotalKEY)
621 621              let $t02511625228 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
622 622              let wxToClaimUserNew = $t02511625228._1
623 623              let integralSTATE = $t02511625228._2
624 624              let debug = $t02511625228._3
625 625              let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
626 626              if ((zeroBigInt >= availableToClaim))
627 627                  then if (throwIfNothingToClaim)
628 628                      then throw("nothing to claim")
629 629                      else $Tuple2(nil, 0)
630 630                  else {
631 631                      let wxAmountBoostTotal = max([asInt(asAnyList(invoke(boostingContract, "claimWxBoost", [lpAssetIdStr, userAddressStr], nil))[0]), 0])
632 632                      let minRewardPart = availableToClaim
633 633                      let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
634 634                      let totalReward = (minRewardPart + boostRewardPart)
635 635                      let wxAssetId = asByteVector(asAnyList(invoke(emissionContract, "emit", [toInt(minRewardPart)], nil))[0])
636 636                      let emitBoost = asAnyList(invoke(emissionContract, "emit", [toInt(boostRewardPart)], nil))
637 637                      if ((emitBoost == emitBoost))
638 638                          then {
639 639                              let claimedByUserValue = ((claimedByUser + minRewardPart) + boostRewardPart)
640 640                              let claimedByUserMinRewardPlusPart = (claimedByUserMinReward + minRewardPart)
641 641                              let claimedByUserBoostRewardPlusBoostRewardPart = (claimedByUserBoostReward + boostRewardPart)
642 642                              let claimedTotalPlusAvailableToClaim = (claimedTotal + availableToClaim)
643 643                              $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 644                              }
645 645                          else throw("Strict value is not equal to itself.")
646 646                      }
647 647              }
648 648          else throw("Strict value is not equal to itself.")
649 649      }
650 650  
651 651  
652 652  
653 653  @Callable(i)
654 654  func claimWxBulkInternalREADONLY (currentIter,lpAssetIds,userAddressStr,resAcc) = if ((currentIter == size(lpAssetIds)))
655 655      then $Tuple2(nil, resAcc)
656 656      else {
657 657          let lpAssetId = lpAssetIds[currentIter]
658 658          let info = split({
659 659              let @ = invoke(this, "claimWxREADONLY", [lpAssetId, userAddressStr], nil)
660 660              if ($isInstanceOf(@, "String"))
661 661                  then @
662 662                  else throw(($getType(@) + " couldn't be cast to String"))
663 663              }, SEP)
664 664          let unclaimed = info[3]
665 665          let claimed = info[4]
666 666          let res = (resAcc :+ makeString(["%d%d", unclaimed, claimed], SEP))
667 667          let inv = {
668 668              let @ = invoke(this, "claimWxBulkInternalREADONLY", [(currentIter + 1), lpAssetIds, userAddressStr, res], nil)
669 669              if ($isInstanceOf(@, "List[Any]"))
670 670                  then @
671 671                  else throw(($getType(@) + " couldn't be cast to List[Any]"))
672 672              }
673 673          if ((inv == inv))
674 674              then $Tuple2(nil, inv)
675 675              else throw("Strict value is not equal to itself.")
676 676          }
677 677  
678 678  
679 679  
680 680  @Callable(i)
681 681  func claimWxBulkREADONLY (lpAssetIds,userAddressStr) = {
682 682      let res = invoke(this, "claimWxBulkInternalREADONLY", [0, lpAssetIds, userAddressStr, nil], nil)
683 683      $Tuple2(nil, res)
684 684      }
685 685  
686 686  
687 687  
688 688  @Callable(i)
689 689  func claimWxREADONLY (lpAssetIdStr,userAddressStr) = {
690 690      let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
691 691      let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
692 692      let claimedByUserKEY = keyClaimedByUser(lpAssetIdStr, userAddressStr)
693 693      let claimedByUserMinRewardKEY = keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr)
694 694      let stakedByUser = readStaked(stakedByUserKEY)
695 695      let stakedTotal = readStaked(stakedTotalKEY)
696 696      let claimedByUser = getBigIntFromStringOrZero(this, claimedByUserKEY)
697 697      let claimedByUserMinReward = getBigIntFromStringOrZero(this, claimedByUserMinRewardKEY)
698 698      let poolAddressStr = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetIdStr))
699 699      let poolWeight = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
700 700      let wxEmissionPerBlock = getIntOrFail(emissionContract, keyEmissionRatePerBlockCurrent())
701 701      let emissionStartBlock = getIntOrFail(emissionContract, keyEmissionStartBlock())
702 702      let passedBlocks = if ((emissionStartBlock > height))
703 703          then 0
704 704          else (height - emissionStartBlock)
705 705      let poolWxEmission = fraction((wxEmissionPerBlock * passedBlocks), poolWeight, POOLWEIGHTMULT)
706 706      let userWxReward = fraction(poolWxEmission, stakedByUser, stakedTotal)
707 707      let $t02903729149 = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)
708 708      let wxToClaimUserNew = $t02903729149._1
709 709      let integralSTATE = $t02903729149._2
710 710      let debug = $t02903729149._3
711 711      let availableToClaim = max([(wxToClaimUserNew - claimedByUserMinReward), zeroBigInt])
712 712      let boostInvResult = asAnyList(invoke(boostingContract, "claimWxBoostREADONLY", [lpAssetIdStr, userAddressStr], nil))
713 713      let wxAmountBoostTotal = max([asInt(boostInvResult[0]), 0])
714 714      let boostDebug = asString(boostInvResult[1])
715 715      let minRewardPart = availableToClaim
716 716      let boostRewardPart = min([(minRewardPart * toBigInt(2)), toBigInt(wxAmountBoostTotal)])
717 717      let totalReward = (minRewardPart + boostRewardPart)
718 718      $Tuple2(nil, makeString(["%s%s%d%d%d%d%s", lpAssetIdStr, userAddressStr, toString(totalReward), toString(claimedByUser), toString(minRewardPart), toString(boostRewardPart), "soon"], SEP))
719 719      }
720 720  
721 721  
722 722  
723 723  @Callable(i)
724 724  func stakedByUserREADONLY (lpAssetIdStr,userAddressStr) = {
725 725      let stakedByUser = valueOrElse(getInteger(keyStakedByUser(userAddressStr, lpAssetIdStr)), 0)
726 726      $Tuple2(nil, stakedByUser)
727 727      }
728 728  
729 729  
730 730  
731 731  @Callable(i)
732 732  func usersListTraversal (lpAssetId) = {
733 733      let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
734 734          then true
735 735          else mustManager(i)
736 736      if ((checkCaller == checkCaller))
737 737          then {
738 738              let listName = getUsersListName(lpAssetId)
739 739              let userOrUnit = getString(keyNextUser(lpAssetId))
740 740              let headOrUnit = getString(keyListHead(listName))
741 741              match userOrUnit {
742 742                  case _: Unit => 
743 743                      match headOrUnit {
744 744                          case _: Unit => 
745 745                              $Tuple2(nil, false)
746 746                          case head: String => 
747 747                              $Tuple2([StringEntry(keyNextUser(lpAssetId), head)], true)
748 748                          case _ => 
749 749                              throw("Match error")
750 750                      }
751 751                  case userAddress: String => 
752 752                      let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetId, userAddress))
753 753                      let poolAddress = getStringByAddressOrFail(factoryContract, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
754 754                      let wxToClaimUserNew = refreshINTEGRALS(lpAssetId, userAddress, poolAddress, 0)._1
755 755                      let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
756 756                      let throwIfNothingToClaim = true
757 757                      let r = if ((availableToClaim > zeroBigInt))
758 758                          then invoke(this, "claimWxINTERNAL", [lpAssetId, userAddress, throwIfNothingToClaim], nil)
759 759                          else unit
760 760                      if ((r == r))
761 761                          then {
762 762                              let nextUserOrUnit = getString(keyListNext(listName, userAddress))
763 763                              match nextUserOrUnit {
764 764                                  case _: Unit => 
765 765                                      $Tuple2([DeleteEntry(keyNextUser(lpAssetId))], false)
766 766                                  case nextUser: String => 
767 767                                      $Tuple2([StringEntry(keyNextUser(lpAssetId), nextUser)], true)
768 768                                  case _ => 
769 769                                      throw("Match error")
770 770                              }
771 771                              }
772 772                          else throw("Strict value is not equal to itself.")
773 773                  case _ => 
774 774                      throw("Match error")
775 775              }
776 776              }
777 777          else throw("Strict value is not equal to itself.")
778 778      }
779 779  
780 780  
781 781  
782 782  @Callable(i)
783 783  func onModifyWeight (lpAssetIdStr,poolAddressStr) = if ((i.caller != factoryContract))
784 784      then throw("permissions denied")
785 785      else {
786 786          let $t03175531865 = refreshPoolINTEGRALS(lpAssetIdStr, poolAddressStr, 0)
787 787          let wxPerLpIntegralNew = $t03175531865._1
788 788          let poolIntegralSTATE = $t03175531865._2
789 789          let poolDEBUG = $t03175531865._3
790 790          poolIntegralSTATE
791 791          }
792 792  
793 793  
794 794  @Verifier(tx)
795 795  func verify () = {
796 796      let targetPublicKey =     match managerPublicKeyOrUnit() {
797 797          case pk: ByteVector => 
798 798              pk
799 799          case _: Unit => 
800 800              tx.senderPublicKey
801 801          case _ => 
802 802              throw("Match error")
803 803      }
804 804      sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
805 805      }
806 806

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	423	func unstakeActions (i,lpAssetId,poolAddress,userAddress,lpAssetRecipientAddress,amount) = {
424	424	let userAddressStr = toString(userAddress)
425	425	let lpAssetIdStr = toBase58String(lpAssetId)
426	426	let poolAddressStr = toString(poolAddress)
427	427	let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
428	428	let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
429	429	let stakedByUser = readStaked(stakedByUserKEY)
430	430	let stakedTotal = readStaked(stakedTotalKEY)
431	431	let integralSTATE = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, -(amount))._2
432	432	let listName = getUsersListName(lpAssetIdStr)
433	433	let listActions = if (if (containsNode(listName, userAddressStr))
434	434	then (amount == stakedByUser)
435	435	else false)
436	436	then deleteNodeActions(listName, userAddressStr)
437	437	else nil
438	438	let refreshStakedVote = if ((amount == stakedByUser))
439	439	then invoke(boostingContract, "onStakedVoteUpdate", [lpAssetIdStr, userAddressStr, false], nil)
440	440	else unit
441	441	if ((refreshStakedVote == refreshStakedVote))
442	442	then {
443	443	let claimedByUserMinReward = getBigIntFromStringOrZero(this, keyClaimedByUserMinReward(lpAssetIdStr, userAddressStr))
444	444	let wxToClaimUserNew = refreshINTEGRALS(lpAssetIdStr, userAddressStr, poolAddressStr, 0)._1
445	445	let availableToClaim = (wxToClaimUserNew - claimedByUserMinReward)
446	446	let throwIfNothingToClaim = true
447	447	let r = if ((availableToClaim > zeroBigInt))
448	448	then invoke(this, "claimWxINTERNAL", [lpAssetIdStr, userAddressStr, throwIfNothingToClaim], nil)
449	449	else unit
450	450	if ((r == r))
451	451	then if ((amount > stakedByUser))
452	452	then throw(((((((("passed amount=" + toString(amount)) + " is greater than available=") + toString(stakedByUser)) + ". lpAssetId=") + lpAssetIdStr) + ". stakedByUserKEY=") + stakedByUserKEY))
453	453	else (([IntegerEntry(stakedByUserKEY, (stakedByUser - amount)), IntegerEntry(stakedTotalKEY, (stakedTotal - amount)), ScriptTransfer(lpAssetRecipientAddress, amount, lpAssetId), OperationHistoryEntry("unstake", userAddressStr, lpAssetIdStr, amount, i.transactionId)] ++ integralSTATE) ++ listActions)
454	454	else throw("Strict value is not equal to itself.")
455	455	}
456	456	else throw("Strict value is not equal to itself.")
457	457	}
458	458
459	459
460	460	@Callable(i)
461	461	func constructor (factoryAddressStr) = {
462	462	let checkCaller = mustManager(i)
463	463	if ((checkCaller == checkCaller))
464	464	then [StringEntry(keyFactoryAddress(), factoryAddressStr)]
465	465	else throw("Strict value is not equal to itself.")
466	466	}
467	467
468	468
469	469
470	470	@Callable(i)
471	471	func constructorV2 (votingEmissionContract) = {
472	472	let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
473	473	then true
474	474	else "invalid voting emission contract address"]
475	475	if ((cheks == cheks))
476	476	then [StringEntry(keyVotingEmissionContract(), votingEmissionContract)]
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 setManager (pendingManagerPublicKey) = {
484	484	let checkCaller = mustManager(i)
485	485	if ((checkCaller == checkCaller))
486	486	then {
487	487	let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
488	488	if ((checkManagerPublicKey == checkManagerPublicKey))
489	489	then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
490	490	else throw("Strict value is not equal to itself.")
491	491	}
492	492	else throw("Strict value is not equal to itself.")
493	493	}
494	494
495	495
496	496
497	497	@Callable(i)
498	498	func confirmManager () = {
499	499	let pm = pendingManagerPublicKeyOrUnit()
500	500	let hasPM = if (isDefined(pm))

github/deemru/w8io/169f3d6 
70.92 ms ◑