tx · J7CtRfvmR6nxAmVpGH798a1n9V3WL4HU17ZVEzPLqXak

3N1Epwa6GQuTQr2K9WzeUcqSFCdERwuvL5T:  -0.01400000 Waves

2022.04.29 15:59 [2029795] smart account 3N1Epwa6GQuTQr2K9WzeUcqSFCdERwuvL5T > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "J7CtRfvmR6nxAmVpGH798a1n9V3WL4HU17ZVEzPLqXak",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1651237181832,
    "version": 1,
    "sender": "3N1Epwa6GQuTQr2K9WzeUcqSFCdERwuvL5T",
    "senderPublicKey": "7iXEgsFNsnbLZ3ca4tmz8jffnyxMu9keuBV6CuQPJLuA",
    "proofs": [
        "5EZEVLxdjSEpKZExrLeRyWYD4G9EBuYbmUYTJ4H6pF2M5VLSBLps4vcNqTsE9sf82TmBEtSyF4jCZw2AJYBGQeQJ"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2029795,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

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

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 keyVotingDuration = makeString(["%s", "epochLength"], separator)
11+
12+let keyVotingThreshold = makeString(["%s", "votingThreshold"], 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+func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), (key + " is not defined"))
25+
26+
27+func keyInListAssetId (amountAssetId,priceAssetId) = makeString([("%s%s%s" + "inList"), amountAssetId, priceAssetId], separator)
28+
29+
30+func keyStartHeight (amountAssetId,priceAssetId) = makeString([("%s%s%s" + "startHeight"), amountAssetId, priceAssetId], separator)
31+
32+
33+func keyVotingResult (amountAssetId,priceAssetId) = makeString(["%s%s%s", "votingResult", amountAssetId, priceAssetId], separator)
34+
35+
36+func keyVote (amountAssetId,priceAssetId,voterAddress) = makeString(["%s%s%s%s", "vote", amountAssetId, priceAssetId, voterAddress], separator)
37+
38+
39+func keyManagerPublicKey () = "%s__managerPublicKey"
40+
41+
42+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
43+
44+
45+let emissionContract = addressFromStringValue(getStringOrFail(keyEmissionContract))
46+
47+let userPoolContract = addressFromStringValue(getStringOrFail(keyuserPoolContract))
48+
49+let boostingContract = addressFromStringValue(getStringOrFail(keyBoostingContract))
50+
51+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
52+    case s: String => 
53+        fromBase58String(s)
54+    case _: Unit => 
55+        unit
56+    case _ => 
57+        throw("Match error")
58+}
59+
60+
61+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
62+    case s: String => 
63+        fromBase58String(s)
64+    case _: Unit => 
65+        unit
66+    case _ => 
67+        throw("Match error")
68+}
69+
70+
71+func mustManager (i) = {
72+    let pd = throw("Permission denied")
73+    match managerPublicKeyOrUnit() {
74+        case pk: ByteVector => 
75+            if ((i.callerPublicKey == pk))
76+                then true
77+                else pd
78+        case _: Unit => 
79+            if ((i.caller == this))
80+                then true
81+                else pd
82+        case _ => 
83+            throw("Match error")
84+    }
85+    }
86+
87+
88+func asInt (val) = match val {
89+    case valInt: Int => 
90+        valInt
91+    case _ => 
92+        throw("Failed to cast into Integer")
93+}
94+
95+
96+@Callable(i)
97+func constructor (assetsStoreContractPrm,userPoolContractPrm,boostingContractPrm,emissionContractPrm,feeAmountPrm,wxAssetIdPrm,votingThresholdPrm,votingDurationPrm,usdnAssetIdPrm) = {
98+    let checks = [if (mustManager(i))
99+        then true
100+        else throw("Must manager"), if (isDefined(addressFromString(assetsStoreContractPrm)))
101+        then true
102+        else throw("Invalid asset_store contract address"), if (isDefined(addressFromString(boostingContractPrm)))
103+        then true
104+        else throw("Invalid boosting contract address"), if (isDefined(addressFromString(userPoolContractPrm)))
105+        then true
106+        else throw("Invalid user_pools contract address"), if (isDefined(addressFromString(emissionContractPrm)))
107+        then true
108+        else throw("Invalid emission contract address"), if ((feeAmountPrm >= 0))
109+        then true
110+        else throw("Invalid fee amount"), if ((votingDurationPrm > 0))
111+        then true
112+        else throw("Invalid voting duration"), if ((votingThresholdPrm >= 0))
113+        then true
114+        else throw("Invalid voting threshold"), if (isDefined(assetInfo(fromBase58String(wxAssetIdPrm))))
115+        then true
116+        else throw("Invalid WX asset ID"), if (isDefined(assetInfo(fromBase58String(usdnAssetIdPrm))))
117+        then true
118+        else throw("Invalid USDN asset ID")]
119+    if ((checks == checks))
120+        then $Tuple2([StringEntry(keyAssetsStoreContract, assetsStoreContractPrm), StringEntry(keyuserPoolContract, userPoolContractPrm), StringEntry(keyEmissionContract, emissionContractPrm), IntegerEntry(keyFeeAmount, feeAmountPrm), IntegerEntry(keyVotingDuration, votingDurationPrm), IntegerEntry(keyVotingThreshold, votingThresholdPrm), StringEntry(keyWxAssetId, wxAssetIdPrm), StringEntry(keyUsdnAssetId, usdnAssetIdPrm)], unit)
121+        else throw("Strict value is not equal to itself.")
122+    }
123+
124+
125+
126+@Callable(i)
127+func suggest (amountAssetId,priceAssetId) = {
128+    let payment = value(i.payments[0])
129+    let info = valueOrErrorMessage(assetInfo(fromBase58String(amountAssetId)), "Invalid amountAssetId ID")
130+    let checks = [if ((info.issuer == i.caller))
131+        then true
132+        else throw("Asset can only be suggested by its issuer"), if ((info.scripted == false))
133+        then true
134+        else throw("Asset is smart"), if ((toBase58String(value(payment.assetId)) == value(getString(keyWxAssetId))))
135+        then true
136+        else throw("Invalid fee asset"), if ((payment.amount == value(getInteger(keyFeeAmount))))
137+        then true
138+        else throw("Invalid fee amount"), if ((priceAssetId == value(getString(keyUsdnAssetId))))
139+        then true
140+        else throw("priceAssetId is not USDN"), if ((getBoolean(keyInListAssetId(amountAssetId, priceAssetId)) == unit))
141+        then true
142+        else throw("Already in voting list"), if (valueOrElse(invoke(userPoolContract, "keyStatus", [amountAssetId, priceAssetId], nil), false))
143+        then true
144+        else throw("User pool is not active")]
145+    if ((checks == checks))
146+        then {
147+            let isAmountAssetVerified =             match invoke(value(addressFromString(keyAssetsStoreContract)), "isVerifiedREADONLY", [amountAssetId], nil) {
148+                case b: Boolean => 
149+                    b
150+                case _ => 
151+                    throw("Asset is not verified")
152+            }
153+            let burnFeeInv = invoke(emissionContract, "burn", nil, [AttachedPayment(payment.assetId, payment.amount)])
154+            if ((burnFeeInv == burnFeeInv))
155+                then [BooleanEntry(keyInListAssetId(amountAssetId, priceAssetId), true), IntegerEntry(keyStartHeight(amountAssetId, priceAssetId), height)]
156+                else throw("Strict value is not equal to itself.")
157+            }
158+        else throw("Strict value is not equal to itself.")
159+    }
160+
161+
162+
163+@Callable(i)
164+func vote (amountAssetId,priceAssetId,inFavor) = {
165+    let checks = [if (valueOrElse(getBoolean(keyInListAssetId(amountAssetId, priceAssetId)), false))
166+        then true
167+        else throw("The token isn't on the voting list"), (height >= (value(getInteger(keyStartHeight(amountAssetId, priceAssetId))) + value(getInteger(keyVotingDuration))))]
168+    if ((checks == checks))
169+        then {
170+            let votingResult = split(value(getString(keyVotingResult(amountAssetId, priceAssetId))), separator)
171+            let positiveVotes = votingResult[1]
172+            let negativeVotes = votingResult[2]
173+            let gwxAmount = invoke(boostingContract, "getUserGwxAmountAtHeightREADONLY", [toString(i.caller), height], nil)
174+            let entries = if (inFavor)
175+                then {
176+                    let newPositiveVotes = (parseIntValue(positiveVotes) + asInt(gwxAmount))
177+                    let totalVotes = makeString(["%d%d", toString(newPositiveVotes), negativeVotes], separator)
178+                    let yesVoteKey = keyVote(amountAssetId, priceAssetId, toString(i.caller))
179+                    let yesVoteValue = makeString([keyVotingResult(amountAssetId, priceAssetId), "yes"], separator)
180+                    $Tuple2([StringEntry(keyVotingResult(amountAssetId, priceAssetId), totalVotes), StringEntry(yesVoteKey, yesVoteValue)], unit)
181+                    }
182+                else {
183+                    let newNegativeVotes = (parseIntValue(negativeVotes) + asInt(gwxAmount))
184+                    let totalVotes = makeString(["%d%d", positiveVotes, toString(newNegativeVotes)], separator)
185+                    let noVoteKey = keyVote(amountAssetId, priceAssetId, toString(i.caller))
186+                    let noVoteValue = makeString([keyVotingResult(amountAssetId, priceAssetId), "no"], separator)
187+                    $Tuple2([StringEntry(keyVotingResult(amountAssetId, priceAssetId), totalVotes), StringEntry(noVoteKey, noVoteValue)], unit)
188+                    }
189+            entries
190+            }
191+        else throw("Strict value is not equal to itself.")
192+    }
193+
194+
195+
196+@Callable(i)
197+func setManager (pendingManagerPublicKey) = {
198+    let checkCaller = mustManager(i)
199+    if ((checkCaller == checkCaller))
200+        then {
201+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
202+            if ((checkManagerPublicKey == checkManagerPublicKey))
203+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
204+                else throw("Strict value is not equal to itself.")
205+            }
206+        else throw("Strict value is not equal to itself.")
207+    }
208+
209+
210+
211+@Callable(i)
212+func confirmManager () = {
213+    let pm = pendingManagerPublicKeyOrUnit()
214+    let hasPM = if (isDefined(pm))
215+        then true
216+        else throw("No pending manager")
217+    if ((hasPM == hasPM))
218+        then {
219+            let checkPM = if ((i.callerPublicKey == value(pm)))
220+                then true
221+                else throw("You are not pending manager")
222+            if ((checkPM == checkPM))
223+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
224+                else throw("Strict value is not equal to itself.")
225+            }
226+        else throw("Strict value is not equal to itself.")
227+    }
228+
229+
230+@Verifier(tx)
231+func verify () = {
232+    let targetPublicKey =     match managerPublicKeyOrUnit() {
233+        case pk: ByteVector => 
234+            pk
235+        case _: Unit => 
236+            tx.senderPublicKey
237+        case _ => 
238+            throw("Match error")
239+    }
240+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
241+    }
242+
github/deemru/w8io/169f3d6 
23.51 ms ◑