tx · 7P2MLKwxfFVKYpVVkAFLmveKdf7Pmwu2xpMjmPXGqSQS

3My4jcWufVEgwTMesfeETVZdHyGGFZ5m7FP:  -0.02300000 Waves

2023.03.14 17:28 [2489837] smart account 3My4jcWufVEgwTMesfeETVZdHyGGFZ5m7FP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7P2MLKwxfFVKYpVVkAFLmveKdf7Pmwu2xpMjmPXGqSQS",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1678804178745,
    "version": 2,
    "chainId": 84,
    "sender": "3My4jcWufVEgwTMesfeETVZdHyGGFZ5m7FP",
    "senderPublicKey": "G91RK9gjQQJYqGVA36j96cX7zMx1NgmT6LF3B398M1ur",
    "proofs": [
        "uGCNHQyZC3qUXXypvVH9eiEr5uHnKM2W5oYWoEGsnNfZY8wg7SRGQK2N8X96a7cXuQ8joXHrGYepVYPhMWvyDmo"
    ],
    "script": "base64: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",
    "height": 2489837,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: EfkmmYpquZLk6qsP3qYP5MnxXyLuZjmfpKp3N681YRCP
Next: 8E2kqQP1pZhavFCGjiN96VVcVEwbA5gAuGjQfbr2BsNS

Diff: 
Old
New
Differences
60
60
 
61
61
 
62
62
 
func keyInList (pool) = {
63
-
    let $t025262566 = pool
64
-
    let amountAssetId = $t025262566._1
65
-
    let priceAssetId = $t025262566._2
63
+
    let $t024632503 = pool
64
+
    let amountAssetId = $t024632503._1
65
+
    let priceAssetId = $t024632503._2
66
66
 
    makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
67
67
 
    }
68
68
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 5 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let separator = "__"
5
5
 
6
6
 
let keyFeeAmount = makeString(["%s", "fee"], separator)
7
7
 
8
8
 
let keyUsdnAssetId = makeString(["%s", "usdnAssetId"], separator)
9
9
 
10
10
 
let keyEpochLength = makeString(["%s", "epochLength"], separator)
11
11
 
12
12
 
let keyFinalizeReward = makeString(["%s", "finalizeReward"], separator)
13
13
 
14
14
 
let keyWxAssetId = makeString(["%s", "wxAssetId"], separator)
15
15
 
16
16
 
let keyAssetsStoreContract = makeString(["%s", "assetsStoreContract"], separator)
17
17
 
18
18
 
let keyUserPoolContract = makeString(["%s", "userPoolContract"], separator)
19
19
 
20
20
 
let keyEmissionContract = makeString(["%s", "emissionContract"], separator)
21
21
 
22
22
 
let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
23
23
 
24
24
 
let keyFactoryContract = makeString(["%s", "factoryContract"], separator)
25
25
 
26
26
 
let keyVotingEmissionContract = makeString(["%s", "votingEmissionContract"], separator)
27
27
 
28
28
 
let keyThreshold = makeString(["%s", "votingThreshold"], separator)
29
29
 
30
30
 
func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), (key + " is not defined"))
31
31
 
32
32
 
33
33
 
func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), (key + " is not defined"))
34
34
 
35
35
 
36
36
 
func keyInListAssetId (amountAssetId,priceAssetId) = makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
37
37
 
38
38
 
39
39
 
func keySuggestIndex (amountAssetId,priceAssetId) = makeString(["%s%s%s", "suggestIndex", amountAssetId, priceAssetId], separator)
40
40
 
41
41
 
42
42
 
func keyStartHeight (amountAssetId,priceAssetId,suggestIndex) = makeString(["%s%s%s%d", "startHeight", amountAssetId, priceAssetId, toString(suggestIndex)], separator)
43
43
 
44
44
 
45
45
 
func keyVotingResult (amountAssetId,priceAssetId,suggestIndex) = makeString(["%s%s%s%d", "votingResult", amountAssetId, priceAssetId, toString(suggestIndex)], separator)
46
46
 
47
47
 
48
48
 
func totalVotes (totalYes,totalNo) = makeString(["%d%d", totalYes, totalNo], separator)
49
49
 
50
50
 
51
51
 
func keyVote (amountAssetId,priceAssetId,suggestIndex,voterAddress) = makeString(["%s%s%s%d%s", "vote", amountAssetId, priceAssetId, toString(suggestIndex), voterAddress], separator)
52
52
 
53
53
 
54
54
 
