tx · 9Vcb37WVJapTfnmTYgozzUAWdEiTTjXQDcAhXmKVjkku

3NB8Yc3PYs2zCzFyyTZmP9PucxDB1obJXZB:  -0.03800000 Waves

2023.03.16 14:20 [2492511] smart account 3NB8Yc3PYs2zCzFyyTZmP9PucxDB1obJXZB > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9Vcb37WVJapTfnmTYgozzUAWdEiTTjXQDcAhXmKVjkku",
    "fee": 3800000,
    "feeAssetId": null,
    "timestamp": 1678965693991,
    "version": 2,
    "chainId": 84,
    "sender": "3NB8Yc3PYs2zCzFyyTZmP9PucxDB1obJXZB",
    "senderPublicKey": "2WysCpmFpq5PHtT8uiLCYxeAmvDWeLtzBcci5UTkYDya",
    "proofs": [
        "5wrjeu3emrgQ8jSQAjhHLaWfyCVqrtA4M2HtYwFefj3U2m5Amv5p1nGT7EUqdgFzwNWw3Nct3fPb4DXx19qb4Wnj"
    ],
    "script": "base64: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",
    "height": 2492511,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8zLUeUd6XSXuxJrrtZSHmaeL3jze9Zyd3cPUEGVxQqE4
