2022.07.04 12:17 [3190324] smart account 3PEGyZ9UqeC3coXzRt4DGJQiWaMdH2JShFG > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9uEVWn6WNGxttdfVkZRbJig1FaioZ4C11iqxsJnffb22",
    "fee": 2200000,
    "feeAssetId": null,
    "timestamp": 1656923333402,
    "version": 1,
    "sender": "3PEGyZ9UqeC3coXzRt4DGJQiWaMdH2JShFG",
    "senderPublicKey": "DQtGXvog3Y6B9bxto8pajLFKjsTX8tBjkDi6RRhtP8X5",
    "proofs": [
        "3cZeCSaJdkUcG2obLHAotw6FxDb5KkTJawSruiQzSAtuxQLJTVDniC3KR5CVqYvKDTvWz6J98id1ZyqEYiMPGMSF"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3190324,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: DVma55jdB8xfWRP5CNCcm9Xs4fjnFm2g2ANBadd61AYY

Full: 

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