w8 · tx · 86S···bug

tx · 86Sg5HHJwSxwiuysoKhj4UmzLFTiKJvXYUudjbo1pbug

3MwNfynRH5bFf25GzWjcEdi6kSkX4AwR9Bz:  -0.03300000 Waves

2023.03.20 11:06 [2498071] smart account 3MwNfynRH5bFf25GzWjcEdi6kSkX4AwR9Bz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "86Sg5HHJwSxwiuysoKhj4UmzLFTiKJvXYUudjbo1pbug",
    "fee": 3300000,
    "feeAssetId": null,
    "timestamp": 1679299604034,
    "version": 2,
    "chainId": 84,
    "sender": "3MwNfynRH5bFf25GzWjcEdi6kSkX4AwR9Bz",
    "senderPublicKey": "CP4TEKgebTgiDjwiN6XPMRxxtJr9ZNVotimqif4HEqx5",
    "proofs": [
        "2ZCEwA6iZFBEYPW3oZW6Vfc5fxNQ1hGULsh6ediB5es5f44Avc4GsNu7MiY6vEBNwGBTG5paN5oKDUkBfi3yPis4"
    ],
    "script": "base64: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",
    "height": 2498071,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6obG9ZKqiiBsDqTGqJ8dN4TxmgLrq4Dz6CQGFQEmnxtP
Next: Ha48CcnuAZVRiHbGaaQJKw3S6H1QcWchqST32Eipq9Za

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

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

github/deemru/w8io/169f3d6 
46.72 ms ◑