Next: 8ysAkcjJGCMC2pkzZrv9BeymHcET4v1Fu3zP7QzL5yJQ

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let SCALE8 = 8
7+
8+let MULT8 = 100000000
9+
10+let POOLWEIGHTMULT = MULT8
11+
12+func wrapErr (msg) = makeString(["boosting.ride:", msg], " ")
13+
14+
15+func throwErr (msg) = throw(wrapErr(msg))
16+
17+
18+func strf (address,key) = valueOrErrorMessage(getString(address, key), (("mandatory this." + key) + " is not defined"))
19+
20+
21+func ioz (address,key) = valueOrElse(getInteger(address, key), 0)
22+
23+
24+func iod (address,key,defaultVal) = valueOrElse(getInteger(address, key), defaultVal)
25+
26+
27+func iof (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
28+
29+
30+func abs (val) = if ((0 > val))
31+    then -(val)
32+    else val
33+
34+
35+func aal (val) = match val {
36+    case valAnyLyst: List[Any] => 
37+        valAnyLyst
38+    case _ => 
39+        throw("fail to cast into List[Any]")
40+}
41+
42+
43+func ai (val) = match val {
44+    case valInt: Int => 
45+        valInt
46+    case _ => 
47+        throw("fail to cast into Int")
48+}
49+
50+
51+func keyReferralsContractAddress () = makeString(["%s%s", "config", "referralsContractAddress"], SEP)
52+
53+
54+let referralsContractAddressOrFail = addressFromStringValue(strf(this, keyReferralsContractAddress()))
55+
56+let keyReferralProgramName = makeString(["%s%s", "referral", "programName"], SEP)
57+
58+let referralProgramNameDefault = "wxlock"
59+
60+let referralProgramName = valueOrElse(getString(this, keyReferralProgramName), referralProgramNameDefault)
61+
62+func keyFactoryAddress () = "%s%s__config__factoryAddress"
63+
64+
65+let IdxFactoryCfgStakingDapp = 1
66+
67+let IdxFactoryCfgBoostingDapp = 2
68+
69+let IdxFactoryCfgIdoDapp = 3
70+
71+let IdxFactoryCfgTeamDapp = 4
72+
73+let IdxFactoryCfgEmissionDapp = 5
74+
75+let IdxFactoryCfgRestDapp = 6
76+
77+let IdxFactoryCfgSlippageDapp = 7
78+
79+let IdxFactoryCfgDaoDapp = 8
80+
81+let IdxFactoryCfgMarketingDapp = 9
82+
83+let IdxFactoryCfgGwxRewardDapp = 10
84+
85+let IdxFactoryCfgBirdsDapp = 11
86+
87+func keyFactoryCfg () = "%s__factoryConfig"
88+
89+
90+func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
91+
92+
93+func keyFactoryLpList () = "%s__lpTokensList"
94+
95+
96+func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
97+
98+
99+func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
100+
101+
102+func keyFactoryPoolWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
103+
104+
105+func readFactoryAddressOrFail () = addressFromStringValue(strf(this, keyFactoryAddress()))
106+
107+
108+func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
109+
110+
111+func readFactoryCfgOrFail (factory) = split(strf(factory, keyFactoryCfg()), SEP)
112+
113+
114+func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
115+
116+
117+func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
118+
119+
120+func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
121+
122+
123+func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
124+
125+
126+func keyManagerPublicKey () = "%s__managerPublicKey"
127+
128+
129+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
130+
131+
132+func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
133+
134+
135+func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
136+
137+
138+func keyEmissionStartBlock () = "%s%s__emission__startBlock"
139+
140+
141+func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
142+
143+
144+func keyEmissionEndBlock () = "%s%s__emission__endBlock"
145+
146+
147+func keyNextPeriod () = "%s__nextPeriod"
148+
149+
150+func keyGwxRewardEmissionStartHeight () = "%s%s__gwxRewardEmissionPart__startHeight"
151+
152+
153+let IdxCfgAssetId = 1
154+
155+let IdxCfgMinLockAmount = 2
156+
157+let IdxCfgMinLockDuration = 3
158+
159+let IdxCfgMaxLockDuration = 4
160+
161+let IdxCfgMathContract = 5
162+
163+func keyConfig () = "%s__config"
164+
165+
166+func readConfigArrayOrFail () = split(strf(this, keyConfig()), SEP)
167+
168+
169+let mathContract = addressFromStringValue(readConfigArrayOrFail()[IdxCfgMathContract])
170+
171+func formatConfigS (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = makeString(["%s%d%d%d", assetId, minLockAmount, minLockDuration, maxLockDuration, mathContract], SEP)
172+
173+
174+func formatConfig (assetId,minLockAmount,minLockDuration,maxLockDuration,mathContract) = formatConfigS(assetId, toString(minLockAmount), toString(minLockDuration), toString(maxLockDuration), mathContract)
175+
176+
177+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
178+    case s: String => 
179+        fromBase58String(s)
180+    case _: Unit => 
181+        unit
182+    case _ => 
183+        throw("Match error")
184+}
185+
186+
187+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
188+    case s: String => 
189+        fromBase58String(s)
190+    case _: Unit => 
191+        unit
192+    case _ => 
193+        throw("Match error")
194+}
195+
196+
197+func mustManager (i) = {
198+    let pd = throw("Permission denied")
199+    match managerPublicKeyOrUnit() {
200+        case pk: ByteVector => 
201+            if ((i.callerPublicKey == pk))
202+                then true
203+                else pd
204+        case _: Unit => 
205+            if ((i.caller == this))
206+                then true
207+                else pd
208+        case _ => 
209+            throw("Match error")
210+    }
211+    }
212+
213+
214+let IdxLockUserNum = 1
215+
216+let IdxLockAmount = 2
217+
218+let IdxLockStart = 3
219+
220+let IdxLockDuration = 4
221+
222+let IdxLockParamK = 5
223+
224+let IdxLockParamB = 6
225+
226+func keyLockParamsRecord (userAddress) = makeString(["%s%s__lock", userAddress], SEP)
227+
228+
229+func readLockParamsRecordOrFail (userAddress) = split(strf(this, keyLockParamsRecord(userAddress)), SEP)
230+
231+
232+func formatLockParamsRecordS (userNum,amount,start,duration,paramK,paramB,lastUpdTimestamp,gwxAmount) = makeString(["%d%d%d%d%d%d%d%d", userNum, amount, start, duration, paramK, paramB, lastUpdTimestamp, gwxAmount], SEP)
233+
234+
235+func formatLockParamsRecord (userNum,amount,start,duration,paramK,paramB,gwxAmount) = formatLockParamsRecordS(userNum, toString(amount), toString(start), toString(duration), toString(paramK), toString(paramB), toString(lastBlock.timestamp), toString(gwxAmount))
236+
237+
238+func keyNextUserNum () = "%s__nextUserNum"
239+
240+
241+func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
242+
243+
244+func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
245+
246+
247+func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
248+
249+
250+func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
251+
252+
253+func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
254+
255+
256+func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
257+
258+
259+func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
260+
261+
262+func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
263+
264+
265+func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
266+
267+
268+func keyLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
269+
270+
271+func keyStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
272+
273+
274+func keyStatsLocksCount () = "%s%s__stats__locksCount"
275+
276+
277+func keyStatsUsersCount () = "%s%s__stats__activeUsersCount"
278+
279+
280+func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
281+
282+
283+func keyUserLpBoostEmissionLastINTEGRAL (userNum,lpAssetId) = makeString(["%s%d__userBoostEmissionLastInt", userNum, lpAssetId], SEP)
284+
285+
286+func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
287+
288+
289+func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
290+
291+
292+func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
293+
294+
295+func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
296+
297+
298+func keyTotalCachedGwx () = "%s%s__gwxCached__total"
299+
300+
301+func keyTotalCachedGwxCorrective () = "%s__gwxCachedTotalCorrective"
302+
303+
304+let factoryContract = readFactoryAddressOrFail()
305+
306+let factoryCfg = readFactoryCfgOrFail(factoryContract)
307+
308+let emissionContract = getEmissionAddressOrFail(factoryCfg)
309+
310+let stakingContract = getStakingAddressOrFail(factoryCfg)
311+
312+let gwxRewardContract = getGwxRewardAddressOrFail(factoryCfg)
313+
314+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"))
315+
316+let keyVotingEmissionContract = makeString(["%s", "votingEmissionContract"], SEP)
317+
318+let votingEmissionContract = addressFromStringValue(getStringValue(factoryContract, keyVotingEmissionContract))
319+
320+func getTotalCachedGwx (correct) = {
321+    let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], SEP)
322+    let currentEpochUi = getIntegerValue(votingEmissionContract, keyCurrentEpochUi)
323+    let keyTargetEpoch = makeString(["%s%s", "totalCachedGwxCorrection__activationEpoch"], SEP)
324+    let targetEpochOption = getInteger(this, keyTargetEpoch)
325+    let totalCachedGwxRaw = valueOrElse(getInteger(this, keyTotalCachedGwx()), 0)
326+    let isCorrectionActivated = if (isDefined(targetEpochOption))
327+        then (currentEpochUi >= value(targetEpochOption))
328+        else false
329+    let corrective = if (if (isCorrectionActivated)
330+        then correct
331+        else false)
332+        then valueOrElse(getInteger(this, keyTotalCachedGwxCorrective()), 0)
333+        else 0
334+    max([0, (totalCachedGwxRaw + corrective)])
335+    }
336+
337+
338+func HistoryEntry (type,user,amount,lockStart,duration,k,b,i) = {
339+    let historyKEY = makeString(["%s%s%s%s__history", type, user, toBase58String(i.transactionId)], SEP)
340+    let historyDATA = makeString(["%d%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(amount), toString(lockStart), toString(duration), toString(k), toString(b)], SEP)
341+    StringEntry(historyKEY, historyDATA)
342+    }
343+
344+
345+func StatsEntry (totalLockedInc,durationInc,lockCountInc,usersCountInc) = {
346+    let locksDurationSumInBlocksKEY = keyStatsLocksDurationSumInBlocks()
347+    let locksCountKEY = keyStatsLocksCount()
348+    let usersCountKEY = keyStatsUsersCount()
349+    let totalAmountKEY = keyLockParamTotalAmount()
350+    let locksDurationSumInBlocks = ioz(this, locksDurationSumInBlocksKEY)
351+    let locksCount = ioz(this, locksCountKEY)
352+    let usersCount = ioz(this, usersCountKEY)
353+    let totalAmount = ioz(this, totalAmountKEY)
354+[IntegerEntry(locksDurationSumInBlocksKEY, (locksDurationSumInBlocks + durationInc)), IntegerEntry(locksCountKEY, (locksCount + lockCountInc)), IntegerEntry(usersCountKEY, (usersCount + usersCountInc)), IntegerEntry(totalAmountKEY, (totalAmount + totalLockedInc))]
355+    }
356+
357+
358+func calcGwxAmount (kRaw,bRaw,h) = {
359+    let SCALE = 1000
360+    (((kRaw * h) + bRaw) / SCALE)
361+    }
362+
363+
364+func LockParamsEntry (userAddress,userNum,amount,start,duration,k,b,period) = {
365+    let userAmountKEY = keyLockParamUserAmount(userNum)
366+    let startBlockKEY = keyLockParamStartBlock(userNum)
367+    let durationKEY = keyLockParamDuration(userNum)
368+    let kKEY = keyLockParamK(userNum)
369+    let bKEY = keyLockParamB(userNum)
370+    let kByPeriodKEY = keyLockParamByPeriodK(userNum, period)
371+    let bByPeriodKEY = keyLockParamByPeriodB(userNum, period)
372+    let gwxAmount = calcGwxAmount(k, b, height)
373+[IntegerEntry(userAmountKEY, amount), IntegerEntry(startBlockKEY, start), IntegerEntry(durationKEY, duration), IntegerEntry(kKEY, k), IntegerEntry(bKEY, b), IntegerEntry(kByPeriodKEY, k), IntegerEntry(bByPeriodKEY, b), StringEntry(keyLockParamsRecord(userAddress), formatLockParamsRecord(userNum, amount, start, duration, k, b, gwxAmount))]
374+    }
375+
376+
377+func extractOptionalPaymentAmountOrFail (i,expectedAssetId) = if ((size(i.payments) > 1))
378+    then throw("only one payment is allowed")
379+    else if ((size(i.payments) == 0))
380+        then 0
381+        else {
382+            let pmt = i.payments[0]
383+            if ((value(pmt.assetId) != expectedAssetId))
384+                then throw("invalid asset id in payment")
385+                else pmt.amount
386+            }
387+
388+
389+func calcUserGwxAmountAtHeight (userAddress,targetHeight) = {
390+    let EMPTY = "empty"
391+    let user2NumMappingKEY = keyUser2NumMapping(userAddress)
392+    let userNum = valueOrElse(getString(user2NumMappingKEY), EMPTY)
393+    let k = valueOrElse(getInteger(keyLockParamK(userNum)), 0)
394+    let b = valueOrElse(getInteger(keyLockParamB(userNum)), 0)
395+    let gwxAmountCalc = calcGwxAmount(k, b, targetHeight)
396+    let gwxAmount = if ((0 > gwxAmountCalc))
397+        then 0
398+        else gwxAmountCalc
399+    gwxAmount
400+    }
401+
402+
403+func calcCurrentGwxAmount (userAddress) = calcUserGwxAmountAtHeight(userAddress, height)
404+
405+
406+func getVotingEmissionEpochInfo () = {
407+    let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], SEP)
408+    let $t01526715559 = {
409+        let currentEpochUi = value(getInteger(votingEmissionContract, keyCurrentEpochUi))
410+        let lastFinalizedEpoch = (currentEpochUi - 1)
411+        if ((0 > lastFinalizedEpoch))
412+            then throwErr("invalid epoch")
413+            else $Tuple2(currentEpochUi, lastFinalizedEpoch)
414+        }
415+    let currentEpochUi = $t01526715559._1
416+    let lastFinalizedEpoch = $t01526715559._2
417+    func keyStartHeightByEpoch (epoch) =     makeString(["%s%d", "startHeight", toString(epoch)], SEP)
418+
419+    let currentEpochStartHeight = value(getInteger(votingEmissionContract, keyStartHeightByEpoch(currentEpochUi)))
420+    $Tuple2(lastFinalizedEpoch, currentEpochStartHeight)
421+    }
422+
423+
424+func keyVote (amountAssetId,priceAssetId,address,epoch) = makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], SEP)
425+
426+
427+func keyVotingResultStaked (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStaked", lpAssetIdStr, toString(epoch)], SEP)
428+
429+
430+func keyVotingResultStakedIntegral (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegral", lpAssetIdStr, toString(epoch)], SEP)
431+
432+
433+func keyVotingResultStakedLastUpdateHeight (lpAssetIdStr,epoch) = makeString(["%s%s%d", "votingResultStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(epoch)], SEP)
434+
435+
436+func keyVoteStakedIntegral (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegral", lpAssetIdStr, toString(address), toString(epoch)], SEP)
437+
438+
439+func keyVoteStakedLastUpdateHeight (lpAssetIdStr,address,epoch) = makeString(["%s%s%s%d", "voteStakedIntegralLastUpdateHeight", lpAssetIdStr, toString(address), toString(epoch)], SEP)
440+
441+
442+func getVotingResultStaked (lpAssetIdStr) = {
443+    let $t01728317363 = getVotingEmissionEpochInfo()
444+    let lastFinalizedEpoch = $t01728317363._1
445+    let currentEpochStartHeight = $t01728317363._2
446+    let votingResultStakedStart = valueOrElse(getInteger(votingEmissionContract, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), 0)
447+    let votingResultStaked = valueOrElse(getInteger(this, keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch)), votingResultStakedStart)
448+    votingResultStaked
449+    }
450+
451+
452+func refreshVotingResultStakedIntegral (lpAssetIdStr,stakedVoteDelta) = {
453+    let $t01789717977 = getVotingEmissionEpochInfo()
454+    let lastFinalizedEpoch = $t01789717977._1
455+    let currentEpochStartHeight = $t01789717977._2
456+    let votingResultStaked = getVotingResultStaked(lpAssetIdStr)
457+    let votingResultStakedNew = (votingResultStaked + stakedVoteDelta)
458+    let votingResultStakedIntegralKey = keyVotingResultStakedIntegral(lpAssetIdStr, lastFinalizedEpoch)
459+    let votingResultStakedIntegralPrev = valueOrElse(getInteger(this, votingResultStakedIntegralKey), 0)
460+    let votingResultLastUpdateHeightKey = keyVotingResultStakedLastUpdateHeight(lpAssetIdStr, lastFinalizedEpoch)
461+    let votingResultStakedLastUpdateHeight = valueOrElse(getInteger(this, votingResultLastUpdateHeightKey), currentEpochStartHeight)
462+    let votingResultStakedIntegralDh = (height - votingResultStakedLastUpdateHeight)
463+    let votingResultStakedIntegral = ((votingResultStakedIntegralDh * votingResultStaked) + votingResultStakedIntegralPrev)
464+    $Tuple2([IntegerEntry(keyVotingResultStaked(lpAssetIdStr, lastFinalizedEpoch), votingResultStakedNew), IntegerEntry(votingResultLastUpdateHeightKey, height), IntegerEntry(votingResultStakedIntegralKey, votingResultStakedIntegral)], votingResultStakedIntegral)
465+    }
466+
467+
468+func refreshVoteStakedIntegral (lpAssetIdStr,userAddressStr,edge) = {
469+    let $t01920219282 = getVotingEmissionEpochInfo()
470+    let lastFinalizedEpoch = $t01920219282._1
471+    let currentEpochStartHeight = $t01920219282._2
472+    let userAddress = addressFromStringValue(userAddressStr)
473+    let idxAmountAssetId = 4
474+    let idxPriceAssetId = 5
475+    let poolCfg = {
476+        let @ = invoke(factoryContract, "getPoolConfigByLpAssetId", [lpAssetIdStr], nil)
477+        if ($isInstanceOf(@, "List[Any]"))
478+            then @
479+            else throw(($getType(@) + " couldn't be cast to List[Any]"))
480+        }
481+    let amountAssetId = {
482+        let @ = poolCfg[idxAmountAssetId]
483+        if ($isInstanceOf(@, "String"))
484+            then @
485+            else throw(($getType(@) + " couldn't be cast to String"))
486+        }
487+    let priceAssetId = {
488+        let @ = poolCfg[idxPriceAssetId]
489+        if ($isInstanceOf(@, "String"))
490+            then @
491+            else throw(($getType(@) + " couldn't be cast to String"))
492+        }
493+    let userVote = valueOrElse(getInteger(votingEmissionContract, keyVote(amountAssetId, priceAssetId, userAddress, lastFinalizedEpoch)), 0)
494+    let actions = if ((userVote == 0))
495+        then nil
496+        else {
497+            let stakedVoteDelta = if (edge)
498+                then userVote
499+                else -(userVote)
500+            let $t01990020019 = refreshVotingResultStakedIntegral(lpAssetIdStr, stakedVoteDelta)
501+            let votingResultActions = $t01990020019._1
502+            let votingResultStakedIntegral = $t01990020019._2
503+            let userVoteStaked = if (edge)
504+                then 0
505+                else userVote
506+            let userVoteStakedIntegralKey = keyVoteStakedIntegral(lpAssetIdStr, userAddress, lastFinalizedEpoch)
507+            let userVoteStakedIntegralPrev = valueOrElse(getInteger(this, userVoteStakedIntegralKey), 0)
508+            let userVoteStakedLastUpdateHeightKey = keyVoteStakedLastUpdateHeight(lpAssetIdStr, userAddress, lastFinalizedEpoch)
509+            let userVoteStakedLastUpdateHeight = valueOrElse(getInteger(this, userVoteStakedLastUpdateHeightKey), currentEpochStartHeight)
510+            let userVoteStakedIntegralDh = (height - userVoteStakedLastUpdateHeight)
511+            let userVoteStakedIntegral = ((userVoteStakedIntegralDh * userVoteStaked) + userVoteStakedIntegralPrev)
512+            let voteActions = [IntegerEntry(userVoteStakedLastUpdateHeightKey, height), IntegerEntry(userVoteStakedIntegralKey, userVoteStakedIntegral)]
513+            (votingResultActions ++ voteActions)
514+            }
515+    actions
516+    }
517+
518+
519+func internalClaimWxBoost (lpAssetIdStr,userAddressStr,readOnly) = {
520+    let EMPTY = "EMPTY"
521+    let userRecordOrEmpty = valueOrElse(getString(this, keyLockParamsRecord(userAddressStr)), EMPTY)
522+    if ((userRecordOrEmpty == EMPTY))
523+        then $Tuple3(0, nil, "userRecord::is::empty")
524+        else {
525+            let userRecordArray = split(userRecordOrEmpty, SEP)
526+            let userNumStr = userRecordArray[IdxLockUserNum]
527+            let gwxRewardEmissionStartHeight = valueOrElse(getInteger(gwxRewardContract, keyGwxRewardEmissionStartHeight()), 0)
528+            let EMPTYSTR = "empty"
529+            let $t02152922107 = if ((lpAssetIdStr != EMPTYSTR))
530+                then {
531+                    let poolAddressStr = valueOrErrorMessage(getString(factoryContract, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
532+                    let pw1 = getIntegerValue(factoryContract, keyFactoryPoolWeight(poolAddressStr))
533+                    let pw0 = valueOrElse(getInteger(factoryContract, keyFactoryPoolWeightHistory(poolAddressStr, 0)), pw1)
534+                    $Tuple2(pw0, pw1)
535+                    }
536+                else if (readOnly)
537+                    then $Tuple2(0, 0)
538+                    else throw(("not readonly mode: unsupported lp asset " + lpAssetIdStr))
539+            let poolWeight0 = $t02152922107._1
540+            let poolWeight1 = $t02152922107._2
541+            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
542+            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
543+            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
544+            let h = if ((height > emissionEnd))
545+                then emissionEnd
546+                else height
547+            let dh = max([(h - emissionStart), 0])
548+            let userLpBoostEmissionLastIntegralKEY = keyUserLpBoostEmissionLastINTEGRAL(userNumStr, lpAssetIdStr)
549+            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
550+            let userBoostEmissionLastIntegral = valueOrElse(getInteger(this, userLpBoostEmissionLastIntegralKEY), ioz(this, userBoostEmissionLastIntegralKEY))
551+            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
552+            let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
553+            let udh = fraction(userBoostEmissionIntegral, 3, (2 * wxEmissionPerBlock))
554+            let uLastH = (h - udh)
555+            let udh0 = max([(gwxRewardEmissionStartHeight - uLastH), 0])
556+            let udh1 = ((h - uLastH) - udh0)
557+            if (if (if ((0 > uLastH))
558+                then true
559+                else (0 > udh1))
560+                then true
561+                else (abs(((udh0 + udh1) - udh)) >= 1))
562+                then throw(((((((((((("invalid udh calc: udh=" + toString(udh)) + " uLastH=") + toString(uLastH)) + " udh0=") + toString(udh0)) + " udh1=") + toString(udh1)) + " lpAssetId=") + lpAssetIdStr) + " userAddress=") + userAddressStr))
563+                else if ((0 > userBoostEmissionIntegral))
564+                    then throw("wrong calculations")
565+                    else {
566+                        let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
567+                        let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
568+                        let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
569+                        let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
570+                        let totalCachedGwxCorrected = getTotalCachedGwx(true)
571+                        let userCurrGwx = calcCurrentGwxAmount(userAddressStr)
572+                        let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
573+                        let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
574+                        let userBoostEmissionIntegral0 = if ((udh == 0))
575+                            then 0
576+                            else fraction(userBoostEmissionIntegral, udh0, udh)
577+                        let userBoostEmissionIntegral1 = if ((udh == 0))
578+                            then 0
579+                            else fraction(userBoostEmissionIntegral, udh1, udh)
580+                        let poolUserBoostEmissionIntegral0 = fraction(userBoostEmissionIntegral0, poolWeight0, POOLWEIGHTMULT)
581+                        let poolUserBoostEmissionIntegral1 = fraction(userBoostEmissionIntegral1, poolWeight1, POOLWEIGHTMULT)
582+                        let userBoostAvaliableToClaimTotalNew0 = if ((totalCachedGwxCorrected == 0))
583+                            then 0
584+                            else fraction(poolUserBoostEmissionIntegral0, userCurrGwx, totalCachedGwxCorrected)
585+                        let userBoostAvaliableToClaimTotalNew1 = if ((totalCachedGwxCorrected == 0))
586+                            then 0
587+                            else fraction(poolUserBoostEmissionIntegral1, userCurrGwx, totalCachedGwxCorrected)
588+                        let userBoostAvaliableToClaimTotalNew = (userBoostAvaliableToClaimTotalNew0 + userBoostAvaliableToClaimTotalNew1)
589+                        let userBoostClaimedKEY = keyUserBoostClaimed(userNumStr)
590+                        let userBoostClaimed = ioz(this, userBoostClaimedKEY)
591+                        let userBoostAvailable = (userBoostAvaliableToClaimTotalNew - userBoostClaimed)
592+                        let dataState = [IntegerEntry(userLpBoostEmissionLastIntegralKEY, boostEmissionIntegral)]
593+                        let debug = makeString([toString(userBoostEmissionLastIntegral), toString(userBoostEmissionIntegral), toString(userBoostClaimed), toString(userBoostAvailable), toString(poolWeight0), toString(poolWeight1), toString(h), toString(udh), toString(uLastH), toString(udh0), toString(udh1), toString(userCurrGwx), toString(totalCachedGwxCorrected)], ":")
594+                        $Tuple3(userBoostAvaliableToClaimTotalNew, dataState, debug)
595+                        }
596+            }
597+    }
598+
599+
600+func lockActions (i,duration) = {
601+    let cfgArray = readConfigArrayOrFail()
602+    let assetIdStr = cfgArray[IdxCfgAssetId]
603+    let assetId = fromBase58String(assetIdStr)
604+    let minLockAmount = parseIntValue(cfgArray[IdxCfgMinLockAmount])
605+    let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
606+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
607+    if ((size(i.payments) != 1))
608+        then throw("invalid payment - exact one payment must be attached")
609+        else {
610+            let pmt = i.payments[0]
611+            let pmtAmount = pmt.amount
612+            if ((assetId != value(pmt.assetId)))
613+                then throw((("invalid asset is in payment - " + assetIdStr) + " is expected"))
614+                else {
615+                    let nextUserNumKEY = keyNextUserNum()
616+                    let userAddressStr = toString(i.caller)
617+                    let userIsExisting = isDefined(getString(keyUser2NumMapping(userAddressStr)))
618+                    let userNumStr = if (userIsExisting)
619+                        then value(getString(keyUser2NumMapping(userAddressStr)))
620+                        else toString(iof(this, nextUserNumKEY))
621+                    let userNum = parseIntValue(userNumStr)
622+                    let lockStart = height
623+                    let startBlockKEY = keyLockParamStartBlock(userNumStr)
624+                    let durationKEY = keyLockParamDuration(userNumStr)
625+                    let userAmountKEY = keyLockParamUserAmount(userNumStr)
626+                    if (if ((minLockAmount > pmtAmount))
627+                        then (i.caller != lpStakingPoolsContract)
628+                        else false)
629+                        then throw(("amount is less then minLockAmount=" + toString(minLockAmount)))
630+                        else if ((minLockDuration > duration))
631+                            then throw(("passed duration is less then minLockDuration=" + toString(minLockDuration)))
632+                            else if ((duration > maxLockDuration))
633+                                then throw(("passed duration is greater then maxLockDuration=" + toString(maxLockDuration)))
634+                                else if (if (userIsExisting)
635+                                    then ((iof(this, startBlockKEY) + iof(this, durationKEY)) >= lockStart)
636+                                    else false)
637+                                    then throw("there is an active lock - consider to use increaseLock")
638+                                    else if ((ioz(this, userAmountKEY) > 0))
639+                                        then throw(("there are locked WXs - consider to use increaseLock " + userAmountKEY))
640+                                        else {
641+                                            let coeffX8 = fraction(duration, MULT8, maxLockDuration)
642+                                            let gWxAmountStart = fraction(pmtAmount, coeffX8, MULT8)
643+                                            let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStart, duration], nil))
644+                                            let k = ai(gWxParamsResultList[0])
645+                                            let b = ai(gWxParamsResultList[1])
646+                                            let period = toString(ai(gWxParamsResultList[2]))
647+                                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
648+                                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
649+                                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
650+                                            let h = if ((height > emissionEnd))
651+                                                then emissionEnd
652+                                                else height
653+                                            let dh = max([(h - emissionStart), 0])
654+                                            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
655+                                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
656+                                            let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
657+                                            let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
658+                                            let userMaxBoostInt = ((gWxAmountStart * duration) / 2)
659+                                            let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
660+                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
661+                                            let arr = if (userIsExisting)
662+                                                then nil
663+                                                else [IntegerEntry(nextUserNumKEY, (userNum + 1)), StringEntry(keyUser2NumMapping(userAddressStr), userNumStr), StringEntry(keyNum2UserMapping(userNumStr), userAddressStr)]
664+                                            $Tuple2(((((arr ++ LockParamsEntry(userAddressStr, userNumStr, pmtAmount, lockStart, duration, k, b, period)) ++ StatsEntry(pmtAmount, duration, 1, if (userIsExisting)
665+                                                then 0
666+                                                else 1)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, duration, k, b, i)) ++ [IntegerEntry(userBoostEmissionLastIntegralKEY, boostEmissionIntegral), IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gWxAmountStart))]), gWxAmountStart)
667+                                            }
668+                    }
669+            }
670+    }
671+
672+
673+@Callable(i)
674+func constructor (factoryAddressStr,lockAssetIdStr,minLockAmount,minDuration,maxDuration,mathContract) = {
675+    let checkCaller = mustManager(i)
676+    if ((checkCaller == checkCaller))
677+        then ([IntegerEntry(keyNextUserNum(), 0), StringEntry(keyConfig(), formatConfig(lockAssetIdStr, minLockAmount, minDuration, maxDuration, mathContract)), StringEntry(keyFactoryAddress(), factoryAddressStr)] ++ StatsEntry(0, 0, 0, 0))
678+        else throw("Strict value is not equal to itself.")
679+    }
680+
681+
682+
683+@Callable(i)
684+func lockRef (duration,referrerAddress,signature) = {
685+    let $t03074230807 = lockActions(i, duration)
686+    let lockActionsResult = $t03074230807._1
687+    let gWxAmountStart = $t03074230807._2
688+    let referralAddress = toString(i.caller)
689+    let refInv = if (if ((referrerAddress == ""))
690+        then true
691+        else (signature == base58''))
692+        then unit
693+        else invoke(referralsContractAddressOrFail, "createPair", [referralProgramName, referrerAddress, referralAddress, signature], nil)
694+    if ((refInv == refInv))
695+        then {
696+            let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
697+            if ((updateRefActivity == updateRefActivity))
698+                then $Tuple2(lockActionsResult, unit)
699+                else throw("Strict value is not equal to itself.")
700+            }
701+        else throw("Strict value is not equal to itself.")
702+    }
703+
704+
705+
706+@Callable(i)
707+func lock (duration) = {
708+    let $t03127731342 = lockActions(i, duration)
709+    let lockActionsResult = $t03127731342._1
710+    let gWxAmountStart = $t03127731342._2
711+    let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
712+    if ((updateRefActivity == updateRefActivity))
713+        then $Tuple2(lockActionsResult, unit)
714+        else throw("Strict value is not equal to itself.")
715+    }
716+
717+
718+
719+@Callable(i)
720+func increaseLock (deltaDuration) = {
721+    let cfgArray = readConfigArrayOrFail()
722+    let assetIdStr = cfgArray[IdxCfgAssetId]
723+    let assetId = fromBase58String(assetIdStr)
724+    let minLockDuration = parseIntValue(cfgArray[IdxCfgMinLockDuration])
725+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
726+    let pmtAmount = extractOptionalPaymentAmountOrFail(i, assetId)
727+    let userAddressStr = toString(i.caller)
728+    let userRecordArray = readLockParamsRecordOrFail(userAddressStr)
729+    let userNumStr = userRecordArray[IdxLockUserNum]
730+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
731+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
732+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
733+    let lockEnd = (lockStart + lockDuration)
734+    let remainingDuration = max([(lockEnd - height), 0])
735+    let userAmountNew = (userAmount + pmtAmount)
736+    let lockDurationNew = (remainingDuration + deltaDuration)
737+    if ((0 > deltaDuration))
738+        then throw("duration is less then zero")
739+        else if ((minLockDuration > lockDurationNew))
740+            then throw(("lockDurationNew is less then minLockDuration=" + toString(minLockDuration)))
741+            else if ((lockDurationNew > maxLockDuration))
742+                then throw(("deltaDuration + existedLockDuration is greater then maxLockDuration=" + toString(maxLockDuration)))
743+                else {
744+                    let coeffX8 = fraction(lockDurationNew, MULT8, maxLockDuration)
745+                    let gWxAmountStart = fraction(userAmountNew, coeffX8, MULT8)
746+                    let updateRefActivity = invoke(mathContract, "updateReferralActivity", [toString(i.caller), gWxAmountStart], nil)
747+                    if ((updateRefActivity == updateRefActivity))
748+                        then {
749+                            let lockStartNew = height
750+                            let gWxParamsResultList = aal(invoke(mathContract, "calcGwxParamsREADONLY", [gWxAmountStart, lockStartNew, lockDurationNew], nil))
751+                            let k = ai(gWxParamsResultList[0])
752+                            let b = ai(gWxParamsResultList[1])
753+                            let period = toString(ai(gWxParamsResultList[2]))
754+                            let wxEmissionPerBlock = iof(emissionContract, keyEmissionRatePerBlockCurrent())
755+                            let emissionStart = iof(emissionContract, keyEmissionStartBlock())
756+                            let emissionEnd = iof(emissionContract, keyEmissionEndBlock())
757+                            let h = if ((height > emissionEnd))
758+                                then emissionEnd
759+                                else height
760+                            let dh = max([(h - emissionStart), 0])
761+                            let userBoostEmissionLastIntegralKEY = keyUserBoostEmissionLastINTEGRAL(userNumStr)
762+                            let userBoostEmissionLastIntegral = ioz(this, userBoostEmissionLastIntegralKEY)
763+                            let boostEmissionIntegral = (((wxEmissionPerBlock * dh) * 2) / 3)
764+                            let userBoostEmissionIntegral = (boostEmissionIntegral - userBoostEmissionLastIntegral)
765+                            if ((0 > userBoostEmissionIntegral))
766+                                then throw("wrong calculations")
767+                                else {
768+                                    let userMaxBoostIntegralKEY = keyUserMaxBoostINTEGRAL(userNumStr)
769+                                    let totalMaxBoostIntegralKEY = keyTotalMaxBoostINTEGRAL()
770+                                    let userMaxBoostInt = ioz(this, userMaxBoostIntegralKEY)
771+                                    let totalMaxBoostInt = ioz(this, totalMaxBoostIntegralKEY)
772+                                    let currUserGwx = calcCurrentGwxAmount(userAddressStr)
773+                                    let gwxDiff = (gWxAmountStart - currUserGwx)
774+                                    if ((0 > gwxDiff))
775+                                        then throw(("gwxDiff is less then 0: " + toString(gwxDiff)))
776+                                        else {
777+                                            let totalCachedGwxRaw = getTotalCachedGwx(false)
778+                                            let totalCachedGwxCorrected = getTotalCachedGwx(true)
779+                                            let userBoostAvalaibleToClaimTotalKEY = keyUserBoostAvalaibleToClaimTotal(userNumStr)
780+                                            let userBoostAvaliableToClaimTotal = ioz(this, userBoostAvalaibleToClaimTotalKEY)
781+                                            let userBoostAvaliableToClaimTotalNew = fraction(userBoostEmissionIntegral, currUserGwx, totalCachedGwxCorrected)
782+                                            let userMaxBoostIntNew = ((gWxAmountStart * lockDurationNew) / 2)
783+                                            let remainingUserMaxBoostInt = ((currUserGwx * remainingDuration) / 2)
784+                                            let userMaxBoostIntDiff = (userMaxBoostIntNew - remainingUserMaxBoostInt)
785+                                            (((LockParamsEntry(userAddressStr, userNumStr, userAmountNew, lockStartNew, lockDurationNew, k, b, period) ++ StatsEntry(pmtAmount, deltaDuration, 0, 0)) :+ HistoryEntry("lock", userAddressStr, pmtAmount, lockStart, lockDurationNew, k, b, i)) ++ [IntegerEntry(keyTotalCachedGwx(), (totalCachedGwxRaw + gwxDiff))])
786+                                            }
787+                                    }
788+                            }
789+                        else throw("Strict value is not equal to itself.")
790+                    }
791+    }
792+
793+
794+
795+@Callable(i)
796+func claimWxBoost (lpAssetIdStr,userAddressStr) = if ((stakingContract != i.caller))
797+    then throw("permissions denied")
798+    else {
799+        let $t03641836520 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, false)
800+        let userBoostAvailable = $t03641836520._1
801+        let dataState = $t03641836520._2
802+        let debug = $t03641836520._3
803+        $Tuple2(dataState, [userBoostAvailable])
804+        }
805+
806+
807+
808+@Callable(i)
809+func claimWxBoostREADONLY (lpAssetIdStr,userAddressStr) = {
810+    let $t03665936760 = internalClaimWxBoost(lpAssetIdStr, userAddressStr, true)
811+    let userBoostAvailable = $t03665936760._1
812+    let dataState = $t03665936760._2
813+    let debug = $t03665936760._3
814+    $Tuple2(nil, [userBoostAvailable, debug])
815+    }
816+
817+
818+
819+@Callable(i)
820+func unlock (userAddress) = {
821+    let userRecordArray = readLockParamsRecordOrFail(userAddress)
822+    let userNumStr = userRecordArray[IdxLockUserNum]
823+    let userAmount = parseIntValue(userRecordArray[IdxLockAmount])
824+    let lockStart = parseIntValue(userRecordArray[IdxLockStart])
825+    let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
826+    let lockEnd = (lockStart + lockDuration)
827+    let cfgArray = readConfigArrayOrFail()
828+    let assetId = fromBase58String(cfgArray[IdxCfgAssetId])
829+    if ((lockEnd >= height))
830+        then throw((("wait " + toString(lockEnd)) + " to unlock"))
831+        else if ((0 >= userAmount))
832+            then throw("nothing to unlock")
833+            else {
834+                let period = valueOrElse(getInteger(mathContract, keyNextPeriod()), 0)
835+                (((LockParamsEntry(userAddress, userNumStr, 0, lockStart, lockDuration, 0, 0, toString(period)) ++ StatsEntry(-(userAmount), 0, 0, -1)) :+ HistoryEntry("unlock", userAddress, userAmount, lockStart, lockDuration, 0, 0, i)) :+ ScriptTransfer(addressFromStringValue(userAddress), userAmount, assetId))
836+                }
837+    }
838+
839+
840+
841+@Callable(i)
842+func gwxUserInfoREADONLY (userAddress) = {
843+    let gwxAmount = calcCurrentGwxAmount(userAddress)
844+    $Tuple2(nil, [gwxAmount])
845+    }
846+
847+
848+
849+@Callable(i)
850+func userMaxDurationREADONLY (userAddressStr) = {
851+    let cfgArray = readConfigArrayOrFail()
852+    let maxLockDuration = parseIntValue(cfgArray[IdxCfgMaxLockDuration])
853+    let userRecordOption = getString(this, keyLockParamsRecord(userAddressStr))
854+    if ((userRecordOption == unit))
855+        then $Tuple2(nil, $Tuple2("lock", maxLockDuration))
856+        else {
857+            let userRecordArray = split(value(userRecordOption), SEP)
858+            let lockStart = parseIntValue(userRecordArray[IdxLockStart])
859+            let lockDuration = parseIntValue(userRecordArray[IdxLockDuration])
860+            let lockEnd = (lockStart + lockDuration)
861+            let remainingDuration = max([(lockEnd - height), 0])
862+            let maxDeltaDuration = (maxLockDuration - remainingDuration)
863+            $Tuple2(nil, $Tuple2("increaseLock", maxDeltaDuration))
864+            }
865+    }
866+
867+
868+
869+@Callable(i)
870+func getUserGwxAmountAtHeightREADONLY (userAddress,targetHeight) = {
871+    let gwxAmount = calcUserGwxAmountAtHeight(userAddress, targetHeight)
872+    $Tuple2(nil, gwxAmount)
873+    }
874+
875+
876+
877+@Callable(i)
878+func getTotalCachedGwxREADONLY () = $Tuple2(nil, getTotalCachedGwx(true))
879+
880+
881+
882+@Callable(i)
883+func onStakedVoteUpdate (lpAssetIdStr,userAddressStr,edge) = {
884+    let checkCaller = if ((i.caller == stakingContract))
885+        then true
886+        else mustManager(i)
887+    if ((checkCaller == checkCaller))
888+        then {
889+            let actions = refreshVoteStakedIntegral(lpAssetIdStr, userAddressStr, edge)
890+            $Tuple2(actions, unit)
891+            }
892+        else throw("Strict value is not equal to itself.")
893+    }
894+
895+
896+
897+@Callable(i)
898+func getVotingResultStakedREADONLY (lpAssetIdStr) = $Tuple2(nil, getVotingResultStaked(lpAssetIdStr))
899+
900+
901+
902+@Callable(i)
903+func setManager (pendingManagerPublicKey) = {
904+    let checkCaller = mustManager(i)
905+    if ((checkCaller == checkCaller))
906+        then {
907+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
908+            if ((checkManagerPublicKey == checkManagerPublicKey))
909+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
910+                else throw("Strict value is not equal to itself.")
911+            }
912+        else throw("Strict value is not equal to itself.")
913+    }
914+
915+
916+
917+@Callable(i)
918+func confirmManager () = {
919+    let pm = pendingManagerPublicKeyOrUnit()
920+    let hasPM = if (isDefined(pm))
921+        then true
922+        else throw("No pending manager")
923+    if ((hasPM == hasPM))
924+        then {
925+            let checkPM = if ((i.callerPublicKey == value(pm)))
926+                then true
927+                else throw("You are not pending manager")
928+            if ((checkPM == checkPM))
929+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
930+                else throw("Strict value is not equal to itself.")
931+            }
932+        else throw("Strict value is not equal to itself.")
933+    }
934+
935+
936+@Verifier(tx)
937+func verify () = {
938+    let targetPublicKey =     match managerPublicKeyOrUnit() {
939+        case pk: ByteVector => 
940+            pk
941+        case _: Unit => 
942+            tx.senderPublicKey
943+        case _ => 
944+            throw("Match error")
945+    }
946+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
947+    }
948+
github/deemru/w8io/169f3d6 
64.66 ms ◑