tx · 5sBtdFLYPfixMZ2Y4UB5CSPpDvH5hypwro9AtRBeCbbp

3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE:  -0.02100000 Waves

2023.05.29 13:16 [2599134] smart account 3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5sBtdFLYPfixMZ2Y4UB5CSPpDvH5hypwro9AtRBeCbbp",
    "fee": 2100000,
    "feeAssetId": null,
    "timestamp": 1685355447434,
    "version": 2,
    "chainId": 84,
    "sender": "3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE",
    "senderPublicKey": "6t3vrhP1jCmG7CeKBmL8hUibtdP3cMXGC2XtPYEPPC5w",
    "proofs": [
        "4G5wodX5a7EYe29xxHuneq2j1gGiABAjNpai3646guZHiBeyrgeL8YGkUZXmn29ZNGXkR7ZF37ZHtTiraPBnFw1i"
    ],
    "script": "base64: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",
    "height": 2599134,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: Bc95Do6JTLtq5bwhfkTyPGVPfHCKgJefqJ1gTkckU3wr
Next: Hcb2NQsvWn5HWzuRASG7VaqGpEKtAvtJvqyAgA3w8yjy

Diff: 
Old
New
Differences
124
124
 
func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
125
125
 
    let gwxAmount = invoke(boostingContract, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
126
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
+
    }
127
154
 
    }
128
155
 
129
156
 
330
357
 
    let currentIndex = valueOrElse(getInteger(currentIndexKey), 0)
331
358
 
    let votingThresholdAdd = valueOrErrorMessage(getInteger(keyVotingThresholdAdd), wrapErr("votingThresholdAdd not set"))
332
359
 
    let votingThresholdRemove = valueOrErrorMessage(getInteger(keyVotingThresholdRemove), wrapErr("votingThresholdRemove not set"))
333
-
    let $t01424414683 = if (verificationInProgress)
360
+
    let $t01478315222 = if (verificationInProgress)
334
361
 
        then $Tuple3([DeleteEntry(keyVerificationInProgress(assetId)), BooleanEntry(keyVerified(assetId), true)], true, votingThresholdAdd)
335
362
 
        else $Tuple3([DeleteEntry(keyDeverificationInProgress(assetId)), DeleteEntry(keyVerified(assetId))], true, votingThresholdRemove)
336
-
    let finalizeVotingActions = $t01424414683._1
337
-
    let verified = $t01424414683._2
338
-
    let threshold = $t01424414683._3
363
+
    let finalizeVotingActions = $t01478315222._1
364
+
    let verified = $t01478315222._2
365
+
    let threshold = $t01478315222._3
339
366
 
    let lastVotingValue = valueOrElse(getString(keyVotingResult(assetId, currentIndex)), defaultVotingValue)
340
367
 
    let lastVotingValueParts = split(lastVotingValue, separator)
341
368
 
    let votesFor = parseIntValue(lastVotingValueParts[1])
409
436
 
    }
410
437
 
411
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
+

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