tx · BwZV2GJFMC4zUXeX5uQvaGYH4yqKKRA6x9LkENbjo8Sx

3MyLDDChFqiZMV8At2rmymVkQzrrPbSE7EK:  -0.01000000 Waves

2022.03.16 16:09 [1966547] smart account 3MyLDDChFqiZMV8At2rmymVkQzrrPbSE7EK > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BwZV2GJFMC4zUXeX5uQvaGYH4yqKKRA6x9LkENbjo8Sx",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1647436238622,
    "version": 2,
    "chainId": 84,
    "sender": "3MyLDDChFqiZMV8At2rmymVkQzrrPbSE7EK",
    "senderPublicKey": "GFmKZ2naZFRoCvNbwKAQVGmLb1uBeWGDgFabdGBuZiuy",
    "proofs": [
        "2DvjrRaeB31DZXABd9FW3KQqbCGCkAo9aE8piDgWUu6U9pQfFzyU6qjKgyb8K5JckxrnqNkfvX24HqsjF97Rptfb"
    ],
    "script": "base64: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",
    "height": 1966547,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 5dV9FWiXPZGpMuk7omzA8p7eNmEWdFN1JX85JWAyXnqU
Next: 9Vi6dShqRBrogqSX8vt3DTNWaJHRG6yctKmES5BLEdaU

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4+let adminPubKey1 = base58'GFmKZ2naZFRoCvNbwKAQVGmLb1uBeWGDgFabdGBuZiuy'
5+
6+let adminPubKey2 = base58'GmJXRyhRA79g8yUGgKBAVdnFfQFDMjQG98b1MmLDh5kk'
7+
8+let adminPubKey3 = base58'CFhbV6h41hVjbGHudGtS3fYUv7QAKRxFQzKNtx4B5PqP'
9+
10+let adminPubKeyStartStop = base58'GFmKZ2naZFRoCvNbwKAQVGmLb1uBeWGDgFabdGBuZiuy'
11+
12+let adminPubKeyWallet = base58'4FKEh3tmKwAdBv7cr6iMhVN9wDx7FiM6u62eKY3M4uBg'
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 keyLaunchpadBoughtTickets = "_bought_tickets"
79+
80+let keyLaunchpadSwopPerTickets = "_swop_per_ticket"
81+
82+let keyLaunchpadActiveId = "launchpad_active_id"
83+
84+let keyLaunchpadDuration = "_duration"
85+
86+let keyLaunchpadStartHeight = "_start_height"
87+
88+let keyLauchpadFreezSwopDuration = "_freeze_swop_duration"
89+
90+let isActive = valueOrElse(getBoolean(this, keyActive), true)
91+
92+let farmingSWOPAddress = Address(base58'3P73HDkPqG15nLXevjCbmXtazHYTZbpPoPw')
93+
94+let votingLiteContract = Address(base58'3PQZWxShKGRgBN1qoJw6B4s9YWS9FneZTPg')
95+
96+let votingForNewPool = Address(base58'3PHgHf5C4WvHJucSHrjoVnMFsP1EhWffVLt')
97+
98+let launchpad = Address(base58'3P6YGPihPiF81VELikoV1myU55iwTvmcQaQ')
99+
100+let keySWOPid = "SWOP_id"
101+
102+let SWOP = fromBase58String(getStringValue(farmingSWOPAddress, keySWOPid))
103+
104+let scaleValue = 100000000
105+
106+let totalVoteShare = 10000000000
107+
108+let kStartHeight = "start_height"
109+
110+let kBasePeriod = "base_period"
111+
112+let kPeriodLength = "period_length"
113+
114+let kUserTotalStruc = "_user_total_struc"
115+
116+let basePeriod = valueOrErrorMessage(getInteger(votingLiteContract, kBasePeriod), "Empty kBasePeriod at voting contract")
117+
118+let startHeight = valueOrErrorMessage(getInteger(votingLiteContract, kStartHeight), "Empty kStartHeight at voting contract")
119+
120+let periodLength = valueOrErrorMessage(getInteger(votingLiteContract, kPeriodLength), "Empty kPeriodLength at voting contract")
121+
122+let firstActiveVote = valueOrElse(getString(votingForNewPool, activeVoteFirst), "")
123+
124+let secondActiveVote = valueOrElse(getString(votingForNewPool, activeVoteSecond), "")
125+
126+let thirdActiveVote = valueOrElse(getString(votingForNewPool, activeVoteThird), "")
127+
128+let currVotingPeriod = (basePeriod + ((height - startHeight) / periodLength))
129+
130+func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
4131 
5132 
133+func throwNotEnoughSWOP () = throw("Not enough SWOP: userSWOPLocked - userTotalVoteAmount < voteSWOPAmount")
134+
135+
136+func getLastInterestInfo () = {
137+    let lastInterest = valueOrElse(getInteger(this, keyLastInterest), 0)
138+    lastInterest
139+    }
140+
141+
142+func getUserSWOPLocked (user) = valueOrElse(getInteger(this, (toString(user) + keyUserSWOPLocked)), 0)
143+
144+
145+func getUserSWOPClaimedAmount (user) = valueOrElse(getInteger(this, (toString(user) + keyUserSWOPClaimedAmount)), 0)
146+
147+
148+func getUserTotalVoteAmount (user) = valueOrElse(getInteger(votingLiteContract, (toString(user) + kUserTotalVoteSWOP)), 0)
149+
150+
151+func getUserInterestInfo (user,lastInterest) = {
152+    let userSWOPAmount = getUserSWOPLocked(user)
153+    let userLastInterest = getInteger(this, (toString(user) + keyUserLastInterest))
154+    let userLastInterestValue =     match userLastInterest {
155+        case userLastInterest: Int => 
156+            userLastInterest
157+        case _ => 
158+            lastInterest
159+    }
160+    $Tuple2(userLastInterestValue, userSWOPAmount)
161+    }
162+
163+
164+func getUserTotalVoteAmountForOnePool (pool,user) = {
165+    let voting = valueOrElse(getInteger(votingForNewPool, pool), -1)
166+    let heightOfVoting = valueOrElse(getInteger(votingForNewPool, (toString(voting) + keyHeightOfPoolVotingForNewPool)), 0)
167+    let statusOfVoting = valueOrElse(getBoolean(votingForNewPool, (toString(voting) + keyStatusOfVotingForNewPool)), true)
168+    let currentHeight = height
169+    if ((0 > voting))
170+        then 0
171+        else if (!(statusOfVoting))
172+            then 0
173+            else if ((heightOfVoting > currentHeight))
174+                then (valueOrElse(getInteger(votingForNewPool, (((toString(user) + "_") + toString(voting)) + keyYesVotingForNewPool)), 0) + valueOrElse(getInteger(votingForNewPool, (((toString(user) + "_") + toString(voting)) + keyNoVotingForNewPool)), 0))
175+                else 0
176+    }
177+
178+
179+func getUserTotalVoteForNewPoolAmount (user) = {
180+    let listOfVoting = [getUserTotalVoteAmountForOnePool(firstActiveVote, user), getUserTotalVoteAmountForOnePool(secondActiveVote, user), getUserTotalVoteAmountForOnePool(thirdActiveVote, user)]
181+    max(listOfVoting)
182+    }
183+
184+
185+func getUserBlockedInLauchpad (user) = {
186+    let lauchpadId = toString(valueOrElse(getInteger(launchpad, keyLaunchpadActiveId), 0))
187+    if ((lauchpadId == "0"))
188+        then 0
189+        else {
190+            let lStartHeight = valueOrElse(getInteger(launchpad, (lauchpadId + keyLaunchpadStartHeight)), 0)
191+            let lDuration = valueOrElse(getInteger(launchpad, (lauchpadId + keyLaunchpadDuration)), 0)
192+            let lFreezeSwopDuration = valueOrElse(getInteger(launchpad, (lauchpadId + keyLauchpadFreezSwopDuration)), 0)
193+            let blockEndHeight = ((lStartHeight + lDuration) + lFreezeSwopDuration)
194+            if ((height > blockEndHeight))
195+                then 0
196+                else {
197+                    let boughtTickets = valueOrElse(getInteger(launchpad, (((toString(user) + "_") + lauchpadId) + keyLaunchpadBoughtTickets)), 0)
198+                    let swopPerTicket = valueOrElse(getInteger(launchpad, (lauchpadId + keyLaunchpadSwopPerTickets)), 0)
199+                    (boughtTickets * swopPerTicket)
200+                    }
201+            }
202+    }
203+
204+
205+func getTotalSWOPLocked () = valueOrElse(getInteger(this, keyTotalSWOPLocked), 0)
206+
207+
208+func getUserVoteInfo (user) = {
209+    let $t072067757 = if (isDefined(getString(votingLiteContract, (toString(user) + kUserTotalStruc))))
210+        then {
211+            let data = split(valueOrErrorMessage(getString(votingLiteContract, (toString(user) + kUserTotalStruc)), "Empty kUserTotalStruc"), "_")
212+            $Tuple3(parseIntValue(data[0]), parseIntValue(data[1]), parseIntValue(data[2]))
213+            }
214+        else {
215+            let uPoolTotalSWOP = valueOrElse(getInteger(votingLiteContract, (toString(user) + kUserTotalVoteSWOP)), 0)
216+            $Tuple3(uPoolTotalSWOP, 0, currVotingPeriod)
217+            }
218+    let userTotalVoteSWOP = $t072067757._1
219+    let userUnvoted = $t072067757._2
220+    let userUnvotedPeriod = $t072067757._3
221+    let userUnvotedActual = if ((userUnvotedPeriod == currVotingPeriod))
222+        then userUnvoted
223+        else 0
224+    $Tuple2(userTotalVoteSWOP, userUnvotedActual)
225+    }
226+
227+
228+func getUserVoteOptionAmount (user) = valueOrElse(getInteger(this, (toString(user) + keyUserVoteOptionAmount)), 0)
229+
230+
231+func getVotingStartHeight (voteName) = valueOrElse(getInteger(this, (voteName + keyVotingStartHeight)), 0)
232+
233+
234+func getPoolUpdateHeight (pool) = valueOrElse(getInteger(this, (pool + keyHeightPoolFraction)), 0)
235+
236+
237+func isDefinePoolUpdateHeight (pool) = isDefined(getInteger(this, (pool + keyHeightPoolFraction)))
238+
239+
240+func getCurPoolWeight (pool) = valueOrElse(getInteger(this, (pool + keyRewardPoolFractionCurrent)), 0)
241+
242+
243+func getPrevPoolWeight (pool) = valueOrElse(getInteger(this, (pool + keyRewardPoolFractionPrevious)), 0)
244+
245+
246+func getVoteOptionAmount (user,voteName,option) = {
247+    let userVoteOptionAmount = getInteger(this, (((voteName + option) + toString(user)) + keyUserVoteOptionAmount))
248+    let uvoa =     match userVoteOptionAmount {
249+        case uvoa: Int => 
250+            uvoa
251+        case uvoa: Unit => 
252+            0
253+        case _ => 
254+            throw("Match error")
255+    }
256+    valueOrErrorMessage(uvoa, (((("No data on the key: " + voteName) + option) + toString(user)) + keyUserVoteOptionAmount))
257+    }
258+
259+
260+func getVoteDuration (voteName) = valueOrErrorMessage(getInteger(this, (voteName + keyVoteDuration)), (("No data on the key: " + voteName) + keyVoteDuration))
261+
262+
263+func getTotalVoteOptionAmount (voteName,option) = {
264+    let totalVoteOptionAmount = getInteger(this, ((voteName + option) + keyTotalVoteOptionAmount))
265+    let tvoa =     match totalVoteOptionAmount {
266+        case tvoa: Int => 
267+            tvoa
268+        case tvoa: Unit => 
269+            0
270+        case _ => 
271+            throw("Match error")
272+    }
273+    tvoa
274+    }
275+
276+
277+func getUserGetBackAmount (voteName,option,user,getBackSWOPHeight) = {
278+    let key = ((((((voteName + "_") + option) + "_") + toString(user)) + "_") + toString(getBackSWOPHeight))
279+    valueOrErrorMessage(getInteger(this, key), ("No data on the key: " + key))
280+    }
281+
282+
283+func claimCalc (caller) = {
284+    let lastInterest = getLastInterestInfo()
285+    let $t01016110241 = getUserInterestInfo(caller, lastInterest)
286+    let userLastInterest = $t01016110241._1
287+    let userSWOPLocked = $t01016110241._2
288+    let claimAmount = fraction(userSWOPLocked, (lastInterest - userLastInterest), scaleValue)
289+    let userNewInterest = lastInterest
290+    $Tuple2(userNewInterest, claimAmount)
291+    }
292+
293+
294+@Callable(i)
295+func airDrop () = if (!(isActive))
296+    then throw("DApp is inactive at this moment")
297+    else {
298+        let $t01050610581 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
299+        let pmtAmount = $t01050610581._1
300+        let pmtAssetId = $t01050610581._2
301+        if ((pmtAssetId != SWOP))
302+            then throw("Incorrect pmtAssetId")
303+            else {
304+                let totalSWOPLocked = getTotalSWOPLocked()
305+                let lastInterest = getLastInterestInfo()
306+                let interestNew = (lastInterest + fraction(pmtAmount, scaleValue, totalSWOPLocked))
307+[IntegerEntry(keyLastInterest, interestNew)]
308+                }
309+        }
310+
311+
312+
313+@Callable(i)
314+func lockSWOP () = if (!(isActive))
315+    then throw("DApp is inactive at this moment")
316+    else {
317+        let $t01101911094 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
318+        let pmtAmount = $t01101911094._1
319+        let pmtAssetId = $t01101911094._2
320+        if ((pmtAssetId != SWOP))
321+            then throw("Incorrect pmtAssetId")
322+            else {
323+                let lastInterest = getLastInterestInfo()
324+                let $t01121011292 = getUserInterestInfo(i.caller, lastInterest)
325+                let userLastInterest = $t01121011292._1
326+                let userSWOPLocked = $t01121011292._2
327+                let claimAmount = fraction(userSWOPLocked, (lastInterest - userLastInterest), scaleValue)
328+                let userSWOPLockedNew = ((userSWOPLocked + pmtAmount) + claimAmount)
329+                let userNewInterest = lastInterest
330+                let totalSWOPLocked = getTotalSWOPLocked()
331+                let totalSWOPLockedNew = ((totalSWOPLocked + pmtAmount) + claimAmount)
332+                let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
333+                let userClaimedAmountNew = (userClaimedAmount + claimAmount)
334+[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)]
335+                }
336+        }
337+
338+
339+
340+@Callable(i)
341+func withdrawSWOP (withdrawAmount) = if (!(isActive))
342+    then throw("DApp is inactive at this moment")
343+    else if ((0 >= withdrawAmount))
344+        then throw("withdrawAmount <= 0")
345+        else {
346+            let totalSWOPLocked = getTotalSWOPLocked()
347+            let userSWOPLocked = getUserSWOPLocked(i.caller)
348+            let $t01244212497 = claimCalc(i.caller)
349+            let userNewInterest = $t01244212497._1
350+            let claimAmount = $t01244212497._2
351+            let $t01250212567 = getUserVoteInfo(i.caller)
352+            let userVoteAmount = $t01250212567._1
353+            let userUnvoteAmount = $t01250212567._2
354+            let userVoteAmountForNewPool = getUserTotalVoteForNewPoolAmount(i.caller)
355+            let blockedInLaunchpad = getUserBlockedInLauchpad(i.caller)
356+            if (if (if ((0 > userUnvoteAmount))
357+                then true
358+                else (0 > userVoteAmount))
359+                then true
360+                else (0 > userVoteAmountForNewPool))
361+                then throw("userUnvoteAmount < 0 || userVoteAmount < 0 || userVoteAmountForNewPool < 0")
362+                else {
363+                    let availableToUnstake = (userSWOPLocked - max([userVoteAmountForNewPool, (userVoteAmount + userUnvoteAmount), blockedInLaunchpad]))
364+                    if ((withdrawAmount > availableToUnstake))
365+                        then throw("withdrawAmount > availableToUnstake")
366+                        else {
367+                            let totalSWOPLockedNew = ((totalSWOPLocked + claimAmount) - withdrawAmount)
368+                            let userSWOPamountNew = ((userSWOPLocked + claimAmount) - withdrawAmount)
369+                            let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
370+                            let userClaimedAmountNew = (userClaimedAmount + claimAmount)
371+[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)]
372+                            }
373+                    }
374+            }
375+
376+
377+
378+@Callable(i)
379+func claimAndWithdrawSWOP () = if (!(isActive))
380+    then throw("DApp is inactive at this moment")
381+    else {
382+        let lastInterest = getLastInterestInfo()
383+        let $t01402614081 = claimCalc(i.caller)
384+        let userNewInterest = $t01402614081._1
385+        let claimAmount = $t01402614081._2
386+        let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
387+        let userClaimedAmountNew = (userClaimedAmount + claimAmount)
388+        if ((claimAmount == 0))
389+            then throw("You have 0 available SWOP")
390+            else [IntegerEntry((toString(i.caller) + keyUserLastInterest), userNewInterest), IntegerEntry((toString(i.caller) + keyUserSWOPClaimedAmount), userClaimedAmountNew), IntegerEntry((toString(i.caller) + keyUserSWOPLastClaimedAmount), claimAmount), ScriptTransfer(i.caller, claimAmount, SWOP)]
391+        }
392+
393+
394+
395+@Callable(i)
396+func claimAndStakeSWOP () = if (!(isActive))
397+    then throw("DApp is inactive at this moment")
398+    else {
399+        let totalSWOPLocked = getTotalSWOPLocked()
400+        let userSWOPLocked = getUserSWOPLocked(i.caller)
401+        let lastInterest = getLastInterestInfo()
402+        let $t01486014915 = claimCalc(i.caller)
403+        let userNewInterest = $t01486014915._1
404+        let claimAmount = $t01486014915._2
405+        let userSWOPLockedNew = (userSWOPLocked + claimAmount)
406+        let totalSWOPLockedNew = (totalSWOPLocked + claimAmount)
407+        let userClaimedAmount = getUserSWOPClaimedAmount(i.caller)
408+        let userClaimedAmountNew = (userClaimedAmount + claimAmount)
409+        if ((claimAmount == 0))
410+            then throw("You have 0 available SWOP")
411+            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)]
412+        }
413+
414+
415+
416+@Callable(i)
417+func updateWeights (currentPools,currentRewards,rewardUpdateHeight,pagination) = if (!(isActive))
418+    then throw("DApp is inactive at this moment")
419+    else {
420+        let amountPools = 10
421+        let totalRewardUpdateHeight = valueOrElse(getInteger(this, keyRewardUpdateHeight), 0)
422+        if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop, adminPubKeyWallet], i.callerPublicKey)))
423+            then throw("Only admin can call this function")
424+            else if ((size(currentPools) > amountPools))
425+                then throw(("Max amount of pool is " + toString(amountPools)))
426+                else if ((totalRewardUpdateHeight >= rewardUpdateHeight))
427+                    then throw("rewardUpdateHeight <= totalRewardUpdateHeight")
428+                    else if ((height >= rewardUpdateHeight))
429+                        then throw("height >= rewardUpdateHeight")
430+                        else if ((0 >= rewardUpdateHeight))
431+                            then throw("0 >= rewardUpdateHeight ")
432+                            else {
433+                                func sum (a,b) =                                 (a + b)
434+
435+                                func changePreviousRewardEntry (accumulated,pool) =                                 {
436+                                    let poolRewardUpdateHeight = getPoolUpdateHeight(pool)
437+                                    if (if (!(isDefinePoolUpdateHeight(pool)))
438+                                        then true
439+                                        else if ((rewardUpdateHeight != poolRewardUpdateHeight))
440+                                            then (poolRewardUpdateHeight == totalRewardUpdateHeight)
441+                                            else false)
442+                                        then {
443+                                            let poolReward = getCurPoolWeight(pool)
444+IntegerEntry((pool + keyRewardPoolFractionPrevious), poolReward) :: accumulated
445+                                            }
446+                                        else {
447+                                            let poolReward = getPrevPoolWeight(pool)
448+IntegerEntry((pool + keyRewardPoolFractionPrevious), poolReward) :: accumulated
449+                                            }
450+                                    }
451+
452+                                func changeCurrentRewardEntry (accumulated,pool) =                                 {
453+                                    let poolIndex = value(indexOf(currentPools, pool))
454+                                    let poolReward = currentRewards[poolIndex]
455+                                    if ((0 > poolReward))
456+                                        then throw("PoolReward < 0")
457+                                        else IntegerEntry((pool + keyRewardPoolFractionCurrent), poolReward) :: accumulated
458+                                    }
459+
460+                                func changeHeightEntry (accumulated,pool) =                                 {
461+                                    let poolHeight = rewardUpdateHeight
462+IntegerEntry((pool + keyHeightPoolFraction), poolHeight) :: accumulated
463+                                    }
464+
465+                                func getSumReward (curTempSum,pagination) =                                 if ((pagination == 0))
466+                                    then if ((curTempSum > totalVoteShare))
467+                                        then throw(((("sumRewardPrevious > totalVoteShare or sumRewardCurrent > totalVoteShare - " + toString(pagination)) + " ") + toString(curTempSum)))
468+                                        else $Tuple2([IntegerEntry(keyTempCurSum, curTempSum)], [IntegerEntry(keyRewardUpdateFirstPaginationHeight, rewardUpdateHeight)])
469+                                    else if ((pagination == 1))
470+                                        then {
471+                                            let curTempSumFromKey = valueOrElse(getInteger(this, keyTempCurSum), 0)
472+                                            let rewardUpdateHeightFirstPaginationEntry = valueOrElse(getInteger(this, keyRewardUpdateFirstPaginationHeight), 0)
473+                                            if (((curTempSum + curTempSumFromKey) > totalVoteShare))
474+                                                then throw(((("sumRewardPrevious > totalVoteShare or sumRewardCurrent > totalVoteShare - " + toString(pagination)) + " ") + toString((curTempSum + curTempSumFromKey))))
475+                                                else if ((rewardUpdateHeightFirstPaginationEntry != rewardUpdateHeight))
476+                                                    then throw("current rewardUpdateHeight != rewardUpdateHeightFirstPaginationEntry")
477+                                                    else $Tuple2([IntegerEntry(keyTempCurSum, (curTempSum + curTempSumFromKey))], nil)
478+                                            }
479+                                        else if ((pagination == 2))
480+                                            then {
481+                                                let curSum = (valueOrElse(getInteger(this, keyTempCurSum), 0) + curTempSum)
482+                                                let rewardUpdateHeightFirstPaginationEntry = valueOrElse(getInteger(this, keyRewardUpdateFirstPaginationHeight), 0)
483+                                                if ((curSum != totalVoteShare))
484+                                                    then throw("sumRewardPrevious != totalVoteShare or sumRewardCurrent != totalVoteShare")
485+                                                    else if ((rewardUpdateHeightFirstPaginationEntry != rewardUpdateHeight))
486+                                                        then throw("current rewardUpdateHeight != rewardUpdateHeightFirstPaginationEntry")
487+                                                        else $Tuple2([IntegerEntry(keyTempCurSum, curSum)], nil)
488+                                                }
489+                                            else throw("Incorrect pagination")
490+
491+                                let previousRewardEntryNew = {
492+                                    let $l = currentPools
493+                                    let $s = size($l)
494+                                    let $acc0 = nil
495+                                    func $f0_1 ($a,$i) =                                     if (($i >= $s))
496+                                        then $a
497+                                        else changePreviousRewardEntry($a, $l[$i])
498+
499+                                    func $f0_2 ($a,$i) =                                     if (($i >= $s))
500+                                        then $a
501+                                        else throw("List size exceeds 10")
502+
503+                                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
504+                                    }
505+                                let currentRewardEntryNew = {
506+                                    let $l = currentPools
507+                                    let $s = size($l)
508+                                    let $acc0 = nil
509+                                    func $f1_1 ($a,$i) =                                     if (($i >= $s))
510+                                        then $a
511+                                        else changeCurrentRewardEntry($a, $l[$i])
512+
513+                                    func $f1_2 ($a,$i) =                                     if (($i >= $s))
514+                                        then $a
515+                                        else throw("List size exceeds 10")
516+
517+                                    $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
518+                                    }
519+                                let heightEntryNewCur = {
520+                                    let $l = currentPools
521+                                    let $s = size($l)
522+                                    let $acc0 = nil
523+                                    func $f2_1 ($a,$i) =                                     if (($i >= $s))
524+                                        then $a
525+                                        else changeHeightEntry($a, $l[$i])
526+
527+                                    func $f2_2 ($a,$i) =                                     if (($i >= $s))
528+                                        then $a
529+                                        else throw("List size exceeds 10")
530+
531+                                    $f2_2($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($f2_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
532+                                    }
533+                                let sumRewardCurrentTemp = {
534+                                    let $l = currentRewards
535+                                    let $s = size($l)
536+                                    let $acc0 = 0
537+                                    func $f3_1 ($a,$i) =                                     if (($i >= $s))
538+                                        then $a
539+                                        else sum($a, $l[$i])
540+
541+                                    func $f3_2 ($a,$i) =                                     if (($i >= $s))
542+                                        then $a
543+                                        else throw("List size exceeds 10")
544+
545+                                    $f3_2($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($f3_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
546+                                    }
547+                                let $t02005920170 = getSumReward(sumRewardCurrentTemp, pagination)
548+                                let sumRewardCurrent = $t02005920170._1
549+                                let rewardUpdateHeightFirstPaginationEntry = $t02005920170._2
550+                                let rewardUpdateHeightEntry = if ((pagination == 2))
551+                                    then [IntegerEntry(keyRewardUpdateHeight, rewardUpdateHeight)]
552+                                    else nil
553+                                if ((height > rewardUpdateHeight))
554+                                    then throw("rewardUpdateHeight < height")
555+                                    else (((((previousRewardEntryNew ++ currentRewardEntryNew) ++ heightEntryNewCur) ++ sumRewardCurrent) ++ rewardUpdateHeightEntry) ++ rewardUpdateHeightFirstPaginationEntry)
556+                                }
557+        }
558+
559+
560+
561+@Callable(i)
562+func shutdown () = if (!(isActive))
563+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, keyCause), "the cause wasn't specified")))
564+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
565+        then throw("Only admin can call this function")
566+        else suspend("Paused by admin")
567+
568+
569+
570+@Callable(i)
571+func activate () = if (isActive)
572+    then throw("DApp is already active")
573+    else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStartStop], i.callerPublicKey)))
574+        then throw("Only admin can call this function")
575+        else [BooleanEntry(keyActive, true), DeleteEntry(keyCause)]
576+
577+
578+@Verifier(tx)
579+func verify () = {
580+    let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
581+        then 1
582+        else 0
583+    let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
584+        then 1
585+        else 0
586+    let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
587+        then 1
588+        else 0
589+    (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
590+    }
6591 
github/deemru/w8io/169f3d6 
59.83 ms ◑