tx · 7P2i9ZbBdnRK5XZrecQEm1kYuoTuRfVxuEjZQJasgbJW

3Mq6RkeHgfiGMd6EGFc2gdwnEuGgLMouyzb:  -0.01400000 Waves

2021.10.26 22:38 [1763690] smart account 3Mq6RkeHgfiGMd6EGFc2gdwnEuGgLMouyzb > SELF 0.00000000 Waves

{ "type": 13, "id": "7P2i9ZbBdnRK5XZrecQEm1kYuoTuRfVxuEjZQJasgbJW", "fee": 1400000, "feeAssetId": null, "timestamp": 1635277176750, "version": 1, "sender": "3Mq6RkeHgfiGMd6EGFc2gdwnEuGgLMouyzb", "senderPublicKey": "9F73p3kLgMHDi6feVa4vj9ZMfMxo2D8gp4VuePAny8QA", "proofs": [ "21WaBCB8yanPCdZrLUHmg536fE4LY71HQvgiXzTpTZMK3wqc8i3z3pLzpboUmjJRK9NFJ4xVj5QwbZ2AXSSuW87D" ], "script": "base64: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", "chainId": 84, "height": 1763690, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: none Next: AmRfRCi4U8ySvrMMrTtGZDSL5ckzVs2SF95Bijwtjp3 Full:
OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let adminPubKey1 = base58'DXDY2itiEcYBtGkVLnkpHtDFyWQUkoLJz79uJ7ECbMrA'
5+
6+let adminPubKey2 = base58'E6Wa1SGoktYcjHjsKrvjMiqJY3SWmGKcD8Q5L8kxSPS7'
7+
8+let adminPubKey3 = base58'AZmWJtuy4GeVrMmJH4hfFBRApe1StvhJSk4jcbT6bArQ'
9+
10+let adminPubKeyStartStop = base58'EtVkT6ed8GtbUiVVEqdmEqsp2J4qbb3rre2HFgxeVYdg'
11+
12+let adminPubKeyWallet = base58'GTY8yEJ2S4heRompxyvbJoBN1Td5BM5Pp4JgVbj9tmCw'
13+
14+let keyActive = "active"
15+
16+let keyCause = "shutdown_cause"
17+
18+let keyLastInterest = "last_interest"
19+
20+let keyUserLastInterest = "_last_interest"
21+
22+let keyUserSWOPLocked = "_SWOP_amount"
23+
24+let keyUserGetBackHeight = "_getBackHeight"
25+
26+let keyTotalSWOPLocked = "total_SWOP_amount"
27+
28+let kUserTotalVoteSWOP = "_user_total_SWOP_vote"
29+
30+let keyUserVoteOptionAmount = "_SWOP_option_amount"
31+
32+let keyTotalVoteOptionAmount = "total_SWOP_option_amount"
33+
34+let keyUserSWOPClaimedAmount = "_SWOP_claimed_amount"
35+
36+let keyUserSWOPLastClaimedAmount = "_SWOP_last_claimed_amount"
37+
38+let keyVoteName = "vote_name"
39+
40+let keyOptionName = "_option_name"
41+
42+let keyVotingStartHeight = "_startHeight"
43+
44+let keyVoteDuration = "_vote_duration"
45+
46+let keyRewardPoolFractionCurrent = "_current_pool_fraction_reward"
47+
48+let keyRewardPoolFractionPrevious = "_previous_pool_fraction_reward"
49+
50+let keyHeightPoolFraction = "_pool_reward_update_height"
51+
52+let keyTotalRewardPerBlockCurrent = "total_reward_per_block_current"
53+
54+let keyTotalRewardPerBlockPrevious = "total_reward_per_block_previous"
55+
56+let keyRewardUpdateHeight = "reward_update_height"
57+
58+let keyRewardUpdateFirstPaginationHeight = "reward_update_height_first_pagination"
59+
60+let keyNoVotingForNewPool = "_vote_no"
61+
62+let keyYesVotingForNewPool = "_vote_yes"
63+
64+let keyAmountOfVotingForNewPool = "max_amount_voting"
65+
66+let keyStatusOfVotingForNewPool = "_status"
67+
68+let keyHeightOfPoolVotingForNewPool = "_finish_height"
69+
70+let activeVoteFirst = "voting_active_cell_1"
71+
72+let activeVoteSecond = "voting_active_cell_2"
73+
74+let activeVoteThird = "voting_active_cell_3"
75+
76+let keyTempCurSum = "sum_reward_current"
77+
78+let isActive = valueOrElse(getBoolean(this, keyActive), true)
79+
80+let farmingSWOPAddress = Address(base58'3P73HDkPqG15nLXevjCbmXtazHYTZbpPoPw')
81+
82+let votingLiteContract = Address(base58'3PQZWxShKGRgBN1qoJw6B4s9YWS9FneZTPg')
83+
84+let votingForNewPool = Address(base58'3PHgHf5C4WvHJucSHrjoVnMFsP1EhWffVLt')
85+
86+let keySWOPid = "SWOP_id"
87+
88+let SWOP = fromBase58String("Ccgesc9iWMSg1f8CqFP5nZwgF6xsGirReDhpvNp1JAWW")
89+
90+let scaleValue = 100000000
91+
92+let totalVoteShare = 10000000000
93+
94+let kStartHeight = "start_height"
95+
96+let kBasePeriod = "base_period"
97+
98+let kPeriodLength = "period_length"
99+
100+let kUserTotalStruc = "_user_total_struc"
101+
102+let basePeriod = valueOrErrorMessage(getInteger(votingLiteContract, kBasePeriod), "Empty kBasePeriod at voting contract")
103+
104+let startHeight = valueOrErrorMessage(getInteger(votingLiteContract, kStartHeight), "Empty kStartHeight at voting contract")
105+
106+let periodLength = valueOrErrorMessage(getInteger(votingLiteContract, kPeriodLength), "Empty kPeriodLength at voting contract")
107+
108+let firstActiveVote = valueOrElse(getString(votingForNewPool, activeVoteFirst), "")
109+
110+let secondActiveVote = valueOrElse(getString(votingForNewPool, activeVoteSecond), "")
111+
112+let thirdActiveVote = valueOrElse(getString(votingForNewPool, activeVoteThird), "")
113+
114+let currVotingPeriod = (basePeriod + ((height - startHeight) / periodLength))
115+
116+func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
117+
118+
119+func throwNotEnoughSWOP () = throw("Not enough SWOP: userSWOPLocked - userTotalVoteAmount < voteSWOPAmount")
120+
121+
122+func getLastInterestInfo () = {
123+ let lastInterest = valueOrElse(getInteger(this, keyLastInterest), 0)
124+ lastInterest
125+ }
126+
127+
128+func getUserSWOPLocked (user) = valueOrElse(getInteger(this, (toString(user) + keyUserSWOPLocked)), 0)
129+
130+
131+func getUserSWOPClaimedAmount (user) = valueOrElse(getInteger(this, (toString(user) + keyUserSWOPClaimedAmount)), 0)
132+
133+
134+func getUserTotalVoteAmount (user) = valueOrElse(getInteger(votingLiteContract, (toString(user) + kUserTotalVoteSWOP)), 0)
135+
136+
137+func getUserInterestInfo (user,lastInterest) = {
138+ let userSWOPAmount = getUserSWOPLocked(user)
139+ let userLastInterest = getInteger(this, (toString(user) + keyUserLastInterest))
140+ let userLastInterestValue = match userLastInterest {
141+ case userLastInterest: Int =>
142+ userLastInterest
143+ case _ =>
144+ lastInterest
145+ }
146+ $Tuple2(userLastInterestValue, userSWOPAmount)
147+ }
148+
149+
150+func getUserTotalVoteAmountForOnePool (pool,user) = {
151+ let voting = valueOrElse(getInteger(votingForNewPool, pool), -1)
152+ let heightOfVoting = valueOrElse(getInteger(votingForNewPool, (toString(voting) + keyHeightOfPoolVotingForNewPool)), 0)
153+ let statusOfVoting = valueOrElse(getBoolean(votingForNewPool, (toString(voting) + keyStatusOfVotingForNewPool)), true)
154+ let currentHeight = height
155+ if ((0 > voting))
156+ then 0
157+ else if (!(statusOfVoting))
158+ then 0
159+ else if ((heightOfVoting > currentHeight))
160+ then (valueOrElse(getInteger(votingForNewPool, (((toString(user) + "_") + toString(voting)) + keyYesVotingForNewPool)), 0) + valueOrElse(getInteger(votingForNewPool, (((toString(user) + "_") + toString(voting)) + keyNoVotingForNewPool)), 0))
161+ else 0
162+ }
163+
164+
165+func getUserTotalVoteForNewPoolAmount (user) = {
166+ let listOfVoting = [getUserTotalVoteAmountForOnePool(firstActiveVote, user), getUserTotalVoteAmountForOnePool(secondActiveVote, user), getUserTotalVoteAmountForOnePool(thirdActiveVote, user)]
167+ max(listOfVoting)
168+ }
169+
170+
171+func getTotalSWOPLocked () = valueOrElse(getInteger(this, keyTotalSWOPLocked), 0)
172+
173+
174+func getUserVoteInfo (user) = {
175+ let $t059936544 = if (isDefined(getString(votingLiteContract, (toString(user) + kUserTotalStruc))))
176+ then {
177+ let data = split(valueOrErrorMessage(getString(votingLiteContract, (toString(user) + kUserTotalStruc)), "Empty kUserTotalStruc"), "_")
178+ $Tuple3(parseIntValue(data[0]), parseIntValue(data[1]), parseIntValue(data[2]))
179+ }
180+ else {
181+ let uPoolTotalSWOP = valueOrElse(getInteger(votingLiteContract, (toString(user) + kUserTotalVoteSWOP)), 0)
182+ $Tuple3(uPoolTotalSWOP, 0, currVotingPeriod)
183+ }
184+ let userTotalVoteSWOP = $t059936544._1
185+ let userUnvoted = $t059936544._2
186+ let userUnvotedPeriod = $t059936544._3
187+ let userUnvotedActual = if ((userUnvotedPeriod == currVotingPeriod))
188+ then userUnvoted
189+ else 0
190+ $Tuple2(userTotalVoteSWOP, userUnvotedActual)
191+ }
192+
193+
194+func getUserVoteOptionAmount (user) = valueOrElse(getInteger(this, (toString(user) + keyUserVoteOptionAmount)), 0)
195+
196+
197+func getVotingStartHeight (voteName) = valueOrElse(getInteger(this, (voteName + keyVotingStartHeight)), 0)
198+
199+
200+func getPoolUpdateHeight (pool) = valueOrElse(getInteger(this, (pool + keyHeightPoolFraction)), 0)
201+
202+
203+func isDefinePoolUpdateHeight (pool) = isDefined(getInteger(this, (pool + keyHeightPoolFraction)))
204+
205+
206+func getCurPoolWeight (pool) = valueOrElse(getInteger(this, (pool + keyRewardPoolFractionCurrent)), 0)
207+
208+
209+func getPrevPoolWeight (pool) = valueOrElse(getInteger(this, (pool + keyRewardPoolFractionPrevious)), 0)
210+
211+
212+func getVoteOptionAmount (user,voteName,option) = {
213+ let userVoteOptionAmount = getInteger(this, (((voteName + option) + toString(user)) + keyUserVoteOptionAmount))
214+ let uvoa = match userVoteOptionAmount {
215+ case uvoa: Int =>
216+ uvoa
217+ case uvoa: Unit =>
218+ 0
219+ case _ =>
220+ throw("Match error")
221+ }
222+ valueOrErrorMessage(uvoa, (((("No data on the key: " + voteName) + option) + toString(user)) + keyUserVoteOptionAmount))
223+ }
224+
225+
226+func getVoteDuration (voteName) = valueOrErrorMessage(getInteger(this, (voteName + keyVoteDuration)), (("No data on the key: " + voteName) + keyVoteDuration))
227+
228+
229+func getTotalVoteOptionAmount (voteName,option) = {
230+ let totalVoteOptionAmount = getInteger(this, ((voteName + option) + keyTotalVoteOptionAmount))
231+ let tvoa = match totalVoteOptionAmount {
232+ case tvoa: Int =>
233+ tvoa
234+ case tvoa: Unit =>
235+ 0
236+ case _ =>
237+ throw("Match error")
238+ }
239+ tvoa
240+ }
241+
242+
243+func getUserGetBackAmount (voteName,option,user,getBackSWOPHeight) = {
244+ let key = ((((((voteName + "_") + option) + "_") + toString(user)) + "_") + toString(getBackSWOPHeight))
245+ valueOrErrorMessage(getInteger(this, key), ("No data on the key: " + key))
246+ }
247+
248+
249+func claimCalc (caller) = {
250+ let lastInterest = getLastInterestInfo()
251+ let $t089489028 = getUserInterestInfo(caller, lastInterest)
252+ let userLastInterest = $t089489028._1
253+ let userSWOPLocked = $t089489028._2
254+ let claimAmount = fraction(userSWOPLocked, (lastInterest - userLastInterest), scaleValue)
255+ let userNewInterest = lastInterest
256+ $Tuple2(userNewInterest, claimAmount)
257+ }
258+
259+
260+@Callable(i)
261+func airDrop () = if (!(isActive))
262+ then throw("DApp is inactive at this moment")
263+ else {
264+ let $t092939368 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
265+ let pmtAmount = $t092939368._1
266+ let pmtAssetId = $t092939368._2
267+ if ((pmtAssetId != SWOP))
268+ then throw("Incorrect pmtAssetId")
269+ else {
270+ let totalSWOPLocked = getTotalSWOPLocked()
271+ let lastInterest = getLastInterestInfo()
272+ let interestNew = (lastInterest + fraction(pmtAmount, scaleValue, totalSWOPLocked))
273+[IntegerEntry(keyLastInterest, interestNew)]
274+ }
275+ }
276+
277+
278+
279+@Callable(i)
280+func lockSWOP () = if (!(isActive))
281+ then throw("DApp is inactive at this moment")
282+ else {
283+ let $t098069881 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
284+ let pmtAmount = $t098069881._1
285+ let pmtAssetId = $t098069881._2
286+ if ((pmtAssetId != SWOP))
287+ then throw("Incorrect pmtAssetId")
288+ else {
289+ let lastInterest = getLastInterestInfo()
290+ let $t0999710079 = getUserInterestInfo(i.caller, lastInterest)
291+ let userLastInterest = $t0999710079._1
292+ let userSWOPLocked = $t0999710079._2
293+ let claimAmount = fraction(userSWOPLocked, (lastInterest - userLastInterest), scaleValue)
294+ let userSWOPLockedNew = ((userSWOPLocked + pmtAmount) + claimAmount)
295+ let userNewInterest = lastInterest
296+ let totalSWOPLocked = getTotalSWOPLocked()
297+ let totalSWOPLockedNew = ((totalSWOPLocked + pmtAmount) + claimAmount)
298+ let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
299+ let userClaimedAmountNew = (userClaimedAmount + claimAmount)
300+[IntegerEntry((toString(i.caller) + keyUserLastInterest), userNewInterest), IntegerEntry((toString(i.caller) + keyUserSWOPLocked), userSWOPLockedNew), IntegerEntry(keyTotalSWOPLocked, totalSWOPLockedNew), IntegerEntry((toString(i.caller) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((toString(i.caller) + keyUserSWOPLastClaimedAmount), claimAmount)]
301+ }
302+ }
303+
304+
305+
306+@Callable(i)
307+func withdrawSWOP (withdrawAmount) = if (!(isActive))
308+ then throw("DApp is inactive at this moment")
309+ else if ((0 >= withdrawAmount))
310+ then throw("withdrawAmount <= 0")
311+ else {
312+ let totalSWOPLocked = getTotalSWOPLocked()
313+ let userSWOPLocked = getUserSWOPLocked(i.caller)
314+ let $t01122911284 = claimCalc(i.caller)
315+ let userNewInterest = $t01122911284._1
316+ let claimAmount = $t01122911284._2
317+ let $t01128911378 = $Tuple2(0, 0)
318+ let userVoteAmount = $t01128911378._1
319+ let userUnvoteAmount = $t01128911378._2
320+ let userVoteAmountForNewPool = getUserTotalVoteForNewPoolAmount(i.caller)
321+ if (if (if ((0 > userUnvoteAmount))
322+ then true
323+ else (0 > userVoteAmount))
324+ then true
325+ else (0 > userVoteAmountForNewPool))
326+ then throw("userUnvoteAmount < 0 || userVoteAmount < 0 || userVoteAmountForNewPool < 0")
327+ else {
328+ let availableToUnstake = (userSWOPLocked - max([userVoteAmountForNewPool, (userVoteAmount + userUnvoteAmount)]))
329+ if ((withdrawAmount > availableToUnstake))
330+ then throw("withdrawAmount > availableToUnstake")
331+ else {
332+ let totalSWOPLockedNew = ((totalSWOPLocked + claimAmount) - withdrawAmount)
333+ let userSWOPamountNew = ((userSWOPLocked + claimAmount) - withdrawAmount)
334+ let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
335+ let userClaimedAmountNew = (userClaimedAmount + claimAmount)
336+[IntegerEntry((toString(i.caller) + keyUserLastInterest), userNewInterest), IntegerEntry((toString(i.caller) + keyUserSWOPLocked), userSWOPamountNew), IntegerEntry(keyTotalSWOPLocked, totalSWOPLockedNew), ScriptTransfer(i.caller, withdrawAmount, SWOP), IntegerEntry((toString(i.caller) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((toString(i.caller) + keyUserSWOPLastClaimedAmount), claimAmount)]
337+ }
338+ }
339+ }
340+
341+
342+
343+@Callable(i)
344+func claimAndWithdrawSWOP () = if (!(isActive))
345+ then throw("DApp is inactive at this moment")
346+ else {
347+ let lastInterest = getLastInterestInfo()
348+ let $t01275812813 = claimCalc(i.caller)
349+ let userNewInterest = $t01275812813._1
350+ let claimAmount = $t01275812813._2
351+ let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
352+ let userClaimedAmountNew = (userClaimedAmount + claimAmount)
353+ if ((claimAmount == 0))
354+ then throw("You have 0 available SWOP")
355+ else [IntegerEntry((toString(i.caller) + keyUserLastInterest), userNewInterest), IntegerEntry((toString(i.caller) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((toString(i.caller) + keyUserSWOPLastClaimedAmount), claimAmount), ScriptTransfer(i.caller, claimAmount, SWOP)]
356+ }
357+
358+
359+
360+@Callable(i)
361+func claimAndStakeSWOP () = if (!(isActive))
362+ then throw("DApp is inactive at this moment")
363+ else {
364+ let totalSWOPLocked = getTotalSWOPLocked()
365+ let userSWOPLocked = getUserSWOPLocked(i.caller)
366+ let lastInterest = getLastInterestInfo()
367+ let $t01359213647 = claimCalc(i.caller)
368+ let userNewInterest = $t01359213647._1
369+ let claimAmount = $t01359213647._2
370+ let userSWOPLockedNew = (userSWOPLocked + claimAmount)
371+ let totalSWOPLockedNew = (totalSWOPLocked + claimAmount)
372+ let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
373+ let userClaimedAmountNew = (userClaimedAmount + claimAmount)
374+ if ((claimAmount == 0))
375+ then throw("You have 0 available SWOP")
376+ else [IntegerEntry((toString(i.caller) + keyUserLastInterest), userNewInterest), IntegerEntry(keyTotalSWOPLocked, totalSWOPLockedNew), IntegerEntry((toString(i.caller) + keyUserSWOPLocked), userSWOPLockedNew), IntegerEntry((toString(i.caller) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((toString(i.caller) + keyUserSWOPLastClaimedAmount), claimAmount)]
377+ }
378+
379+
380+
381+@Callable(i)
382+func updateWeights (currentPools,currentRewards,rewardUpdateHeight,pagination) = if (!(isActive))
383+ then throw("DApp is inactive at this moment")
384+ else {
385+ let amountPools = 10
386+ let totalRewardUpdateHeight = valueOrElse(getInteger(this, keyRewardUpdateHeight), 0)
387+ if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop, adminPubKeyWallet], i.callerPublicKey)))
388+ then throw("Only admin can call this function")
389+ else if ((size(currentPools) > amountPools))
390+ then throw(("Max amount of pool is " + toString(amountPools)))
391+ else if ((totalRewardUpdateHeight >= rewardUpdateHeight))
392+ then throw("rewardUpdateHeight <= totalRewardUpdateHeight")
393+ else if ((height >= rewardUpdateHeight))
394+ then throw("height >= rewardUpdateHeight")
395+ else if ((0 >= rewardUpdateHeight))
396+ then throw("0 >= rewardUpdateHeight ")
397+ else {
398+ func sum (a,b) = (a + b)
399+
400+ func changePreviousRewardEntry (accumulated,pool) = {
401+ let poolRewardUpdateHeight = getPoolUpdateHeight(pool)
402+ if (if (!(isDefinePoolUpdateHeight(pool)))
403+ then true
404+ else if ((rewardUpdateHeight != poolRewardUpdateHeight))
405+ then (poolRewardUpdateHeight == totalRewardUpdateHeight)
406+ else false)
407+ then {
408+ let poolReward = getCurPoolWeight(pool)
409+IntegerEntry((pool + keyRewardPoolFractionPrevious), poolReward) :: accumulated
410+ }
411+ else {
412+ let poolReward = getPrevPoolWeight(pool)
413+IntegerEntry((pool + keyRewardPoolFractionPrevious), poolReward) :: accumulated
414+ }
415+ }
416+
417+ func changeCurrentRewardEntry (accumulated,pool) = {
418+ let poolIndex = value(indexOf(currentPools, pool))
419+ let poolReward = currentRewards[poolIndex]
420+ if ((0 > poolReward))
421+ then throw("PoolReward < 0")
422+ else IntegerEntry((pool + keyRewardPoolFractionCurrent), poolReward) :: accumulated
423+ }
424+
425+ func changeHeightEntry (accumulated,pool) = {
426+ let poolHeight = rewardUpdateHeight
427+IntegerEntry((pool + keyHeightPoolFraction), poolHeight) :: accumulated
428+ }
429+
430+ func getSumReward (curTempSum,pagination) = if ((pagination == 0))
431+ then if ((curTempSum > totalVoteShare))
432+ then throw(((("sumRewardPrevious > totalVoteShare or sumRewardCurrent > totalVoteShare - " + toString(pagination)) + " ") + toString(curTempSum)))
433+ else $Tuple2([IntegerEntry(keyTempCurSum, curTempSum)], [IntegerEntry(keyRewardUpdateFirstPaginationHeight, rewardUpdateHeight)])
434+ else if ((pagination == 1))
435+ then {
436+ let curTempSumFromKey = valueOrElse(getInteger(this, keyTempCurSum), 0)
437+ let rewardUpdateHeightFirstPaginationEntry = valueOrElse(getInteger(this, keyRewardUpdateFirstPaginationHeight), 0)
438+ if (((curTempSum + curTempSumFromKey) > totalVoteShare))
439+ then throw(((("sumRewardPrevious > totalVoteShare or sumRewardCurrent > totalVoteShare - " + toString(pagination)) + " ") + toString((curTempSum + curTempSumFromKey))))
440+ else if ((rewardUpdateHeightFirstPaginationEntry != rewardUpdateHeight))
441+ then throw("current rewardUpdateHeight != rewardUpdateHeightFirstPaginationEntry")
442+ else $Tuple2([IntegerEntry(keyTempCurSum, (curTempSum + curTempSumFromKey))], nil)
443+ }
444+ else if ((pagination == 2))
445+ then {
446+ let curSum = (valueOrElse(getInteger(this, keyTempCurSum), 0) + curTempSum)
447+ let rewardUpdateHeightFirstPaginationEntry = valueOrElse(getInteger(this, keyRewardUpdateFirstPaginationHeight), 0)
448+ if ((curSum != totalVoteShare))
449+ then throw("sumRewardPrevious != totalVoteShare or sumRewardCurrent != totalVoteShare")
450+ else if ((rewardUpdateHeightFirstPaginationEntry != rewardUpdateHeight))
451+ then throw("current rewardUpdateHeight != rewardUpdateHeightFirstPaginationEntry")
452+ else $Tuple2([IntegerEntry(keyTempCurSum, curSum)], nil)
453+ }
454+ else throw("Incorrect pagination")
455+
456+ let previousRewardEntryNew = {
457+ let $l = currentPools
458+ let $s = size($l)
459+ let $acc0 = nil
460+ func 1 ($a,$i) = if (($i >= $s))
461+ then $a
462+ else changePreviousRewardEntry($a, $l[$i])
463+
464+ func 2 ($a,$i) = if (($i >= $s))
465+ then $a
466+ else throw("List size exceeds 10")
467+
468+ 2(1(1(1(1(1(1(1(1(1(1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
469+ }
470+ let currentRewardEntryNew = {
471+ let $l = currentPools
472+ let $s = size($l)
473+ let $acc0 = nil
474+ func 1 ($a,$i) = if (($i >= $s))
475+ then $a
476+ else changeCurrentRewardEntry($a, $l[$i])
477+
478+ func 2 ($a,$i) = if (($i >= $s))
479+ then $a
480+ else throw("List size exceeds 10")
481+
482+ 2(1(1(1(1(1(1(1(1(1(1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
483+ }
484+ let heightEntryNewCur = {
485+ let $l = currentPools
486+ let $s = size($l)
487+ let $acc0 = nil
488+ func 1 ($a,$i) = if (($i >= $s))
489+ then $a
490+ else changeHeightEntry($a, $l[$i])
491+
492+ func 2 ($a,$i) = if (($i >= $s))
493+ then $a
494+ else throw("List size exceeds 10")
495+
496+ 2(1(1(1(1(1(1(1(1(1(1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
497+ }
498+ let sumRewardCurrentTemp = {
499+ let $l = currentRewards
500+ let $s = size($l)
501+ let $acc0 = 0
502+ func 1 ($a,$i) = if (($i >= $s))
503+ then $a
504+ else sum($a, $l[$i])
505+
506+ func 2 ($a,$i) = if (($i >= $s))
507+ then $a
508+ else throw("List size exceeds 10")
509+
510+ 2(1(1(1(1(1(1(1(1(1(1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
511+ }
512+ let $t01879118902 = getSumReward(sumRewardCurrentTemp, pagination)
513+ let sumRewardCurrent = $t01879118902._1
514+ let rewardUpdateHeightFirstPaginationEntry = $t01879118902._2
515+ let rewardUpdateHeightEntry = if ((pagination == 2))
516+ then [IntegerEntry(keyRewardUpdateHeight, rewardUpdateHeight)]
517+ else nil
518+ if ((height > rewardUpdateHeight))
519+ then throw("rewardUpdateHeight < height")
520+ else (((((previousRewardEntryNew ++ currentRewardEntryNew) ++ heightEntryNewCur) ++ sumRewardCurrent) ++ rewardUpdateHeightEntry) ++ rewardUpdateHeightFirstPaginationEntry)
521+ }
522+ }
523+
524+
525+
526+@Callable(i)
527+func shutdown () = if (!(isActive))
528+ then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, keyCause), "the cause wasn't specified")))
529+ else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
530+ then throw("Only admin can call this function")
531+ else suspend("Paused by admin")
532+
533+
534+
535+@Callable(i)
536+func activate () = if (isActive)
537+ then throw("DApp is already active")
538+ else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
539+ then throw("Only admin can call this function")
540+ else [BooleanEntry(keyActive, true), DeleteEntry(keyCause)]
541+
542+

github/deemru/w8io/c3f4982 
33.76 ms