func keyVoteValue (gwxAmount,vote) = {
55
55
 
    let key = if (vote)
56
56
 
        then makeString(["%d%s", gwxAmount, "yes"], separator)
57
57
 
        else makeString(["%d%s", gwxAmount, "no"], separator)
58
58
 
    key
59
59
 
    }
60
60
 
61
61
 
62
62
 
func keyInList (pool) = {
63
-
    let $t025262566 = pool
64
-
    let amountAssetId = $t025262566._1
65
-
    let priceAssetId = $t025262566._2
63
+
    let $t024632503 = pool
64
+
    let amountAssetId = $t024632503._1
65
+
    let priceAssetId = $t024632503._2
66
66
 
    makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
67
67
 
    }
68
68
 
69
69
 
70
70
 
func keyManagerPublicKey () = "%s__managerPublicKey"
71
71
 
72
72
 
73
73
 
func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
74
74
 
75
75
 
76
76
 
let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract))
77
77
 
78
78
 
let boostingContract = addressFromStringValue(getStringOrFail(keyBoostingContract))
79
79
 
80
80
 
let emissionContract = addressFromStringValue(getStringOrFail(keyEmissionContract))
81
81
 
82
82
 
let factoryContract = addressFromStringValue(getStringOrFail(keyFactoryContract))
83
83
 
84
84
 
let userPoolContract = addressFromStringValue(getStringOrFail(keyUserPoolContract))
85
85
 
86
86
 
let votingEmissionContract = addressFromStringValue(getStringOrFail(keyVotingEmissionContract))
87
87
 
88
88
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
89
89
 
    case s: String => 
90
90
 
        fromBase58String(s)
91
91
 
    case _: Unit => 
92
92
 
        unit
93
93
 
    case _ => 
94
94
 
        throw("Match error")
95
95
 
}
96
96
 
97
97
 
98
98
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
99
99
 
    case s: String => 
100
100
 
        fromBase58String(s)
101
101
 
    case _: Unit => 
102
102
 
        unit
103
103
 
    case _ => 
104
104
 
        throw("Match error")
105
105
 
}
106
106
 
107
107
 
108
108
 
func isManager (i) = match managerPublicKeyOrUnit() {
109
109
 
    case pk: ByteVector => 
110
110
 
        (i.callerPublicKey == pk)
111
111
 
    case _: Unit => 
112
112
 
        (i.caller == this)
113
113
 
    case _ => 
114
114
 
        throw("Match error")
115
115
 
}
116
116
 
117
117
 
118
118
 
func mustManager (i) = if (isManager(i))
119
119
 
    then true
120
120
 
    else throw("permission denied")
121
121
 
122
122
 
123
123
 
func asInt (val) = match val {
124
124
 
    case valInt: Int => 
125
125
 
        valInt
126
126
 
    case _ => 
127
127
 
        throw("failed to cast into Integer")
128
128
 
}
129
129
 
130
130
 
131
131
 
@Callable(i)
132
132
 
func constructor (assetsStoreContractPrm,boostingContractPrm,emissionContractPrm,factoryContractPrm,userPoolContractPrm,votingEmissionContractPrm,feeAmountPrm,wxAssetIdPrm,votingDurationPrm,usdnAssetIdPrm,finalizeRewardPrm) = {
133
133
 
    let checks = [mustManager(i), if (isDefined(addressFromString(assetsStoreContractPrm)))
134
134
 
        then true
135
135
 
        else throw("Invalid asset_store contract address"), if (isDefined(addressFromString(boostingContractPrm)))
136
136
 
        then true
137
137
 
        else throw("Invalid boosting contract address"), if (isDefined(addressFromString(userPoolContractPrm)))
138
138
 
        then true
139
139
 
        else throw("Invalid user_pools contract address"), if (isDefined(addressFromString(emissionContractPrm)))
140
140
 
        then true
141
141
 
        else throw("Invalid emission contract address"), if (isDefined(addressFromString(factoryContractPrm)))
142
142
 
        then true
143
143
 
        else throw("Invalid factory contract address"), if ((feeAmountPrm >= 0))
144
144
 
        then true
145
145
 
        else throw("Invalid fee amount"), if ((votingDurationPrm > 0))
146
146
 
        then true
147
147
 
        else throw("Invalid voting duration"), if ((finalizeRewardPrm >= 0))
148
148
 
        then true
149
149
 
        else throw("Invalid finalize reward"), if (isDefined(assetInfo(fromBase58String(wxAssetIdPrm))))
150
150
 
        then true
151
151
 
        else throw("Invalid WX asset ID"), if (isDefined(assetInfo(fromBase58String(usdnAssetIdPrm))))
152
152
 
        then true
153
153
 
        else throw("Invalid USDN asset ID")]
154
154
 
    if ((checks == checks))
155
155
 
        then $Tuple2([StringEntry(keyAssetsStoreContract, assetsStoreContractPrm), StringEntry(keyBoostingContract, boostingContractPrm), StringEntry(keyEmissionContract, emissionContractPrm), StringEntry(keyFactoryContract, factoryContractPrm), StringEntry(keyUserPoolContract, userPoolContractPrm), StringEntry(keyVotingEmissionContract, votingEmissionContractPrm), IntegerEntry(keyFeeAmount, feeAmountPrm), IntegerEntry(keyEpochLength, votingDurationPrm), IntegerEntry(keyFinalizeReward, finalizeRewardPrm), StringEntry(keyWxAssetId, wxAssetIdPrm), StringEntry(keyUsdnAssetId, usdnAssetIdPrm)], unit)
156
156
 
        else throw("Strict value is not equal to itself.")
157
157
 
    }
