w8 · tx

2023.06.08 15:34 [3679269] smart account 3P4855PBM7UFPiDn8VC25LvqK8Yr9v5BawT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DRwmUtfxTLzMFjDEXuMvFm4n1TB1VYKKoKPoRFaHs3up",
    "fee": 17000000,
    "feeAssetId": null,
    "timestamp": 1686227646961,
    "version": 2,
    "chainId": 87,
    "sender": "3P4855PBM7UFPiDn8VC25LvqK8Yr9v5BawT",
    "senderPublicKey": "3tXHkQVY1spKwuS7WBaBbSwHFHZacLJ9mW1n6bwHpx33",
    "proofs": [
        "2uuzN9PGmFWBTUm2xjjciSv7cP98EsD3ivoQKarSitehrhU4jPHdemzVBCFmYmz2kRhRKeJ6NGaVWNcgC8qGYSoK"
    ],
    "script": "base64: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",
    "height": 3679269,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 9Exrx86eSsMoVR9LdZkRTzRjainNfDbUVZ9B4KUSmpEN

Full: 
Old New Differences
1 - # no script
1 + {-# STDLIB_VERSION 6 #-}
2 + {-# SCRIPT_TYPE ACCOUNT #-}
3 + {-# CONTENT_TYPE DAPP #-}
4 + let separator = "__"
5 + 
6 + let MULT8 = 100000000
7 + 
8 + func wrapErr (msg) = makeString(["voting_verified_v2.ride:", msg], " ")
9 + 
10 + 
11 + func throwErr (msg) = throw(wrapErr(msg))
12 + 
13 + 
14 + func asInt (val) = match val {
15 +     case valInt: Int => 
16 +         valInt
17 +     case _ => 
18 +         throw("Failed to cast into Integer")
19 + }
20 + 
21 + 
22 + func getIntegerOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
23 + 
24 + 
25 + func getIntegerOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((key + " is not defined")))
26 + 
27 + 
28 + func getStringOrEmpty (address,key) = valueOrElse(getString(address, key), "")
29 + 
30 + 
31 + func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((key + " is not defined")))
32 + 
33 + 
34 + let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
35 + 
36 + let keyEmissionContract = makeString(["%s", "emissionContract"], separator)
37 + 
38 + let keyAssetsStoreContract = makeString(["%s", "assetsStoreContract"], separator)
39 + 
40 + let boostingContract = addressFromStringValue(getStringValue(keyBoostingContract))
41 + 
42 + let emissionContract = addressFromStringValue(getStringValue(keyEmissionContract))
43 + 
44 + let assetsStoreContract = addressFromStringValue(getStringValue(keyAssetsStoreContract))
45 + 
46 + let keyEmissionConfig = makeString(["%s", "config"], separator)
47 + 
48 + let wxAssetIdStr = split(getStringOrFail(emissionContract, keyEmissionConfig), separator)[1]
49 + 
50 + let wxAssetId = fromBase58String(wxAssetIdStr)
51 + 
52 + let keyVotingThresholdAdd = makeString(["%s%s", "votingThreshold", "add"], separator)
53 + 
54 + let keyVotingThresholdRemove = makeString(["%s%s", "votingThreshold", "remove"], separator)
55 + 
56 + func keyPeriodLengthAdd (assetId,index) = makeString(["%s%s%d", "periodLengthAdd", assetId, toString(index)], separator)
57 + 
58 + 
59 + let keyPeriodLengthRemove = makeString(["%s", "periodLengthRemove"], separator)
60 + 
61 + func keyCurrentVotingHeightStart (assetId,index) = makeString(["%s%s%d", "currentVotingHeightStart", assetId, toString(index)], separator)
62 + 
63 + 
64 + func keyVerified (assetId) = makeString(["%s%s", "verified", assetId], separator)
65 + 
66 + 
67 + func keyVerificationInProgress (assetId) = makeString(["%s%s%s", "verification", "inProgress", assetId], separator)
68 + 
69 + 
70 + func keyDeverificationInProgress (assetId) = makeString(["%s%s%s", "deverification", "inProgress", assetId], separator)
71 + 
72 + 
73 + let keyMaxPeriodLength = makeString(["%s", "maxPeriodLength"], separator)
74 + 
75 + let keyMinPeriodLength = makeString(["%s", "minPeriodLength"], separator)
76 + 
77 + func keyVotingRewardAssetId (assetId,index) = makeString(["%s%s%d", "votingRewardAssetId", assetId, toString(index)], separator)
78 + 
79 + 
80 + func keyVotingReward (userAddress,assetId,index) = makeString(["%s%s%s%d", "votingReward", toString(userAddress), assetId, toString(index)], separator)
81 + 
82 + 
83 + func keyTotalVotingReward (assetId,index) = makeString(["%s%s%d", "votingReward", assetId, toString(index)], separator)
84 + 
85 + 
86 + let keyFinalizeCallRewardAmount = makeString(["%s", "finalizeCallRewardAmount"], separator)
87 + 
88 + let keyMinSuggestRemoveBalance = makeString(["%s", "minSuggestRemoveBalance"], separator)
89 + 
90 + func keyCurrentIndex (assetId) = makeString(["%s%s", "currentIndex", assetId], separator)
91 + 
92 + 
93 + func keyVote (assetId,index,caller) = makeString(["%s%s%d%s", "vote", assetId, toString(index), toString(caller)], separator)
94 + 
95 + 
96 + func voteValue (inFavor,gwxAmount) = makeString(["%s%d", toString(inFavor), toString(gwxAmount)], separator)
97 + 
98 + 
99 + func keyVotingResult (assetId,index) = makeString(["%s%s%d", "votingResult", assetId, toString(index)], separator)
100 + 
101 + 
102 + func votingValue (forAmount,againstAmount) = makeString(["%d%d", toString(forAmount), toString(againstAmount)], separator)
103 + 
104 + 
105 + let defaultVotingValue = makeString(["%d%d", "0", "0"], separator)
106 + 
107 + func keySuggestIssuer (assetId,index) = makeString(["%s%s%d", "suggestIssuer", assetId, toString(index)], separator)
108 + 
109 + 
110 + func keyClaimHistory (userAddress,assetId,index) = makeString(["%s%s%s%d", "history", toString(userAddress), assetId, toString(index)], separator)
111 + 
112 + 
113 + func keyVotingEndHeight (assetId,index) = makeString(["%s%s%d", "votingEndHeight", assetId, toString(index)], separator)
114 + 
115 + 
116 + let keyFeePerBlock = makeString(["%s", "feePerBlock"], separator)
117 + 
118 + let feePerBlock = getIntegerOrFail(this, keyFeePerBlock)
119 + 
120 + let keyMinWxMinForSuggestAddAmountRequired = makeString(["%s", "wxMinForSuggestAddAmountRequired"], separator)
121 + 
122 + let keyWxForSuggestRemoveAmountRequired = makeString(["%s", "wxForSuggestRemoveAmountRequired"], separator)
123 + 
124 + func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
125 +     let gwxAmount = invoke(boostingContract, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
126 +     asInt(gwxAmount)
127 +     }
128 + 
129 + 
130 + func keyManagerVaultAddress () = "%s__managerVaultAddress"
131 + 
132 + 
133 + func keyManagerPublicKey () = "%s__managerPublicKey"
134 + 
135 + 
136 + func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
137 +     case s: String => 
138 +         addressFromStringValue(s)
139 +     case _ => 
140 +         this
141 + }
142 + 
143 + 
144 + func managerPublicKeyOrUnit () = {
145 +     let managerVaultAddress = getManagerVaultAddressOrThis()
146 +     match getString(managerVaultAddress, keyManagerPublicKey()) {
147 +         case s: String => 
148 +             fromBase58String(s)
149 +         case _: Unit => 
150 +             unit
151 +         case _ => 
152 +             throw("Match error")
153 +     }
154 +     }
155 + 
156 + 
157 + func votingExistChecks (assetId,currentIndex) = {
158 +     let verificationInProgress = valueOrElse(getBoolean(keyVerificationInProgress(assetId)), false)
159 +     let deverificationInProgress = valueOrElse(getBoolean(keyDeverificationInProgress(assetId)), false)
160 +     let suggestIssuer = valueOrErrorMessage(getString(keySuggestIssuer(assetId, currentIndex)), wrapErr("voting issuer not found"))
161 +     let currentVotingHeightStart = valueOrErrorMessage(getInteger(keyCurrentVotingHeightStart(assetId, currentIndex)), wrapErr("voting start height not found"))
162 +     let votingPeriodLenght = if (verificationInProgress)
163 +         then valueOrErrorMessage(getInteger(keyPeriodLengthAdd(assetId, currentIndex)), wrapErr("voting period length not found"))
164 +         else value(getInteger(keyPeriodLengthRemove))
165 +     let checks = [if (if (verificationInProgress)
166 +         then true
167 +         else deverificationInProgress)
168 +         then true
169 +         else throwErr("no voting in progress"), if (((currentVotingHeightStart + votingPeriodLenght) > height))
170 +         then true
171 +         else throwErr("voting expired")]
172 +     if ((checks == checks))
173 +         then $Tuple5(verificationInProgress, deverificationInProgress, currentVotingHeightStart, votingPeriodLenght, suggestIssuer)
174 +         else throw("Strict value is not equal to itself.")
175 +     }
176 + 
177 + 
178 + func calculateReward (voter,assetId,index) = {
179 +     let voteKey = keyVote(assetId, index, voter)
180 +     let lastVote = valueOrErrorMessage(getString(voteKey), wrapErr("you have not voted"))
181 +     let lastVoteParts = split(lastVote, separator)
182 +     let inFavor = lastVoteParts[1]
183 +     let rewardAmount = if ((inFavor == "true"))
184 +         then {
185 +             let gwxAmount = parseIntValue(lastVoteParts[2])
186 +             let lastVotingValue = valueOrErrorMessage(getString(keyVotingResult(assetId, index)), wrapErr("voting does not exist"))
187 +             let lastVotingValueParts = split(lastVotingValue, separator)
188 +             let totalVotesFor = parseIntValue(lastVotingValueParts[1])
189 +             let partOfTheTotalVotesX8 = fraction(gwxAmount, MULT8, totalVotesFor)
190 +             let totalVotingReward = valueOrElse(getInteger(keyTotalVotingReward(assetId, index)), 0)
191 +             let rewardAmount = fraction(partOfTheTotalVotesX8, totalVotingReward, MULT8, FLOOR)
192 +             rewardAmount
193 +             }
194 +         else 0
195 +     rewardAmount
196 +     }
197 + 
198 + 
199 + @Callable(i)
200 + func suggestAdd (assetId,periodLength,assetImage) = {
201 +     let info = valueOrErrorMessage(assetInfo(fromBase58String(assetId)), "Invalid asset ID")
202 +     if ((info == info))
203 +         then {
204 +             let currentIndexKey = keyCurrentIndex(assetId)
205 +             let currentIndex = getInteger(currentIndexKey)
206 +             let newIndex = if (isDefined(currentIndex))
207 +                 then (value(currentIndex) + 1)
208 +                 else 0
209 +             let wxPayment = i.payments[0]
210 +             let wxPaymentAssetId = value(wxPayment.assetId)
211 +             let wxPaymentAmount = value(wxPayment.amount)
212 +             let votingRewardActions = if ((size(i.payments) > 1))
213 +                 then {
214 +                     let votingRewardPayment = i.payments[1]
215 +                     let votingRewardPaymentAssetId = toBase58String(value(votingRewardPayment.assetId))
216 +                     let votingRewardPaymentAmount = value(votingRewardPayment.amount)
217 + [StringEntry(keyVotingRewardAssetId(assetId, newIndex), votingRewardPaymentAssetId), IntegerEntry(keyTotalVotingReward(assetId, newIndex), votingRewardPaymentAmount)]
218 +                     }
219 +                 else nil
220 +             let minPeriodLength = getIntegerValue(keyMinPeriodLength)
221 +             let maxPeriodLength = getIntegerValue(keyMaxPeriodLength)
222 +             let checks = [if (if ((periodLength >= minPeriodLength))
223 +                 then (maxPeriodLength >= periodLength)
224 +                 else false)
225 +                 then true
226 +                 else throwErr("invalid periodLength"), if ((getBoolean(keyVerified(assetId)) == unit))
227 +                 then true
228 +                 else throwErr("already verified"), if ((getBoolean(keyVerificationInProgress(assetId)) == unit))
229 +                 then true
230 +                 else throwErr("already in progress"), if ((wxPaymentAmount > (periodLength * feePerBlock)))
231 +                 then true
232 +                 else throwErr("not enough wx for given period"), if ((wxPaymentAmount >= getIntegerValue(keyMinWxMinForSuggestAddAmountRequired)))
233 +                 then true
234 +                 else throwErr("payment less then min for suggest")]
235 +             if ((checks == checks))
236 +                 then {
237 +                     let assetsStoreCreateOrUpdateInv = invoke(assetsStoreContract, "createOrUpdate", [assetId, assetImage, false], nil)
238 +                     if ((assetsStoreCreateOrUpdateInv == assetsStoreCreateOrUpdateInv))
239 +                         then {
240 +                             let votingEndHeight = (height + periodLength)
241 +                             let finalizeCallRewardAmount = valueOrElse(getInteger(keyFinalizeCallRewardAmount), 0)
242 +                             let burnWxAmount = (wxPaymentAmount - finalizeCallRewardAmount)
243 +                             ([IntegerEntry(currentIndexKey, newIndex), BooleanEntry(keyVerificationInProgress(assetId), true), IntegerEntry(keyCurrentVotingHeightStart(assetId, newIndex), height), IntegerEntry(keyPeriodLengthAdd(assetId, newIndex), periodLength), StringEntry(keySuggestIssuer(assetId, newIndex), toString(i.caller)), IntegerEntry(keyVotingEndHeight(assetId, newIndex), votingEndHeight), Burn(wxPaymentAssetId, burnWxAmount)] ++ votingRewardActions)
244 +                             }
245 +                         else throw("Strict value is not equal to itself.")
246 +                     }
247 +                 else throw("Strict value is not equal to itself.")
248 +             }
249 +         else throw("Strict value is not equal to itself.")
250 +     }
251 + 
252 + 
253 + 
254 + @Callable(i)
255 + func suggestRemove (assetId) = {
256 +     let gwxAmountAtNow = getUserGwxAmountAtHeight(toString(i.caller), height)
257 +     let minSuggestRemoveBalance = getIntegerValue(keyMinSuggestRemoveBalance)
258 +     let wxPayment = i.payments[0]
259 +     let wxPaymentAssetId = value(wxPayment.assetId)
260 +     let wxPaymentAmount = value(wxPayment.amount)
261 +     let isVerified = valueOrElse(getBoolean(keyVerified(assetId)), false)
262 +     let checks = [if (isVerified)
263 +         then true
264 +         else throwErr(makeString([assetId, "not verified"], " ")), if ((gwxAmountAtNow >= minSuggestRemoveBalance))
265 +         then true
266 +         else throwErr("not enough gWXes"), if ((wxPaymentAmount >= getIntegerValue(keyWxForSuggestRemoveAmountRequired)))
267 +         then true
268 +         else throwErr("payment less then min for suggest")]
269 +     if ((checks == checks))
270 +         then {
271 +             let currentIndexKey = keyCurrentIndex(assetId)
272 +             let currentIndex = getInteger(currentIndexKey)
273 +             let newIndex = if (isDefined(currentIndex))
274 +                 then (value(currentIndex) + 1)
275 +                 else 0
276 +             let periodLength = valueOrErrorMessage(getInteger(keyPeriodLengthRemove), wrapErr("periodLengthRemove not set"))
277 +             let votingEndHeight = (height + periodLength)
278 + [IntegerEntry(currentIndexKey, newIndex), BooleanEntry(keyDeverificationInProgress(assetId), true), IntegerEntry(keyCurrentVotingHeightStart(assetId, newIndex), height), StringEntry(keySuggestIssuer(assetId, newIndex), toString(i.caller)), IntegerEntry(keyVotingEndHeight(assetId, newIndex), votingEndHeight)]
279 +             }
280 +         else throw("Strict value is not equal to itself.")
281 +     }
282 + 
283 + 
284 + 
285 + @Callable(i)
286 + func vote (assetId,inFavor) = {
287 +     let currentIndexKey = keyCurrentIndex(assetId)
288 +     let currentIndex = valueOrErrorMessage(getInteger(currentIndexKey), wrapErr("voting does not exist"))
289 +     let votingInfo = votingExistChecks(assetId, currentIndex)
290 +     if ((votingInfo == votingInfo))
291 +         then {
292 +             let currentVotingHeightStart = votingInfo._3
293 +             let votingPeriodLenght = votingInfo._4
294 +             let gwxAmountAtEnd = getUserGwxAmountAtHeight(toString(i.caller), (currentVotingHeightStart + votingPeriodLenght))
295 +             let voteKey = keyVote(assetId, currentIndex, i.caller)
296 +             let votingResultKey = keyVotingResult(assetId, currentIndex)
297 +             let checks = [if ((getString(voteKey) == unit))
298 +                 then true
299 +                 else throwErr("You have already voted"), if ((gwxAmountAtEnd > 0))
300 +                 then true
301 +                 else throw("You'll not have gWX at the end of voting")]
302 +             if ((checks == checks))
303 +                 then {
304 +                     let lastVotingValue = valueOrElse(getString(votingResultKey), defaultVotingValue)
305 +                     let lastVotingValueParts = split(lastVotingValue, separator)
306 +                     let newVotingValue = if (inFavor)
307 +                         then votingValue((parseIntValue(lastVotingValueParts[1]) + gwxAmountAtEnd), parseIntValue(lastVotingValueParts[2]))
308 +                         else votingValue(parseIntValue(lastVotingValueParts[1]), (parseIntValue(lastVotingValueParts[2]) + gwxAmountAtEnd))
309 + [StringEntry(voteKey, voteValue(inFavor, gwxAmountAtEnd)), StringEntry(votingResultKey, newVotingValue), BooleanEntry(keyVotingReward(i.caller, assetId, currentIndex), true)]
310 +                     }
311 +                 else throw("Strict value is not equal to itself.")
312 +             }
313 +         else throw("Strict value is not equal to itself.")
314 +     }
315 + 
316 + 
317 + 
318 + @Callable(i)
319 + func cancelVote (assetId) = {
320 +     let currentIndexKey = keyCurrentIndex(assetId)
321 +     let currentIndex = valueOrErrorMessage(getInteger(currentIndexKey), wrapErr("voting does not exist"))
322 +     let voteKey = keyVote(assetId, currentIndex, i.caller)
323 +     let votingResultKey = keyVotingResult(assetId, currentIndex)
324 +     let lastVote = valueOrErrorMessage(getString(voteKey), wrapErr("you have not voted"))
325 +     let lastVoteParts = split(lastVote, separator)
326 +     let inFavor = lastVoteParts[1]
327 +     let gwxAmount = parseIntValue(lastVoteParts[2])
328 +     let votingInfo = votingExistChecks(assetId, currentIndex)
329 +     if ((votingInfo == votingInfo))
330 +         then {
331 +             let checks = [if (if ((inFavor == "true"))
332 +                 then true
333 +                 else (inFavor == "false"))
334 +                 then true
335 +                 else throwErr("invalid vote")]
336 +             if ((checks == checks))
337 +                 then {
338 +                     let lastVotingValue = valueOrElse(getString(votingResultKey), defaultVotingValue)
339 +                     let lastVotingValueParts = split(lastVotingValue, separator)
340 +                     let newVotingResultValue = if ((inFavor == "true"))
341 +                         then votingValue((parseIntValue(lastVotingValueParts[1]) - gwxAmount), parseIntValue(lastVotingValueParts[2]))
342 +                         else votingValue(parseIntValue(lastVotingValueParts[1]), (parseIntValue(lastVotingValueParts[2]) - gwxAmount))
343 + [DeleteEntry(voteKey), StringEntry(votingResultKey, newVotingResultValue), DeleteEntry(keyVotingReward(i.caller, assetId, currentIndex))]
344 +                     }
345 +                 else throw("Strict value is not equal to itself.")
346 +             }
347 +         else throw("Strict value is not equal to itself.")
348 +     }
349 + 
350 + 
351 + 
352 + @Callable(i)
353 + func finalize (assetId) = {
354 +     let verificationInProgress = valueOrElse(getBoolean(keyVerificationInProgress(assetId)), false)
355 +     let deverificationInProgress = valueOrElse(getBoolean(keyDeverificationInProgress(assetId)), false)
356 +     let currentIndexKey = keyCurrentIndex(assetId)
357 +     let currentIndex = valueOrElse(getInteger(currentIndexKey), 0)
358 +     let votingThresholdAdd = valueOrErrorMessage(getInteger(keyVotingThresholdAdd), wrapErr("votingThresholdAdd not set"))
359 +     let votingThresholdRemove = valueOrErrorMessage(getInteger(keyVotingThresholdRemove), wrapErr("votingThresholdRemove not set"))
360 +     let $t01501215451 = if (verificationInProgress)
361 +         then $Tuple3([DeleteEntry(keyVerificationInProgress(assetId)), BooleanEntry(keyVerified(assetId), true)], true, votingThresholdAdd)
362 +         else $Tuple3([DeleteEntry(keyDeverificationInProgress(assetId)), DeleteEntry(keyVerified(assetId))], true, votingThresholdRemove)
363 +     let finalizeVotingActions = $t01501215451._1
364 +     let verified = $t01501215451._2
365 +     let threshold = $t01501215451._3
366 +     let lastVotingValue = valueOrElse(getString(keyVotingResult(assetId, currentIndex)), defaultVotingValue)
367 +     let lastVotingValueParts = split(lastVotingValue, separator)
368 +     let votesFor = parseIntValue(lastVotingValueParts[1])
369 +     let votesAgainst = parseIntValue(lastVotingValueParts[2])
370 +     let votesTotal = (votesFor + votesAgainst)
371 +     let votingEndHeight = valueOrErrorMessage(getInteger(keyVotingEndHeight(assetId, currentIndex)), wrapErr("voting end height not found"))
372 +     let checks = [if (if (verificationInProgress)
373 +         then true
374 +         else deverificationInProgress)
375 +         then true
376 +         else throwErr("nothing to finalize"), if ((height >= votingEndHeight))
377 +         then true
378 +         else throwErr("voting not finished"), if ((votesTotal >= threshold))
379 +         then true
380 +         else throwErr("not enough votes")]
381 +     if ((checks == checks))
382 +         then {
383 +             let finalizeCallRewardAction = if ((votesAgainst > votesFor))
384 +                 then {
385 +                     let setVerifiedInvoke = invoke(assetsStoreContract, "setVerified", [assetId, verified], nil)
386 +                     if ((setVerifiedInvoke == setVerifiedInvoke))
387 +                         then {
388 +                             let finalizeCallRewardAmount = valueOrElse(getInteger(keyFinalizeCallRewardAmount), 0)
389 + [ScriptTransfer(i.caller, finalizeCallRewardAmount, wxAssetId)]
390 +                             }
391 +                         else throw("Strict value is not equal to itself.")
392 +                     }
393 +                 else nil
394 +             (finalizeVotingActions ++ finalizeCallRewardAction)
395 +             }
396 +         else throw("Strict value is not equal to itself.")
397 +     }
398 + 
399 + 
400 + 
401 + @Callable(i)
402 + func claimREADONLY (assetId,index,userAddressStr) = {
403 +     let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid address"))
404 +     let votingRewardAssetIdStr = getString(keyVotingRewardAssetId(assetId, index))
405 +     let rewardAmount = if (isDefined(votingRewardAssetIdStr))
406 +         then calculateReward(userAddress, assetId, index)
407 +         else 0
408 +     $Tuple2(nil, rewardAmount)
409 +     }
410 + 
411 + 
412 + 
413 + @Callable(i)
414 + func claim (assetId,index) = {
415 +     let callerAddress = i.caller
416 +     let claimHistoryKey = keyClaimHistory(callerAddress, assetId, index)
417 +     let claimHistory = getInteger(claimHistoryKey)
418 +     let checks = [if ((claimHistory == unit))
419 +         then true
420 +         else throwErr("already claimed")]
421 +     if ((checks == checks))
422 +         then {
423 +             let rewardAmount = if ((calculateReward(callerAddress, assetId, index) > 0))
424 +                 then calculateReward(callerAddress, assetId, index)
425 +                 else throwErr("nothing to claim")
426 +             let votingRewardAssetIdStr = getString(keyVotingRewardAssetId(assetId, index))
427 +             let rewardAction = if (isDefined(votingRewardAssetIdStr))
428 +                 then {
429 +                     let votingRewardAssetId = fromBase58String(value(votingRewardAssetIdStr))
430 + [ScriptTransfer(callerAddress, rewardAmount, votingRewardAssetId), IntegerEntry(claimHistoryKey, rewardAmount)]
431 +                     }
432 +                 else throwErr("nothing to claim")
433 +             rewardAction
434 +             }
435 +         else throw("Strict value is not equal to itself.")
436 +     }
437 + 
438 + 
439 + @Verifier(tx)
440 + func verify () = {
441 +     let targetPublicKey =     match managerPublicKeyOrUnit() {
442 +         case pk: ByteVector => 
443 +             pk
444 +         case _: Unit => 
445 +             tx.senderPublicKey
446 +         case _ => 
447 +             throw("Match error")
448 +     }
449 +     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
450 +     }
451 +

