tx · 3wLVAcwZwkRJGm2VwEnp56Gjg4XMUgvoxzVH8w7K65uM

3MryxrRQ2LXmbZ9FvjVp3S7DjKUfpTdQfY6:  -0.03400000 Waves

2023.02.22 14:57 [2460824] smart account 3MryxrRQ2LXmbZ9FvjVp3S7DjKUfpTdQfY6 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3wLVAcwZwkRJGm2VwEnp56Gjg4XMUgvoxzVH8w7K65uM",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1677067088324,
    "version": 1,
    "sender": "3MryxrRQ2LXmbZ9FvjVp3S7DjKUfpTdQfY6",
    "senderPublicKey": "3BSGCGCq7pbbuADt4JeujrBTqSU1vh2FM4B3ZQr9vUUP",
    "proofs": [
        "4qU66pnE4cys1eQJWmX9kbTTbd3uuezbRwkELNYF3Hy3wMRKJiEAPEqeREW6ihpjt8PWUXNby6zXZBRqVSgYmjAZ"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2460824,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: UHHJvQgKCtj2LgbWpTCusY5buH9sKWZ1TLTFLiEY8we

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let separator = "__"
5+
6+let maxDepthDefault = 10
7+
8+func asInt (val) = match val {
9+    case valInt: Int => 
10+        valInt
11+    case _ => 
12+        throw("Failed to cast into Integer")
13+}
14+
15+
16+func asBool (val) = match val {
17+    case valBool: Boolean => 
18+        valBool
19+    case _ => 
20+        throw("Failed to cast into Boolean")
21+}
22+
23+
24+let keyFeeAmount = makeString(["%s", "fee"], separator)
25+
26+let keyWxAssetId = makeString(["%s", "wxAssetId"], separator)
27+
28+let keyVotingThreshold = makeString(["%s", "votingThreshold"], separator)
29+
30+let keyVotingDuration = makeString(["%s", "epochLength"], separator)
31+
32+let keyVoteBeforeElimination = makeString(["%s", "voteBeforeElimination"], separator)
33+
34+let keyStartHeight = makeString(["%s", "currentVotingHeightStart"], separator)
35+
36+let keyCurrentPeriod = makeString(["%s", "currentEpoch"], separator)
37+
38+let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
39+
40+let keyEmissionContract = makeString(["%s", "emissionContract"], separator)
41+
42+let keyAssetsStoreContract = makeString(["%s", "assetsStoreContract"], separator)
43+
44+let keyLatestProcessedAsset = makeString(["%s", "latestProcessedAsset"], separator)
45+
46+let keyLatestProcessedUser = makeString(["%s", "latestProcessedUser"], separator)
47+
48+let keyLatestProcessedUserRemove = makeString(["%s", "latestProcessedUserRemove"], separator)
49+
50+let keyLatestProcessedAssetTransfer = makeString(["%s", "latestProcessedAssetTransfer"], separator)
51+
52+let keyLatestProcessedUserTransfer = makeString(["%s", "latestProcessedUserTransfer"], separator)
53+
54+let keyLatestProcessedUserRemoveTransfer = makeString(["%s", "latestProcessedUserRemoveTransfer"], separator)
55+
56+let keyMaxDepth = makeString(["%s", "maxDepth"], separator)
57+
58+func keyVotesTransferFinishedByPeriod (period) = makeString(["%s", "votesTransferFinished", toString(period)], separator)
59+
60+
61+let assetsListName = "__assets"
62+
63+func getVotesListName (assetId) = ("%s__votes__" + assetId)
64+
65+
66+func keyListHead (listName) = makeString([("%s%s" + listName), "head"], separator)
67+
68+
69+func keyListSize (listName) = makeString([("%s%s" + listName), "size"], separator)
70+
71+
72+func keyListPrev (listName,id) = makeString([("%s%s%s" + listName), id, "prev"], separator)
73+
74+
75+func keyListNext (listName,id) = makeString([("%s%s%s" + listName), id, "next"], separator)
76+
77+
78+func keyAssetVerifiedByPeriod (assetId,period) = makeString(["%s%d%s", "verifiedAt", toString(period), assetId], separator)
79+
80+
81+func keyAssetVerified (assetId) = makeString(["%s%s", "verified", assetId], separator)
82+
83+
84+func keyAssetWasEliminated (assetId,period) = makeString(["%s%s%d", "eliminated", assetId, toString(period)], separator)
85+
86+
87+func keyVoteResultByPeriod (assetId,period) = makeString(["%s%d%s", "votingResultAtAsset", toString(period), assetId], separator)
88+
89+
90+func formatVoteResult (totalYes,totalNo,verified) = makeString(["%d%d%s", toString(totalYes), toString(totalNo), toString(verified)], separator)
91+
92+
93+func parseVoteResult (input) = {
94+    let parts = split(input, separator)
95+    let totalYesIdx = 1
96+    let totalNoIdx = 2
97+    let verifiedIdx = 3
98+    let totalYes = parseIntValue(parts[totalYesIdx])
99+    let totalNo = parseIntValue(parts[totalNoIdx])
100+    let verified = if ((size(parts) == 4))
101+        then (parts[verifiedIdx] == "true")
102+        else false
103+    $Tuple3(totalYes, totalNo, verified)
104+    }
105+
106+
107+func keyUserVoteByPeriod (userAddress,assetId,period) = makeString(["%s%d%s%s", "vru", toString(period), assetId, userAddress], separator)
108+
109+
110+func formatUserVote (total,inFavor) = {
111+    let totalYes = if (inFavor)
112+        then total
113+        else 0
114+    let totalNo = if (inFavor)
115+        then 0
116+        else total
117+    makeString(["%d%d", toString(totalYes), toString(totalNo)], separator)
118+    }
119+
120+
121+func parseUserVote (input) = {
122+    let parts = split(input, separator)
123+    let totalYesIdx = 1
124+    let totalNoIdx = 2
125+    let totalYes = parseIntValue(parts[totalYesIdx])
126+    let totalNo = parseIntValue(parts[totalNoIdx])
127+    let inFavor = if ((totalYes > 0))
128+        then (totalNo == 0)
129+        else false
130+    let against = if ((totalYes == 0))
131+        then (totalNo > 0)
132+        else false
133+    let checkTotals = if (if (inFavor)
134+        then true
135+        else against)
136+        then true
137+        else throw("Invalid user vote value")
138+    if ((checkTotals == checkTotals))
139+        then {
140+            let total = if (inFavor)
141+                then totalYes
142+                else totalNo
143+            $Tuple2(total, inFavor)
144+            }
145+        else throw("Strict value is not equal to itself.")
146+    }
147+
148+
149+func keyUserVoteHistory (type,userAddress,assetId,txId,period) = makeString(["%s%s%s%s%s%d", "history", type, assetId, userAddress, txId, toString(period)], separator)
150+
151+
152+func thisOnly (i) = if ((i.caller == this))
153+    then true
154+    else throw("Permission denied")
155+
156+
157+func getIntegerOrZero (key) = valueOrElse(getInteger(this, key), 0)
158+
159+
160+func getIntegerOrFail (key) = valueOrErrorMessage(getInteger(this, key), (key + " is not defined"))
161+
162+
163+func getStringOrEmpty (key) = valueOrElse(getString(this, key), "")
164+
165+
166+func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), (key + " is not defined"))
167+
168+
169+let feeAmount = getIntegerOrFail(keyFeeAmount)
170+
171+let wxAssetId = fromBase58String(getStringOrFail(keyWxAssetId))
172+
173+let votingThreshold = getIntegerOrFail(keyVotingThreshold)
174+
175+let votingDuration = getIntegerOrFail(keyVotingDuration)
176+
177+let voteBeforeElimination = getIntegerOrFail(keyVoteBeforeElimination)
178+
179+let startHeight = getIntegerOrFail(keyStartHeight)
180+
181+let currentPeriod = getIntegerOrFail(keyCurrentPeriod)
182+
183+let boostingContract = addressFromStringValue(getStringOrFail(keyBoostingContract))
184+
185+let emissionContract = addressFromStringValue(getStringOrFail(keyEmissionContract))
186+
187+let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract))
188+
189+let maxDepth = valueOrElse(getInteger(keyMaxDepth), maxDepthDefault)
190+
191+let endHeight = (startHeight + votingDuration)
192+
193+func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
194+    let gwxAmount = invoke(boostingContract, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
195+    asInt(gwxAmount)
196+    }
197+
198+
199+func getVoteResultAction (assetId,total,inFavor,period,verified) = {
200+    let voteResultKey = keyVoteResultByPeriod(assetId, period)
201+    let $t062886597 =     match getString(voteResultKey) {
202+        case s: String => 
203+            parseVoteResult(s)
204+        case _: Unit => 
205+            match getString(keyVoteResultByPeriod(assetId, (period - 1))) {
206+                case s: String => 
207+                    $Tuple3(0, 0, parseVoteResult(s)._3)
208+                case _: Unit => 
209+                    $Tuple3(0, 0, false)
210+                case _ => 
211+                    throw("Match error")
212+            }
213+        case _ => 
214+            throw("Match error")
215+    }
216+    let oldTotalYes = $t062886597._1
217+    let oldTotalNo = $t062886597._2
218+    let oldVerified = $t062886597._3
219+    StringEntry(voteResultKey, formatVoteResult((oldTotalYes + (if (inFavor)
220+        then total
221+        else 0)), (oldTotalNo + (if (inFavor)
222+        then 0
223+        else total)), if ((verified == unit))
224+        then oldVerified
225+        else value(verified)))
226+    }
227+
228+
229+func containsNode (listName,id) = {
230+    let head = getString(this, keyListHead(listName))
231+    let prev = getString(this, keyListPrev(listName, id))
232+    let next = getString(this, keyListNext(listName, id))
233+    if (if ((id == head))
234+        then true
235+        else (prev != unit))
236+        then true
237+        else (next != unit)
238+    }
239+
240+
241+func insertNode (listName,id) = {
242+    let head = getString(this, keyListHead(listName))
243+    let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
244+    let checkNode = if (!(containsNode(listName, id)))
245+        then true
246+        else throw("Node exists")
247+    if ((checkNode == checkNode))
248+        then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if (isDefined(head))
249+            then [StringEntry(keyListNext(listName, id), value(head)), StringEntry(keyListPrev(listName, value(head)), id)]
250+            else nil)) ++ [StringEntry(keyListHead(listName), id)])
251+        else throw("Strict value is not equal to itself.")
252+    }
253+
254+
255+func deleteNode (listName,id) = {
256+    let head = getString(this, keyListHead(listName))
257+    let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
258+    let prev = getString(this, keyListPrev(listName, id))
259+    let next = getString(this, keyListNext(listName, id))
260+    ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if (isDefined(prev))
261+        then isDefined(next)
262+        else false)
263+        then [StringEntry(keyListNext(listName, value(prev)), value(next)), StringEntry(keyListPrev(listName, value(next)), value(prev)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
264+        else if (isDefined(next))
265+            then [StringEntry(keyListHead(listName), value(next)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(next)))]
266+            else if (isDefined(prev))
267+                then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prev)))]
268+                else if ((id == head))
269+                    then [DeleteEntry(keyListHead(listName))]
270+                    else throw("Invalid node")))
271+    }
272+
273+
274+func processVote (assetId,userAddressOrUnit,latestProcessedAssetKey,latestProcessedUserKey,latestProcessedUserRemoveKey) = {
275+    let updateLatestProcessedAssetAction = StringEntry(latestProcessedAssetKey, assetId)
276+    let deleteLatestProcessedUserAction = DeleteEntry(latestProcessedUserKey)
277+    if ((userAddressOrUnit == unit))
278+        then [updateLatestProcessedAssetAction, deleteLatestProcessedUserAction]
279+        else {
280+            let userAddress = value(userAddressOrUnit)
281+            let updateLatestProcessedUserAction = StringEntry(latestProcessedUserKey, userAddress)
282+            let userVoteKey = keyUserVoteByPeriod(userAddress, assetId, currentPeriod)
283+            let userVoteOrUnit = getString(userVoteKey)
284+            let voteActions = if ((userVoteOrUnit == unit))
285+                then {
286+                    let userGwxAmountAtEndHeight = getUserGwxAmountAtHeight(userAddress, endHeight)
287+                    if ((userGwxAmountAtEndHeight == 0))
288+                        then [BooleanEntry(latestProcessedUserRemoveKey, true)]
289+                        else {
290+                            let previousPeriod = (currentPeriod - 1)
291+                            let assetWasEliminated = valueOrElse(getBoolean(keyAssetWasEliminated(assetId, previousPeriod)), false)
292+                            let userPreviousVoteOrUnit = if (assetWasEliminated)
293+                                then unit
294+                                else getString(keyUserVoteByPeriod(userAddress, assetId, previousPeriod))
295+                            if ((userPreviousVoteOrUnit == unit))
296+                                then nil
297+                                else {
298+                                    let $t01080110874 = parseUserVote(value(userPreviousVoteOrUnit))
299+                                    let prevTotal = $t01080110874._1
300+                                    let inFavor = $t01080110874._2
301+                                    let total = min([prevTotal, userGwxAmountAtEndHeight])
302+[StringEntry(userVoteKey, formatUserVote(total, inFavor)), getVoteResultAction(assetId, total, inFavor, currentPeriod, unit)]
303+                                    }
304+                            }
305+                    }
306+                else nil
307+            ((voteActions :+ updateLatestProcessedAssetAction) :+ updateLatestProcessedUserAction)
308+            }
309+    }
310+
311+
312+func assetShouldBeEliminated (assetId,period) = !(valueOrElse(getBoolean(keyAssetVerifiedByPeriod(assetId, period)), true))
313+
314+
315+func eliminationCheck (assetId) = if (if (assetShouldBeEliminated(assetId, (currentPeriod - 1)))
316+    then assetShouldBeEliminated(assetId, (currentPeriod - 2))
317+    else false)
318+    then assetShouldBeEliminated(assetId, (currentPeriod - 3))
319+    else false
320+
321+
322+@Callable(i)
323+func constructor (boostingContractPrm,emissionContractPrm,assetsStoreContractPrm,feeAmountPrm,wxAssetIdPrm,votingThresholdPrm,votingDurationPrm,voteBeforeEliminationPrm,startHeightPrm,maxDepthPrm) = {
324+    let checks = [thisOnly(i), if (isDefined(addressFromString(boostingContractPrm)))
325+        then true
326+        else throw("Invalid boosting contract address"), if (isDefined(addressFromString(emissionContractPrm)))
327+        then true
328+        else throw("Invalid emission contract address"), if (isDefined(addressFromString(assetsStoreContractPrm)))
329+        then true
330+        else throw("Invalid asset_store contract address"), if ((feeAmountPrm >= 0))
331+        then true
332+        else throw("Invalid fee amount"), if (isDefined(assetInfo(fromBase58String(wxAssetIdPrm))))
333+        then true
334+        else throw("Invalid WX asset ID"), if ((votingThresholdPrm >= 0))
335+        then true
336+        else throw("Invalid voting threshold"), if ((votingDurationPrm > 0))
337+        then true
338+        else throw("Invalid voting duration"), if (((startHeightPrm + votingDurationPrm) > height))
339+        then true
340+        else throw("Invalid start height")]
341+    if ((checks == checks))
342+        then $Tuple2([StringEntry(keyBoostingContract, boostingContractPrm), StringEntry(keyEmissionContract, emissionContractPrm), StringEntry(keyAssetsStoreContract, assetsStoreContractPrm), IntegerEntry(keyFeeAmount, feeAmountPrm), StringEntry(keyWxAssetId, wxAssetIdPrm), IntegerEntry(keyVotingThreshold, votingThresholdPrm), IntegerEntry(keyVotingDuration, votingDurationPrm), IntegerEntry(keyVoteBeforeElimination, voteBeforeEliminationPrm), IntegerEntry(keyStartHeight, startHeightPrm), IntegerEntry(keyCurrentPeriod, 0), IntegerEntry(keyMaxDepth, maxDepthPrm)], unit)
343+        else throw("Strict value is not equal to itself.")
344+    }
345+
346+
347+
348+@Callable(i)
349+func suggest (assetId,assetImage) = {
350+    let info = valueOrErrorMessage(assetInfo(fromBase58String(assetId)), "Invalid asset ID")
351+    let payment = value(i.payments[0])
352+    let checks = [if ((info.issuer == i.caller))
353+        then true
354+        else throw("Asset can only be suggested by its issuer"), if ((value(payment.assetId) == wxAssetId))
355+        then true
356+        else throw("Invalid fee asset"), if ((payment.amount == feeAmount))
357+        then true
358+        else throw("Invalid fee amount")]
359+    if ((checks == checks))
360+        then {
361+            let assetsStoreCreateOrUpdateInv = invoke(assetsStoreContract, "createOrUpdate", [assetId, assetImage, false], nil)
362+            if ((assetsStoreCreateOrUpdateInv == assetsStoreCreateOrUpdateInv))
363+                then {
364+                    let burnFeeInv = invoke(emissionContract, "burn", nil, [AttachedPayment(payment.assetId, payment.amount)])
365+                    if ((burnFeeInv == burnFeeInv))
366+                        then {
367+                            let addAssetActions = insertNode(assetsListName, assetId)
368+                            let nextPeriod = (currentPeriod + 1)
369+                            let targetPeriod = if ((endHeight > height))
370+                                then currentPeriod
371+                                else nextPeriod
372+                            $Tuple2((addAssetActions :+ getVoteResultAction(assetId, 0, true, targetPeriod, false)), unit)
373+                            }
374+                        else throw("Strict value is not equal to itself.")
375+                    }
376+                else throw("Strict value is not equal to itself.")
377+            }
378+        else throw("Strict value is not equal to itself.")
379+    }
380+
381+
382+
383+@Callable(i)
384+func vote (assetId,inFavor) = {
385+    let checkAsset = if (containsNode(assetsListName, assetId))
386+        then true
387+        else throw("Invalid asset")
388+    if ((checkAsset == checkAsset))
389+        then {
390+            let checkHeight = if ((endHeight > height))
391+                then true
392+                else throw("Current voting is over but results are not finalized")
393+            if ((checkHeight == checkHeight))
394+                then {
395+                    let userAddress = toString(i.caller)
396+                    let gwxAmountAtEnd = getUserGwxAmountAtHeight(userAddress, endHeight)
397+                    let checkGwxAmountAtEnd = if ((gwxAmountAtEnd > 0))
398+                        then true
399+                        else throw("You'll not have gWX at the end of voting")
400+                    if ((checkGwxAmountAtEnd == checkGwxAmountAtEnd))
401+                        then {
402+                            let votesListName = getVotesListName(assetId)
403+                            let userVoteKey = keyUserVoteByPeriod(userAddress, assetId, currentPeriod)
404+                            let userVoteOrUnit = getString(userVoteKey)
405+                            let cancelVoteInv = if ((userVoteOrUnit == unit))
406+                                then unit
407+                                else invoke(this, "cancelVote", [assetId], nil)
408+                            if ((cancelVoteInv == cancelVoteInv))
409+                                then {
410+                                    let userVoteActions = [StringEntry(userVoteKey, formatUserVote(gwxAmountAtEnd, inFavor)), StringEntry(keyUserVoteHistory("vote", userAddress, assetId, toBase58String(i.transactionId), currentPeriod), formatUserVote(gwxAmountAtEnd, inFavor)), getVoteResultAction(assetId, gwxAmountAtEnd, inFavor, currentPeriod, unit)]
411+                                    let votesListActions = if (containsNode(votesListName, userAddress))
412+                                        then nil
413+                                        else insertNode(votesListName, userAddress)
414+                                    $Tuple2((votesListActions ++ userVoteActions), unit)
415+                                    }
416+                                else throw("Strict value is not equal to itself.")
417+                            }
418+                        else throw("Strict value is not equal to itself.")
419+                    }
420+                else throw("Strict value is not equal to itself.")
421+            }
422+        else throw("Strict value is not equal to itself.")
423+    }
424+
425+
426+
427+@Callable(i)
428+func cancelVote (assetId) = {
429+    let userAddress = if ((i.caller == this))
430+        then toString(i.originCaller)
431+        else toString(i.caller)
432+    let votesListName = getVotesListName(assetId)
433+    let userVoteKey = keyUserVoteByPeriod(userAddress, assetId, currentPeriod)
434+    let userVoteOrUnit = getString(userVoteKey)
435+    let $t01631416408 = parseUserVote(valueOrErrorMessage(userVoteOrUnit, "Nothing to cancel"))
436+    let total = $t01631416408._1
437+    let inFavor = $t01631416408._2
438+    let votesListActions = deleteNode(votesListName, userAddress)
439+    let userVoteActions = [DeleteEntry(userVoteKey), StringEntry(keyUserVoteHistory("cancelVote", userAddress, assetId, toBase58String(i.transactionId), currentPeriod), formatUserVote(0, true)), getVoteResultAction(assetId, -(total), inFavor, currentPeriod, unit)]
440+    $Tuple2((votesListActions ++ userVoteActions), unit)
441+    }
442+
443+
444+
445+@Callable(i)
446+func finalizeAssetINTERNAL (assetId,period) = {
447+    let checkCaller = thisOnly(i)
448+    if ((checkCaller == checkCaller))
449+        then {
450+            let voteResultKey = keyVoteResultByPeriod(assetId, period)
451+            let $t01706317242 =             match getString(voteResultKey) {
452+                case s: String => 
453+                    let r = parseVoteResult(s)
454+                    $Tuple2(r._1, r._2)
455+                case _: Unit => 
456+                    $Tuple2(0, 0)
457+                case _ => 
458+                    throw("Match error")
459+            }
460+            let totalYes = $t01706317242._1
461+            let totalNo = $t01706317242._2
462+            let total = (totalYes + totalNo)
463+            let verified = if ((total >= votingThreshold))
464+                then (totalYes > totalNo)
465+                else false
466+            let assetVerifiedActions = [BooleanEntry(keyAssetVerifiedByPeriod(assetId, period), verified), if (verified)
467+                then BooleanEntry(keyAssetVerified(assetId), true)
468+                else DeleteEntry(keyAssetVerified(assetId))]
469+            let assetsStoreSetVerifiedInv = invoke(assetsStoreContract, "setVerified", [assetId, verified], nil)
470+            if ((assetsStoreSetVerifiedInv == assetsStoreSetVerifiedInv))
471+                then {
472+                    let eliminate = if (verified)
473+                        then false
474+                        else eliminationCheck(assetId)
475+                    let assetWasEliminatedActions = if (eliminate)
476+                        then [BooleanEntry(keyAssetWasEliminated(assetId, currentPeriod), true)]
477+                        else nil
478+                    let voteResultActions = if (eliminate)
479+                        then nil
480+                        else [getVoteResultAction(assetId, 0, true, (currentPeriod + 1), verified)]
481+                    let votesListActions = if (eliminate)
482+                        then deleteNode(assetsListName, assetId)
483+                        else nil
484+                    let onEliminationInv = if (eliminate)
485+                        then invoke(assetsStoreContract, "onEliminate", [assetId], nil)
486+                        else unit
487+                    if ((onEliminationInv == onEliminationInv))
488+                        then $Tuple2(((votesListActions ++ voteResultActions) ++ assetVerifiedActions), unit)
489+                        else throw("Strict value is not equal to itself.")
490+                    }
491+                else throw("Strict value is not equal to itself.")
492+            }
493+        else throw("Strict value is not equal to itself.")
494+    }
495+
496+
497+
498+@Callable(i)
499+func deleteUserNodeINTERNAL (assetId,userAddress,latestProcessedUserRemoveKey) = {
500+    let checkCaller = thisOnly(i)
501+    if ((checkCaller == checkCaller))
502+        then $Tuple2((deleteNode(getVotesListName(assetId), userAddress) :+ DeleteEntry(latestProcessedUserRemoveKey)), unit)
503+        else throw("Strict value is not equal to itself.")
504+    }
505+
506+
507+
508+@Callable(i)
509+func finalizeVotingHelper () = if ((endHeight > height))
510+    then $Tuple2(nil, false)
511+    else {
512+        let latestProcessedAssetOrUnit = getString(keyLatestProcessedAsset)
513+        let latestProcessedUserOrUnit = getString(keyLatestProcessedUser)
514+        let nextPeriodDelay = 0
515+        let finish = $Tuple2([IntegerEntry(keyStartHeight, (height + nextPeriodDelay)), IntegerEntry(keyCurrentPeriod, (currentPeriod + 1)), DeleteEntry(keyLatestProcessedAsset), DeleteEntry(keyLatestProcessedUser), DeleteEntry(keyLatestProcessedAssetTransfer), DeleteEntry(keyLatestProcessedUserTransfer)], true)
516+        if ((latestProcessedAssetOrUnit == unit))
517+            then {
518+                let assetsHeadOrUnit = getString(keyListHead(assetsListName))
519+                if ((assetsHeadOrUnit == unit))
520+                    then finish
521+                    else {
522+                        let asset = value(assetsHeadOrUnit)
523+                        let userAddressOrUnit = getString(keyListHead(getVotesListName(asset)))
524+                        let processVoteActions = processVote(asset, userAddressOrUnit, keyLatestProcessedAsset, keyLatestProcessedUser, keyLatestProcessedUserRemove)
525+                        $Tuple2(processVoteActions, true)
526+                        }
527+                }
528+            else {
529+                let latestProcessedAsset = value(latestProcessedAssetOrUnit)
530+                if ((latestProcessedUserOrUnit == unit))
531+                    then {
532+                        let assetOrUnit = getString(keyListNext(assetsListName, latestProcessedAsset))
533+                        if ((assetOrUnit == assetOrUnit))
534+                            then {
535+                                let finalizeAssetInv = invoke(this, "finalizeAssetINTERNAL", [latestProcessedAsset, currentPeriod], nil)
536+                                if ((finalizeAssetInv == finalizeAssetInv))
537+                                    then if ((assetOrUnit == unit))
538+                                        then finish
539+                                        else {
540+                                            let asset = value(assetOrUnit)
541+                                            let userAddressOrUnit = getString(keyListHead(getVotesListName(asset)))
542+                                            let processVoteActions = processVote(asset, userAddressOrUnit, keyLatestProcessedAsset, keyLatestProcessedUser, keyLatestProcessedUserRemove)
543+                                            $Tuple2(processVoteActions, true)
544+                                            }
545+                                    else throw("Strict value is not equal to itself.")
546+                                }
547+                            else throw("Strict value is not equal to itself.")
548+                        }
549+                    else {
550+                        let latestProcessedUser = value(latestProcessedUserOrUnit)
551+                        let userAddressOrUnit = getString(keyListNext(getVotesListName(latestProcessedAsset), latestProcessedUser))
552+                        if ((userAddressOrUnit == userAddressOrUnit))
553+                            then {
554+                                let removeLatestUser = valueOrElse(getBoolean(keyLatestProcessedUserRemove), false)
555+                                let deleteUserInv = if (removeLatestUser)
556+                                    then invoke(this, "deleteUserNodeINTERNAL", [latestProcessedAsset, latestProcessedUser, keyLatestProcessedUserRemove], nil)
557+                                    else unit
558+                                if ((deleteUserInv == deleteUserInv))
559+                                    then {
560+                                        let processVoteActions = processVote(latestProcessedAsset, userAddressOrUnit, keyLatestProcessedAsset, keyLatestProcessedUser, keyLatestProcessedUserRemove)
561+                                        $Tuple2(processVoteActions, true)
562+                                        }
563+                                    else throw("Strict value is not equal to itself.")
564+                                }
565+                            else throw("Strict value is not equal to itself.")
566+                        }
567+                }
568+        }
569+
570+
571+
572+@Callable(i)
573+func finalizeVotingWrapper (counter) = {
574+    let result = asBool(invoke(this, "finalizeVotingHelper", nil, nil))
575+    if ((result == result))
576+        then if (!(result))
577+            then if ((counter == 0))
578+                then throw("Current voting is not over yet")
579+                else $Tuple2(nil, unit)
580+            else if ((maxDepth > counter))
581+                then {
582+                    let inv = invoke(this, "finalizeVotingWrapper", [(counter + 1)], nil)
583+                    if ((inv == inv))
584+                        then $Tuple2(nil, unit)
585+                        else throw("Strict value is not equal to itself.")
586+                    }
587+                else $Tuple2(nil, unit)
588+        else throw("Strict value is not equal to itself.")
589+    }
590+
591+
592+
593+@Callable(i)
594+func finalizeVoting () = {
595+    let inv = invoke(this, "finalizeVotingWrapper", [0], nil)
596+    if ((inv == inv))
597+        then $Tuple2(nil, unit)
598+        else throw("Strict value is not equal to itself.")
599+    }
600+
601+
602+
603+@Callable(i)
604+func transferVotesHelper () = {
605+    let votesTransferFinishedKey = keyVotesTransferFinishedByPeriod(currentPeriod)
606+    let votesTransferFinished = valueOrElse(getBoolean(votesTransferFinishedKey), false)
607+    if (if (if ((startHeight > height))
608+        then true
609+        else (height >= endHeight))
610+        then true
611+        else votesTransferFinished)
612+        then $Tuple2(nil, false)
613+        else {
614+            let latestProcessedAssetOrUnit = getString(keyLatestProcessedAssetTransfer)
615+            let latestProcessedUserOrUnit = getString(keyLatestProcessedUserTransfer)
616+            let finish = $Tuple2([BooleanEntry(votesTransferFinishedKey, true), DeleteEntry(keyLatestProcessedAssetTransfer), DeleteEntry(keyLatestProcessedUserTransfer)], true)
617+            if ((latestProcessedAssetOrUnit == unit))
618+                then {
619+                    let assetsHeadOrUnit = getString(keyListHead(assetsListName))
620+                    if ((assetsHeadOrUnit == unit))
621+                        then finish
622+                        else {
623+                            let asset = value(assetsHeadOrUnit)
624+                            let userAddressOrUnit = getString(keyListHead(getVotesListName(asset)))
625+                            let processVoteActions = processVote(asset, userAddressOrUnit, keyLatestProcessedAssetTransfer, keyLatestProcessedUserTransfer, keyLatestProcessedUserRemoveTransfer)
626+                            $Tuple2(processVoteActions, true)
627+                            }
628+                    }
629+                else {
630+                    let latestProcessedAsset = value(latestProcessedAssetOrUnit)
631+                    if ((latestProcessedUserOrUnit == unit))
632+                        then {
633+                            let assetOrUnit = getString(keyListNext(assetsListName, latestProcessedAsset))
634+                            if ((assetOrUnit == unit))
635+                                then finish
636+                                else {
637+                                    let asset = value(assetOrUnit)
638+                                    let userAddressOrUnit = getString(keyListHead(getVotesListName(asset)))
639+                                    let processVoteActions = processVote(asset, userAddressOrUnit, keyLatestProcessedAssetTransfer, keyLatestProcessedUserTransfer, keyLatestProcessedUserRemoveTransfer)
640+                                    $Tuple2(processVoteActions, true)
641+                                    }
642+                            }
643+                        else {
644+                            let latestProcessedUser = value(latestProcessedUserOrUnit)
645+                            let userAddressOrUnit = getString(keyListNext(getVotesListName(latestProcessedAsset), latestProcessedUser))
646+                            if ((userAddressOrUnit == userAddressOrUnit))
647+                                then {
648+                                    let removeLatestUser = valueOrElse(getBoolean(keyLatestProcessedUserRemoveTransfer), false)
649+                                    let deleteUserInv = if (removeLatestUser)
650+                                        then invoke(this, "deleteUserNodeINTERNAL", [latestProcessedAsset, latestProcessedUser, keyLatestProcessedUserRemoveTransfer], nil)
651+                                        else unit
652+                                    if ((deleteUserInv == deleteUserInv))
653+                                        then {
654+                                            let processVoteActions = processVote(latestProcessedAsset, userAddressOrUnit, keyLatestProcessedAssetTransfer, keyLatestProcessedUserTransfer, keyLatestProcessedUserRemoveTransfer)
655+                                            $Tuple2(processVoteActions, true)
656+                                            }
657+                                        else throw("Strict value is not equal to itself.")
658+                                    }
659+                                else throw("Strict value is not equal to itself.")
660+                            }
661+                    }
662+            }
663+    }
664+
665+
666+
667+@Callable(i)
668+func transferVotesWrapper (counter) = {
669+    let result = asBool(invoke(this, "transferVotesHelper", nil, nil))
670+    if ((result == result))
671+        then if (!(result))
672+            then if ((counter == 0))
673+                then throw("Voting is not started yet")
674+                else $Tuple2(nil, unit)
675+            else if ((maxDepth > counter))
676+                then {
677+                    let inv = invoke(this, "transferVotesWrapper", [(counter + 1)], nil)
678+                    if ((inv == inv))
679+                        then $Tuple2(nil, unit)
680+                        else throw("Strict value is not equal to itself.")
681+                    }
682+                else $Tuple2(nil, unit)
683+        else throw("Strict value is not equal to itself.")
684+    }
685+
686+
687+
688+@Callable(i)
689+func transferVotes () = {
690+    let inv = invoke(this, "transferVotesWrapper", [0], nil)
691+    if ((inv == inv))
692+        then $Tuple2(nil, unit)
693+        else throw("Strict value is not equal to itself.")
694+    }
695+
696+
697+
698+@Callable(i)
699+func setVotingThreshold (newThreshold) = {
700+    let checkCaller = thisOnly(i)
701+    if ((checkCaller == checkCaller))
702+        then $Tuple2([IntegerEntry(keyVotingThreshold, newThreshold)], unit)
703+        else throw("Strict value is not equal to itself.")
704+    }
705+
706+
707+
708+@Callable(i)
709+func setFee (newFee) = {
710+    let checkCaller = thisOnly(i)
711+    if ((checkCaller == checkCaller))
712+        then $Tuple2([IntegerEntry(keyFeeAmount, newFee)], unit)
713+        else throw("Strict value is not equal to itself.")
714+    }
715+
716+
717+
718+@Callable(i)
719+func gwxAvailableForVoteREADONLY (userAddress) = {
720+    let gwxAmountAtEnd = getUserGwxAmountAtHeight(userAddress, endHeight)
721+    $Tuple2(nil, gwxAmountAtEnd)
722+    }
723+
724+
github/deemru/w8io/026f985 
37.79 ms ◑