158
158
 
159
159
 
160
160
 
161
161
 
@Callable(i)
162
162
 
func constructorV2 (threshold) = {
163
163
 
    let checks = [mustManager(i), if ((threshold > 0))
164
164
 
        then true
165
165
 
        else throw("invalid threshold")]
166
166
 
    if ((checks == checks))
167
167
 
        then $Tuple2([IntegerEntry(keyThreshold, threshold)], unit)
168
168
 
        else throw("Strict value is not equal to itself.")
169
169
 
    }
170
170
 
171
171
 
172
172
 
173
173
 
@Callable(i)
174
174
 
func suggest (amountAssetId,priceAssetId) = {
175
175
 
    let pool = $Tuple2(amountAssetId, priceAssetId)
176
176
 
    let payment = value(i.payments[0])
177
177
 
    let checkAmountAsset = if ((amountAssetId == "WAVES"))
178
178
 
        then unit
179
179
 
        else {
180
180
 
            let info = valueOrErrorMessage(assetInfo(fromBase58String(amountAssetId)), "invalid amountAssetId ID")
181
181
 
            if ((info.scripted == false))
182
182
 
                then true
183
183
 
                else throw("asset is smart")
184
184
 
            }
185
185
 
    if ((checkAmountAsset == checkAmountAsset))
186
186
 
        then {
187
187
 
            let checks = [if ((toBase58String(value(payment.assetId)) == value(getString(keyWxAssetId))))
188
188
 
                then true
189
189
 
                else throw("invalid fee asset"), if ((payment.amount == value(getInteger(keyFeeAmount))))
190
190
 
                then true
191
191
 
                else throw("invalid fee amount"), if ((getInteger(keyInListAssetId(amountAssetId, priceAssetId)) == unit))
192
192
 
                then true
193
193
 
                else throw("already in voting list"), if (!(valueOrElse(getBoolean(votingEmissionContract, keyInList(pool)), false)))
194
194
 
                then true
195
195
 
                else throw("pool is in emission voting list")]
196
196
 
            if ((checks == checks))
197
197
 
                then {
198
198
 
                    let ensureActive =                     match invoke(userPoolContract, "statusREADONLY", [amountAssetId, priceAssetId], nil) {
199
199
 
                        case s: String => 
200
200
 
                            if ((s == "active"))
201
201
 
                                then true
202
202
 
                                else throw("user pool is not active")
203
203
 
                        case _ => 
204
204
 
                            throw("user pool is not active")
205
205
 
                    }
206
206
 
                    if ((ensureActive == ensureActive))
207
207
 
                        then {
208
208
 
                            let ensureAmountAssetVerified = if (isManager(i))
209
209
 
                                then unit
210
210
 
                                else {
211
211
 
                                    let inv =                                     match invoke(assetsStoreContract, "isVerifiedREADONLY", [amountAssetId], nil) {
212
212
 
                                        case b: Boolean => 
213
213
 
                                            if (b)
214
214
 
                                                then true
215
215
 
                                                else throw("asset is not verified")
216
216
 
                                        case _ => 
217
217
 
                                            throw("asset is not verified")
218
218
 
                                    }
219
219
 
                                    if ((inv == inv))
220
220
 
                                        then unit
221
221
 
                                        else throw("Strict value is not equal to itself.")
222
222
 
                                    }
223
223
 
                            if ((ensureAmountAssetVerified == ensureAmountAssetVerified))
224
224
 
                                then {
225
225
 
                                    let burnFeeInv = invoke(emissionContract, "burn", nil, [AttachedPayment(payment.assetId, payment.amount)])
226
226
 
                                    if ((burnFeeInv == burnFeeInv))
227
227
 
                                        then {
228
228
 
                                            let newSuggestIndex =                                             match getInteger(keySuggestIndex(amountAssetId, priceAssetId)) {
229
229
 
                                                case int: Int => 
230
230
 
                                                    (int + 1)
231
231
 
                                                case _ => 
232
232
 
                                                    0
233
233
 
                                            }
234
234
 
                                            $Tuple2([IntegerEntry(keyInListAssetId(amountAssetId, priceAssetId), newSuggestIndex), IntegerEntry(keyStartHeight(amountAssetId, priceAssetId, newSuggestIndex), height), StringEntry(keyVotingResult(amountAssetId, priceAssetId, newSuggestIndex), totalVotes("0", "0")), IntegerEntry(keySuggestIndex(amountAssetId, priceAssetId), newSuggestIndex)], unit)
235
235
 
                                            }
236
236
 
                                        else throw("Strict value is not equal to itself.")
237
237
 
                                    }
238
238
 
                                else throw("Strict value is not equal to itself.")
239
239
 
                            }
240
240
 
                        else throw("Strict value is not equal to itself.")
241
241
 
                    }
242
242
 
                else throw("Strict value is not equal to itself.")
243
243
 
            }
244
244
 
        else throw("Strict value is not equal to itself.")
245
245
 
    }