Old	New		Differences
1		-	# no script
	1	+	{-# STDLIB_VERSION 6 #-}
	2	+	{-# SCRIPT_TYPE ACCOUNT #-}
	3	+	{-# CONTENT_TYPE DAPP #-}
	4	+	let separator = "__"
	5	+
	6	+	let MULT8 = 100000000
	7	+
	8	+	func wrapErr (msg) = makeString(["voting_verified_v2.ride:", msg], " ")
	9	+
	10	+
	11	+	func throwErr (msg) = throw(wrapErr(msg))
	12	+
	13	+
	14	+	func asInt (val) = match val {
	15	+	case valInt: Int =>
	16	+	valInt
	17	+	case _ =>
	18	+	throw("Failed to cast into Integer")
	19	+	}
	20	+
	21	+
	22	+	func getIntegerOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
	23	+
	24	+
	25	+	func getIntegerOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), wrapErr((key + " is not defined")))
	26	+
	27	+
	28	+	func getStringOrEmpty (address,key) = valueOrElse(getString(address, key), "")
	29	+
	30	+
	31	+	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), wrapErr((key + " is not defined")))
	32	+
	33	+
	34	+	let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
	35	+
	36	+	let keyEmissionContract = makeString(["%s", "emissionContract"], separator)
	37	+
	38	+	let keyAssetsStoreContract = makeString(["%s", "assetsStoreContract"], separator)
	39	+
	40	+	let boostingContract = addressFromStringValue(getStringValue(keyBoostingContract))
	41	+
	42	+	let emissionContract = addressFromStringValue(getStringValue(keyEmissionContract))
	43	+
	44	+	let assetsStoreContract = addressFromStringValue(getStringValue(keyAssetsStoreContract))
	45	+
	46	+	let keyEmissionConfig = makeString(["%s", "config"], separator)
	47	+
	48	+	let wxAssetIdStr = split(getStringOrFail(emissionContract, keyEmissionConfig), separator)[1]
	49	+
	50	+	let wxAssetId = fromBase58String(wxAssetIdStr)
	51	+
	52	+	let keyVotingThresholdAdd = makeString(["%s%s", "votingThreshold", "add"], separator)
	53	+
	54	+	let keyVotingThresholdRemove = makeString(["%s%s", "votingThreshold", "remove"], separator)
	55	+
	56	+	func keyPeriodLengthAdd (assetId,index) = makeString(["%s%s%d", "periodLengthAdd", assetId, toString(index)], separator)
	57	+
	58	+
	59	+	let keyPeriodLengthRemove = makeString(["%s", "periodLengthRemove"], separator)
	60	+
	61	+	func keyCurrentVotingHeightStart (assetId,index) = makeString(["%s%s%d", "currentVotingHeightStart", assetId, toString(index)], separator)
	62	+
	63	+
	64	+	func keyVerified (assetId) = makeString(["%s%s", "verified", assetId], separator)
	65	+
	66	+
	67	+	func keyVerificationInProgress (assetId) = makeString(["%s%s%s", "verification", "inProgress", assetId], separator)
	68	+
	69	+
	70	+	func keyDeverificationInProgress (assetId) = makeString(["%s%s%s", "deverification", "inProgress", assetId], separator)
	71	+
	72	+
	73	+	let keyMaxPeriodLength = makeString(["%s", "maxPeriodLength"], separator)
	74	+
	75	+	let keyMinPeriodLength = makeString(["%s", "minPeriodLength"], separator)
	76	+
	77	+	func keyVotingRewardAssetId (assetId,index) = makeString(["%s%s%d", "votingRewardAssetId", assetId, toString(index)], separator)
	78	+
	79	+
	80	+	func keyVotingReward (userAddress,assetId,index) = makeString(["%s%s%s%d", "votingReward", toString(userAddress), assetId, toString(index)], separator)
	81	+
	82	+
	83	+	func keyTotalVotingReward (assetId,index) = makeString(["%s%s%d", "votingReward", assetId, toString(index)], separator)
	84	+
	85	+
	86	+	let keyFinalizeCallRewardAmount = makeString(["%s", "finalizeCallRewardAmount"], separator)
	87	+
	88	+	let keyMinSuggestRemoveBalance = makeString(["%s", "minSuggestRemoveBalance"], separator)
	89	+
	90	+	func keyCurrentIndex (assetId) = makeString(["%s%s", "currentIndex", assetId], separator)
	91	+
	92	+
	93	+	func keyVote (assetId,index,caller) = makeString(["%s%s%d%s", "vote", assetId, toString(index), toString(caller)], separator)
	94	+
	95	+
	96	+	func voteValue (inFavor,gwxAmount) = makeString(["%s%d", toString(inFavor), toString(gwxAmount)], separator)
	97	+
	98	+
	99	+	func keyVotingResult (assetId,index) = makeString(["%s%s%d", "votingResult", assetId, toString(index)], separator)
	100	+
	101	+
	102	+	func votingValue (forAmount,againstAmount) = makeString(["%d%d", toString(forAmount), toString(againstAmount)], separator)
	103	+
	104	+
	105	+	let defaultVotingValue = makeString(["%d%d", "0", "0"], separator)
	106	+
	107	+	func keySuggestIssuer (assetId,index) = makeString(["%s%s%d", "suggestIssuer", assetId, toString(index)], separator)
	108	+
	109	+
	110	+	func keyClaimHistory (userAddress,assetId,index) = makeString(["%s%s%s%d", "history", toString(userAddress), assetId, toString(index)], separator)
	111	+
	112	+
	113	+	func keyVotingEndHeight (assetId,index) = makeString(["%s%s%d", "votingEndHeight", assetId, toString(index)], separator)
	114	+
	115	+
	116	+	let keyFeePerBlock = makeString(["%s", "feePerBlock"], separator)
	117	+
	118	+	let feePerBlock = getIntegerOrFail(this, keyFeePerBlock)
	119	+
	120	+	let keyMinWxMinForSuggestAddAmountRequired = makeString(["%s", "wxMinForSuggestAddAmountRequired"], separator)
	121	+
	122	+	let keyWxForSuggestRemoveAmountRequired = makeString(["%s", "wxForSuggestRemoveAmountRequired"], separator)
	123	+
	124	+	func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
	125	+	let gwxAmount = invoke(boostingContract, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
	126	+	asInt(gwxAmount)
	127	+	}
	128	+
	129	+
	130	+	func keyManagerVaultAddress () = "%s__managerVaultAddress"
	131	+
	132	+
	133	+	func keyManagerPublicKey () = "%s__managerPublicKey"
	134	+
	135	+
	136	+	func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
	137	+	case s: String =>
	138	+	addressFromStringValue(s)
	139	+	case _ =>
	140	+	this
	141	+	}
	142	+
	143	+
	144	+	func managerPublicKeyOrUnit () = {
	145	+	let managerVaultAddress = getManagerVaultAddressOrThis()
	146	+	match getString(managerVaultAddress, keyManagerPublicKey()) {
	147	+	case s: String =>
	148	+	fromBase58String(s)
	149	+	case _: Unit =>
	150	+	unit
	151	+	case _ =>
	152	+	throw("Match error")
	153	+	}
	154	+	}
	155	+
	156	+
	157	+	func votingExistChecks (assetId,currentIndex) = {
	158	+	let verificationInProgress = valueOrElse(getBoolean(keyVerificationInProgress(assetId)), false)
	159	+	let deverificationInProgress = valueOrElse(getBoolean(keyDeverificationInProgress(assetId)), false)
	160	+	let suggestIssuer = valueOrErrorMessage(getString(keySuggestIssuer(assetId, currentIndex)), wrapErr("voting issuer not found"))
	161	+	let currentVotingHeightStart = valueOrErrorMessage(getInteger(keyCurrentVotingHeightStart(assetId, currentIndex)), wrapErr("voting start height not found"))
	162	+	let votingPeriodLenght = if (verificationInProgress)
	163	+	then valueOrErrorMessage(getInteger(keyPeriodLengthAdd(assetId, currentIndex)), wrapErr("voting period length not found"))
	164	+	else value(getInteger(keyPeriodLengthRemove))
	165	+	let checks = [if (if (verificationInProgress)
	166	+	then true
	167	+	else deverificationInProgress)
	168	+	then true
	169	+	else throwErr("no voting in progress"), if (((currentVotingHeightStart + votingPeriodLenght) > height))
	170	+	then true
	171	+	else throwErr("voting expired")]
	172	+	if ((checks == checks))
	173	+	then $Tuple5(verificationInProgress, deverificationInProgress, currentVotingHeightStart, votingPeriodLenght, suggestIssuer)
	174	+	else throw("Strict value is not equal to itself.")
	175	+	}
	176	+
	177	+
	178	+	func calculateReward (voter,assetId,index) = {
	179	+	let voteKey = keyVote(assetId, index, voter)
	180	+	let lastVote = valueOrErrorMessage(getString(voteKey), wrapErr("you have not voted"))
	181	+	let lastVoteParts = split(lastVote, separator)
	182	+	let inFavor = lastVoteParts[1]
	183	+	let rewardAmount = if ((inFavor == "true"))
	184	+	then {
	185	+	let gwxAmount = parseIntValue(lastVoteParts[2])
	186	+	let lastVotingValue = valueOrErrorMessage(getString(keyVotingResult(assetId, index)), wrapErr("voting does not exist"))
	187	+	let lastVotingValueParts = split(lastVotingValue, separator)
	188	+	let totalVotesFor = parseIntValue(lastVotingValueParts[1])
	189	+	let partOfTheTotalVotesX8 = fraction(gwxAmount, MULT8, totalVotesFor)
	190	+	let totalVotingReward = valueOrElse(getInteger(keyTotalVotingReward(assetId, index)), 0)
	191	+	let rewardAmount = fraction(partOfTheTotalVotesX8, totalVotingReward, MULT8, FLOOR)
	192	+	rewardAmount
	193	+	}
	194	+	else 0
	195	+	rewardAmount
	196	+	}
	197	+
	198	+
	199	+	@Callable(i)
	200	+	func suggestAdd (assetId,periodLength,assetImage) = {
	201	+	let info = valueOrErrorMessage(assetInfo(fromBase58String(assetId)), "Invalid asset ID")
	202	+	if ((info == info))
	203	+	then {
	204	+	let currentIndexKey = keyCurrentIndex(assetId)
	205	+	let currentIndex = getInteger(currentIndexKey)
	206	+	let newIndex = if (isDefined(currentIndex))
	207	+	then (value(currentIndex) + 1)
	208	+	else 0
	209	+	let wxPayment = i.payments[0]
	210	+	let wxPaymentAssetId = value(wxPayment.assetId)
	211	+	let wxPaymentAmount = value(wxPayment.amount)
	212	+	let votingRewardActions = if ((size(i.payments) > 1))
	213	+	then {
	214	+	let votingRewardPayment = i.payments[1]
	215	+	let votingRewardPaymentAssetId = toBase58String(value(votingRewardPayment.assetId))
	216	+	let votingRewardPaymentAmount = value(votingRewardPayment.amount)
	217	+	[StringEntry(keyVotingRewardAssetId(assetId, newIndex), votingRewardPaymentAssetId), IntegerEntry(keyTotalVotingReward(assetId, newIndex), votingRewardPaymentAmount)]
	218	+	}
	219	+	else nil
	220	+	let minPeriodLength = getIntegerValue(keyMinPeriodLength)
	221	+	let maxPeriodLength = getIntegerValue(keyMaxPeriodLength)
	222	+	let checks = [if (if ((periodLength >= minPeriodLength))
	223	+	then (maxPeriodLength >= periodLength)
	224	+	else false)
	225	+	then true
	226	+	else throwErr("invalid periodLength"), if ((getBoolean(keyVerified(assetId)) == unit))
	227	+	then true
	228	+	else throwErr("already verified"), if ((getBoolean(keyVerificationInProgress(assetId)) == unit))
	229	+	then true
	230	+	else throwErr("already in progress"), if ((wxPaymentAmount > (periodLength * feePerBlock)))
	231	+	then true
	232	+	else throwErr("not enough wx for given period"), if ((wxPaymentAmount >= getIntegerValue(keyMinWxMinForSuggestAddAmountRequired)))
	233	+	then true
	234	+	else throwErr("payment less then min for suggest")]
	235	+	if ((checks == checks))
	236	+	then {
	237	+	let assetsStoreCreateOrUpdateInv = invoke(assetsStoreContract, "createOrUpdate", [assetId, assetImage, false], nil)
	238	+	if ((assetsStoreCreateOrUpdateInv == assetsStoreCreateOrUpdateInv))
	239	+	then {
	240	+	let votingEndHeight = (height + periodLength)
	241	+	let finalizeCallRewardAmount = valueOrElse(getInteger(keyFinalizeCallRewardAmount), 0)
	242	+	let burnWxAmount = (wxPaymentAmount - finalizeCallRewardAmount)
	243	+	([IntegerEntry(currentIndexKey, newIndex), BooleanEntry(keyVerificationInProgress(assetId), true), IntegerEntry(keyCurrentVotingHeightStart(assetId, newIndex), height), IntegerEntry(keyPeriodLengthAdd(assetId, newIndex), periodLength), StringEntry(keySuggestIssuer(assetId, newIndex), toString(i.caller)), IntegerEntry(keyVotingEndHeight(assetId, newIndex), votingEndHeight), Burn(wxPaymentAssetId, burnWxAmount)] ++ votingRewardActions)
	244	+	}
	245	+	else throw("Strict value is not equal to itself.")
	246	+	}
	247	+	else throw("Strict value is not equal to itself.")
	248	+	}
	249	+	else throw("Strict value is not equal to itself.")
	250	+	}
	251	+
	252	+
	253	+
	254	+	@Callable(i)
	255	+	func suggestRemove (assetId) = {
	256	+	let gwxAmountAtNow = getUserGwxAmountAtHeight(toString(i.caller), height)
	257	+	let minSuggestRemoveBalance = getIntegerValue(keyMinSuggestRemoveBalance)
	258	+	let wxPayment = i.payments[0]
	259	+	let wxPaymentAssetId = value(wxPayment.assetId)
	260	+	let wxPaymentAmount = value(wxPayment.amount)
	261	+	let isVerified = valueOrElse(getBoolean(keyVerified(assetId)), false)
	262	+	let checks = [if (isVerified)
	263	+	then true
	264	+	else throwErr(makeString([assetId, "not verified"], " ")), if ((gwxAmountAtNow >= minSuggestRemoveBalance))
	265	+	then true
	266	+	else throwErr("not enough gWXes"), if ((wxPaymentAmount >= getIntegerValue(keyWxForSuggestRemoveAmountRequired)))
	267	+	then true
	268	+	else throwErr("payment less then min for suggest")]
	269	+	if ((checks == checks))
	270	+	then {
	271	+	let currentIndexKey = keyCurrentIndex(assetId)
	272	+	let currentIndex = getInteger(currentIndexKey)
	273	+	let newIndex = if (isDefined(currentIndex))
	274	+	then (value(currentIndex) + 1)
	275	+	else 0
	276	+	let periodLength = valueOrErrorMessage(getInteger(keyPeriodLengthRemove), wrapErr("periodLengthRemove not set"))
	277	+	let votingEndHeight = (height + periodLength)
	278	+	[IntegerEntry(currentIndexKey, newIndex), BooleanEntry(keyDeverificationInProgress(assetId), true), IntegerEntry(keyCurrentVotingHeightStart(assetId, newIndex), height), StringEntry(keySuggestIssuer(assetId, newIndex), toString(i.caller)), IntegerEntry(keyVotingEndHeight(assetId, newIndex), votingEndHeight)]
	279	+	}
	280	+	else throw("Strict value is not equal to itself.")
	281	+	}
	282	+
	283	+
	284	+
	285	+	@Callable(i)
	286	+	func vote (assetId,inFavor) = {
	287	+	let currentIndexKey = keyCurrentIndex(assetId)
	288	+	let currentIndex = valueOrErrorMessage(getInteger(currentIndexKey), wrapErr("voting does not exist"))
	289	+	let votingInfo = votingExistChecks(assetId, currentIndex)
	290	+	if ((votingInfo == votingInfo))
	291	+	then {
	292	+	let currentVotingHeightStart = votingInfo._3
	293	+	let votingPeriodLenght = votingInfo._4
	294	+	let gwxAmountAtEnd = getUserGwxAmountAtHeight(toString(i.caller), (currentVotingHeightStart + votingPeriodLenght))
	295	+	let voteKey = keyVote(assetId, currentIndex, i.caller)
	296	+	let votingResultKey = keyVotingResult(assetId, currentIndex)
	297	+	let checks = [if ((getString(voteKey) == unit))
	298	+	then true
	299	+	else throwErr("You have already voted"), if ((gwxAmountAtEnd > 0))
	300	+	then true
	301	+	else throw("You'll not have gWX at the end of voting")]
	302	+	if ((checks == checks))
	303	+	then {
	304	+	let lastVotingValue = valueOrElse(getString(votingResultKey), defaultVotingValue)
	305	+	let lastVotingValueParts = split(lastVotingValue, separator)
	306	+	let newVotingValue = if (inFavor)
	307	+	then votingValue((parseIntValue(lastVotingValueParts[1]) + gwxAmountAtEnd), parseIntValue(lastVotingValueParts[2]))
	308	+	else votingValue(parseIntValue(lastVotingValueParts[1]), (parseIntValue(lastVotingValueParts[2]) + gwxAmountAtEnd))
	309	+	[StringEntry(voteKey, voteValue(inFavor, gwxAmountAtEnd)), StringEntry(votingResultKey, newVotingValue), BooleanEntry(keyVotingReward(i.caller, assetId, currentIndex), true)]
	310	+	}
	311	+	else throw("Strict value is not equal to itself.")
	312	+	}
	313	+	else throw("Strict value is not equal to itself.")
	314	+	}
	315	+
	316	+
	317	+
	318	+	@Callable(i)
	319	+	func cancelVote (assetId) = {
	320	+	let currentIndexKey = keyCurrentIndex(assetId)
	321	+	let currentIndex = valueOrErrorMessage(getInteger(currentIndexKey), wrapErr("voting does not exist"))
	322	+	let voteKey = keyVote(assetId, currentIndex, i.caller)
	323	+	let votingResultKey = keyVotingResult(assetId, currentIndex)
	324	+	let lastVote = valueOrErrorMessage(getString(voteKey), wrapErr("you have not voted"))
	325	+	let lastVoteParts = split(lastVote, separator)
	326	+	let inFavor = lastVoteParts[1]
	327	+	let gwxAmount = parseIntValue(lastVoteParts[2])
	328	+	let votingInfo = votingExistChecks(assetId, currentIndex)
	329	+	if ((votingInfo == votingInfo))
	330	+	then {
	331	+	let checks = [if (if ((inFavor == "true"))
	332	+	then true
	333	+	else (inFavor == "false"))
	334	+	then true
	335	+	else throwErr("invalid vote")]
	336	+	if ((checks == checks))
	337	+	then {
	338	+	let lastVotingValue = valueOrElse(getString(votingResultKey), defaultVotingValue)
	339	+	let lastVotingValueParts = split(lastVotingValue, separator)
	340	+	let newVotingResultValue = if ((inFavor == "true"))
	341	+	then votingValue((parseIntValue(lastVotingValueParts[1]) - gwxAmount), parseIntValue(lastVotingValueParts[2]))
	342	+	else votingValue(parseIntValue(lastVotingValueParts[1]), (parseIntValue(lastVotingValueParts[2]) - gwxAmount))
	343	+	[DeleteEntry(voteKey), StringEntry(votingResultKey, newVotingResultValue), DeleteEntry(keyVotingReward(i.caller, assetId, currentIndex))]
	344	+	}
	345	+	else throw("Strict value is not equal to itself.")
	346	+	}
	347	+	else throw("Strict value is not equal to itself.")
	348	+	}
	349	+
	350	+
	351	+
	352	+	@Callable(i)
	353	+	func finalize (assetId) = {
	354	+	let verificationInProgress = valueOrElse(getBoolean(keyVerificationInProgress(assetId)), false)
	355	+	let deverificationInProgress = valueOrElse(getBoolean(keyDeverificationInProgress(assetId)), false)
	356	+	let currentIndexKey = keyCurrentIndex(assetId)
	357	+	let currentIndex = valueOrElse(getInteger(currentIndexKey), 0)
	358	+	let votingThresholdAdd = valueOrErrorMessage(getInteger(keyVotingThresholdAdd), wrapErr("votingThresholdAdd not set"))
	359	+	let votingThresholdRemove = valueOrErrorMessage(getInteger(keyVotingThresholdRemove), wrapErr("votingThresholdRemove not set"))
	360	+	let $t01501215451 = if (verificationInProgress)
	361	+	then $Tuple3([DeleteEntry(keyVerificationInProgress(assetId)), BooleanEntry(keyVerified(assetId), true)], true, votingThresholdAdd)
	362	+	else $Tuple3([DeleteEntry(keyDeverificationInProgress(assetId)), DeleteEntry(keyVerified(assetId))], true, votingThresholdRemove)
	363	+	let finalizeVotingActions = $t01501215451._1
	364	+	let verified = $t01501215451._2
	365	+	let threshold = $t01501215451._3
	366	+	let lastVotingValue = valueOrElse(getString(keyVotingResult(assetId, currentIndex)), defaultVotingValue)
	367	+	let lastVotingValueParts = split(lastVotingValue, separator)
	368	+	let votesFor = parseIntValue(lastVotingValueParts[1])
	369	+	let votesAgainst = parseIntValue(lastVotingValueParts[2])
	370	+	let votesTotal = (votesFor + votesAgainst)
	371	+	let votingEndHeight = valueOrErrorMessage(getInteger(keyVotingEndHeight(assetId, currentIndex)), wrapErr("voting end height not found"))
	372	+	let checks = [if (if (verificationInProgress)
	373	+	then true
	374	+	else deverificationInProgress)
	375	+	then true
	376	+	else throwErr("nothing to finalize"), if ((height >= votingEndHeight))
	377	+	then true
	378	+	else throwErr("voting not finished"), if ((votesTotal >= threshold))
	379	+	then true
	380	+	else throwErr("not enough votes")]
	381	+	if ((checks == checks))
	382	+	then {
	383	+	let finalizeCallRewardAction = if ((votesAgainst > votesFor))
	384	+	then {
	385	+	let setVerifiedInvoke = invoke(assetsStoreContract, "setVerified", [assetId, verified], nil)
	386	+	if ((setVerifiedInvoke == setVerifiedInvoke))
	387	+	then {
	388	+	let finalizeCallRewardAmount = valueOrElse(getInteger(keyFinalizeCallRewardAmount), 0)
	389	+	[ScriptTransfer(i.caller, finalizeCallRewardAmount, wxAssetId)]
	390	+	}
	391	+	else throw("Strict value is not equal to itself.")
	392	+	}
	393	+	else nil
	394	+	(finalizeVotingActions ++ finalizeCallRewardAction)
	395	+	}
	396	+	else throw("Strict value is not equal to itself.")
	397	+	}
	398	+
	399	+
	400	+
	401	+	@Callable(i)
	402	+	func claimREADONLY (assetId,index,userAddressStr) = {
	403	+	let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid address"))
	404	+	let votingRewardAssetIdStr = getString(keyVotingRewardAssetId(assetId, index))
	405	+	let rewardAmount = if (isDefined(votingRewardAssetIdStr))
	406	+	then calculateReward(userAddress, assetId, index)
	407	+	else 0
	408	+	$Tuple2(nil, rewardAmount)
	409	+	}
	410	+
	411	+
	412	+
	413	+	@Callable(i)
	414	+	func claim (assetId,index) = {
	415	+	let callerAddress = i.caller
	416	+	let claimHistoryKey = keyClaimHistory(callerAddress, assetId, index)
	417	+	let claimHistory = getInteger(claimHistoryKey)
	418	+	let checks = [if ((claimHistory == unit))
	419	+	then true
	420	+	else throwErr("already claimed")]
	421	+	if ((checks == checks))
	422	+	then {
	423	+	let rewardAmount = if ((calculateReward(callerAddress, assetId, index) > 0))
	424	+	then calculateReward(callerAddress, assetId, index)
	425	+	else throwErr("nothing to claim")
	426	+	let votingRewardAssetIdStr = getString(keyVotingRewardAssetId(assetId, index))
	427	+	let rewardAction = if (isDefined(votingRewardAssetIdStr))
	428	+	then {
	429	+	let votingRewardAssetId = fromBase58String(value(votingRewardAssetIdStr))
	430	+	[ScriptTransfer(callerAddress, rewardAmount, votingRewardAssetId), IntegerEntry(claimHistoryKey, rewardAmount)]
	431	+	}
	432	+	else throwErr("nothing to claim")
	433	+	rewardAction
	434	+	}
	435	+	else throw("Strict value is not equal to itself.")
	436	+	}
	437	+
	438	+
	439	+	@Verifier(tx)
	440	+	func verify () = {
	441	+	let targetPublicKey = match managerPublicKeyOrUnit() {
	442	+	case pk: ByteVector =>
	443	+	pk
	444	+	case _: Unit =>
	445	+	tx.senderPublicKey
	446	+	case _ =>
	447	+	throw("Match error")
	448	+	}
	449	+	sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
	450	+	}
	451	+

github/deemru/w8io/786bc32 
32.93 ms ◑