tx · hR4KL3FKMExdrcwZyu9Rs5HPqk5HHFkWR4eSusEQsy5

3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE:  -0.02100000 Waves

2023.06.08 18:22 [2613870] smart account 3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE > SELF 0.00000000 Waves

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

View: original | compacted
Prev: NkrWMQqaWLPBDGFc7jHJkpc7UBRE4ZhxE14iidRpbbr
Next: EAmYFzeoPoe26PAmNtN9n9bGCHK2exKVQhnC1HBCmjdL

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

github/deemru/w8io/026f985 
222.04 ms ◑