246
246
 
247
247
 
248
248
 
249
249
 
@Callable(i)
250
250
 
func vote (amountAssetId,priceAssetId,inFavor) = {
251
251
 
    let suggestIndex = value(getInteger(keyInListAssetId(amountAssetId, priceAssetId)))
252
252
 
    let votingFinishHeight = (value(getInteger(keyStartHeight(amountAssetId, priceAssetId, suggestIndex))) + value(getInteger(keyEpochLength)))
253
253
 
    let checks = [if (isDefined(getInteger(keyInListAssetId(amountAssetId, priceAssetId))))
254
254
 
        then true
255
255
 
        else throw("the token isn't on the voting list"), if ((votingFinishHeight > height))
256
256
 
        then true
257
257
 
        else throw("too late to vote")]
258
258
 
    if ((checks == checks))
259
259
 
        then {
260
260
 
            let gwxAmount = invoke(boostingContract, "getUserGwxAmountAtHeightREADONLY", [toString(i.caller), votingFinishHeight], nil)
261
261
 
            let notZero = if ((asInt(gwxAmount) > 0))
262
262
 
                then true
263
263
 
                else throw("you don't have gwx")
264
264
 
            if ((notZero == notZero))
265
265
 
                then {
266
266
 
                    let vote =                     match getString(keyVote(amountAssetId, priceAssetId, suggestIndex, toString(i.caller))) {
267
267
 
                        case s: String => 
268
268
 
                            let vote = split(s, separator)
269
269
 
                            let voteValue = vote[1]
270
270
 
                            let voteType = vote[2]
271
271
 
                            let isVoteTypeSimilar = if (if ((voteType == "yes"))
272
272
 
                                then (inFavor == true)
273
273
 
                                else false)
274
274
 
                                then true
275
275
 
                                else if ((voteType == "no"))
276
276
 
                                    then (inFavor == false)
277
277
 
                                    else false
278
278
 
                            let isVoteValueSimilar = if (isVoteTypeSimilar)
279
279
 
                                then (asInt(gwxAmount) == parseIntValue(voteValue))
280
280
 
                                else false
281
281
 
                            let isNewVoteSimilar = if (if (isVoteTypeSimilar)
282
282
 
                                then isVoteValueSimilar
283
283
 
                                else false)
284
284
 
                                then throw("you already voted")
285
285
 
                                else invoke(this, "cancelVote", [amountAssetId, priceAssetId], nil)
286
286
 
                            isNewVoteSimilar
287
287
 
                        case u: Unit => 
288
288
 
                            u
289
289
 
                        case _ => 
290
290
 
                            throw("Match error")
291
291
 
                    }
292
292
 
                    if ((vote == vote))
293
293
 
                        then {
294
294
 
                            let votingResult = split(value(getString(keyVotingResult(amountAssetId, priceAssetId, suggestIndex))), separator)
295
295
 
                            let positiveVotes = votingResult[1]
296
296
 
                            let negativeVotes = votingResult[2]
297
297
 
                            let newPositiveAndNegativeVotes = if (inFavor)
298
298
 
                                then {
299
299
 
                                    let newPositiveVotes = (parseIntValue(positiveVotes) + asInt(gwxAmount))
300
300
 
[toString(newPositiveVotes), negativeVotes]
301
301
 
                                    }
302
302
 
                                else {
303
303
 
                                    let newNegativeVotes = (parseIntValue(negativeVotes) + asInt(gwxAmount))
304
304
 
[positiveVotes, toString(newNegativeVotes)]
305
305
 
                                    }
306
306
 
                            let voteKey = keyVote(amountAssetId, priceAssetId, suggestIndex, toString(i.caller))
307
307
 
                            let voteValue = keyVoteValue(toString(asInt(gwxAmount)), inFavor)
308
308
 
                            $Tuple2([StringEntry(keyVotingResult(amountAssetId, priceAssetId, suggestIndex), totalVotes(newPositiveAndNegativeVotes[0], newPositiveAndNegativeVotes[1])), StringEntry(voteKey, voteValue)], unit)
309
309
 
                            }
310
310
 
                        else throw("Strict value is not equal to itself.")
311
311
 
                    }
312
312
 
                else throw("Strict value is not equal to itself.")
313
313
 
            }
314
314
 
        else throw("Strict value is not equal to itself.")
315
315
 
    }
316
316
 
317
317
 
318
318
 
319
319
 
@Callable(i)
320
320
 
func cancelVote (amountAssetId,priceAssetId) = {
321
321
 
    let userAddress = if ((i.caller == this))
322
322
 
        then toString(i.originCaller)
323
323
 
        else toString(i.caller)
324
324
 
    let suggestIndex = value(getInteger(keyInListAssetId(amountAssetId, priceAssetId)))
325
325
 
    let checks = [if (isDefined(getString(keyVotingResult(amountAssetId, priceAssetId, suggestIndex))))
326
326
 
        then true
327
327
 
        else throw("no vote for assets pair")]
328
328
 
    if ((checks == checks))
329
329
 
        then {
330
330
 
            let vote = split(value(getString(keyVote(amountAssetId, priceAssetId, suggestIndex, userAddress))), separator)
331
331
 
            let voteValue = vote[1]
332
332
 
            let voteType = vote[2]
333
333
 
            let votingResult = split(value(getString(keyVotingResult(amountAssetId, priceAssetId, suggestIndex))), separator)
334
334
 
            let positiveVotes = votingResult[1]
335
335
 
            let negativeVotes = votingResult[2]
336
336
 
            let actions = if ((voteType == "yes"))
337
337
 
                then {
338
338
 
                    let newPositiveVotes = (parseIntValue(positiveVotes) - parseIntValue(voteValue))
339
339
 
                    $Tuple2([StringEntry(keyVotingResult(amountAssetId, priceAssetId, suggestIndex), totalVotes(toString(newPositiveVotes), negativeVotes)), DeleteEntry(keyVote(amountAssetId, priceAssetId, suggestIndex, userAddress))], unit)
340
340
 
                    }
341
341
 
                else {
342
342
 
                    let newNegativeVotes = (parseIntValue(negativeVotes) - parseIntValue(voteValue))
343
343
 
                    $Tuple2([StringEntry(keyVotingResult(amountAssetId, priceAssetId, suggestIndex), totalVotes(positiveVotes, toString(newNegativeVotes))), DeleteEntry(keyVote(amountAssetId, priceAssetId, suggestIndex, userAddress))], unit)
344
344
 
                    }
345
345
 
            actions
346
346
 
            }
347
347
 
        else throw("Strict value is not equal to itself.")
348
348
 
    }
349
349
 
350
350
 
351
351
 
352
352
 
@Callable(i)
353
353
 
func setFee (newFee) = {
354
354
 
    let checks = [mustManager(i)]
355
355
 
    if ((checks == checks))
356
356
 
        then [IntegerEntry(keyFeeAmount, newFee)]
357
357
 
        else throw("Strict value is not equal to itself.")
358
358
 
    }
359
359
 
360
360
 
361
361
 
362
362
 
@Callable(i)
363
363
 
func setThreshold (newThreshold) = {
364
364
 
    let checks = [mustManager(i), if ((newThreshold > 0))
365
365
 
        then true
366
366
 
        else throw("invalid threshold")]
367
367
 
    if ((checks == checks))
368
368
 
        then $Tuple2([IntegerEntry(keyThreshold, newThreshold)], unit)
369
369
 
        else throw("Strict value is not equal to itself.")
370
370
 
    }
371
371
 
372
372
 
373
373
 
374
374
 
@Callable(i)
375
375
 
func finalize (amountAssetId,priceAssetId) = {
376
376
 
    let suggestIndex = value(getInteger(keyInListAssetId(amountAssetId, priceAssetId)))
377
377
 
    let votingFinishHeight = (value(getInteger(keyStartHeight(amountAssetId, priceAssetId, suggestIndex))) + value(getInteger(keyEpochLength)))
378
378
 
    let checks = [if (isDefined(getInteger(keyInListAssetId(amountAssetId, priceAssetId))))
379
379
 
        then true
380
380
 
        else throw("no assets pair"), if ((height >= votingFinishHeight))
381
381
 
        then true
382
382
 
        else throw("insufficient height for completion")]
383
383
 
    if ((checks == checks))
384
384
 
        then {
385
385
 
            let votingResult = split(value(getString(keyVotingResult(amountAssetId, priceAssetId, suggestIndex))), separator)
386
386
 
            let positiveVotes = parseIntValue(votingResult[1])
387
387
 
            let negativeVotes = parseIntValue(votingResult[2])
388
388
 
            let allVotes = (positiveVotes + negativeVotes)
389
389
 
            let threshold = getIntOrFail(keyThreshold)
390
390
 
            let actions = if (if ((allVotes >= threshold))
391
391
 
                then (positiveVotes > negativeVotes)
392
392
 
                else false)
393
393
 
                then {
394
394
 
                    let res = invoke(factoryContract, "setWxEmissionPoolLabel", [amountAssetId, priceAssetId], nil)
395
395
 
                    if ((res == res))
396
396
 
                        then {
397
397
 
                            let votingEmissionInv = invoke(votingEmissionContract, "create", [amountAssetId, priceAssetId], nil)
398
398
 
                            if ((votingEmissionInv == votingEmissionInv))
399
399
 
                                then $Tuple2([DeleteEntry(keyInListAssetId(amountAssetId, priceAssetId))], unit)
400
400
 
                                else throw("Strict value is not equal to itself.")
401
401
 
                            }
402
402
 
                        else throw("Strict value is not equal to itself.")
403
403
 
                    }
404
404
 
                else $Tuple2([DeleteEntry(keyInListAssetId(amountAssetId, priceAssetId))], unit)
405
405
 
            actions
406
406
 
            }
407
407
 
        else throw("Strict value is not equal to itself.")
408
408
 
    }
409
409
 
410
410
 
411
411
 
412
412
 
@Callable(i)
413
413
 
func setManager (pendingManagerPublicKey) = {
414
414
 
    let checkCaller = mustManager(i)
415
415
 
    if ((checkCaller == checkCaller))
416
416
 
        then {
417
417
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
418
418
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
419
419
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
420
420
 
                else throw("Strict value is not equal to itself.")
421
421
 
            }
422
422
 
        else throw("Strict value is not equal to itself.")
423
423
 
    }
424
424
 
425
425
 
426
426
 
427
427
 
@Callable(i)
428
428
 
func confirmManager () = {
429
429
 
    let pm = pendingManagerPublicKeyOrUnit()
430
430
 
    let hasPM = if (isDefined(pm))
431
431
 
        then true
432
432
 
        else throw("no pending manager")
433
433
 
    if ((hasPM == hasPM))
434
434
 
        then {
435
435
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
436
436
 
                then true
437
437
 
                else throw("you are not pending manager")
438
438
 
            if ((checkPM == checkPM))
439
439
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
440
440
 
                else throw("Strict value is not equal to itself.")
441
441
 
            }
442
442
 
        else throw("Strict value is not equal to itself.")
443
443
 
    }
444
444
 
445
445
 
446
446
 
@Verifier(tx)
447
447
 
func verify () = {
448
448
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
449
449
 
        case pk: ByteVector => 
450
450
 
            pk
451
451
 
        case _: Unit => 
452
452
 
            tx.senderPublicKey
453
453
 
        case _ => 
454
454
 
            throw("Match error")
455
455
 
    }
456
456
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
457
457
 
    }
458
458
 

github/deemru/w8io/169f3d6 
54.04 ms ◑