tx · 7rodGGGNeBx6DZ5H97unpj5vRfr3HFt9mb4C1Mnkn7Eg

3MyVvNfXht9piazyf1e5BVFsqv1R7z5cWJL:  -0.03300000 Waves

2022.06.21 16:49 [2106239] smart account 3MyVvNfXht9piazyf1e5BVFsqv1R7z5cWJL > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7rodGGGNeBx6DZ5H97unpj5vRfr3HFt9mb4C1Mnkn7Eg",
    "fee": 3300000,
    "feeAssetId": null,
    "timestamp": 1655819415146,
    "version": 1,
    "sender": "3MyVvNfXht9piazyf1e5BVFsqv1R7z5cWJL",
    "senderPublicKey": "DnPyGWCgpQChvoQrnXQRcC9FtN32mPGrcog2wcKHdkVn",
    "proofs": [
        "5dGDSdrBFq2EjyDUKkbwUjen1ccKdzQyEvr2cZwaU5Q67QYH1LtFWVyAuMvSjkdatfr5cYoStMGUUapoxsFnSB3n"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2106239,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: F1CtiBMh5o2FxEiNM1pSobsrtP98N9R1JW5sxkJFuTx5
Next: ELK4b5o9ABp9H6iJxgTtC9s365ch86usH4mwKL82yXw2

Diff: 

OldNewDifferences
1818 let keyMaxDepth = makeString(["%s", "maxDepth"], separator)
1919 
2020 let keyVotingEmissionCandidateContract = makeString(["%s", "votingEmissionCandidateContract"], separator)
21+
22+let keyFactoryContract = makeString(["%s", "factoryContract"], separator)
2123 
2224 let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
2325 
4042 
4143 
4244 func keyInList (pool) = {
43-    let $t012901330 = pool
44-    let amountAssetId = $t012901330._1
45-    let priceAssetId = $t012901330._2
45+    let $t013631403 = pool
46+    let amountAssetId = $t013631403._1
47+    let priceAssetId = $t013631403._2
4648     makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
4749     }
4850 
5153 
5254 
5355 func keyVote (pool,address,epoch) = {
54-    let $t016041644 = pool
55-    let amountAssetId = $t016041644._1
56-    let priceAssetId = $t016041644._2
56+    let $t016771717 = pool
57+    let amountAssetId = $t016771717._1
58+    let priceAssetId = $t016771717._2
5759     makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], separator)
5860     }
5961 
6062 
6163 func keyVotingResult (pool,epoch) = {
62-    let $t018261866 = pool
63-    let amountAssetId = $t018261866._1
64-    let priceAssetId = $t018261866._2
64+    let $t018991939 = pool
65+    let amountAssetId = $t018991939._1
66+    let priceAssetId = $t018991939._2
6567     makeString(["%s%s%s%d", "votingResult", amountAssetId, priceAssetId, toString(epoch)], separator)
6668     }
6769 
6870 
6971 func keyPoolShare (pool,epoch) = {
70-    let $t020312071 = pool
71-    let amountAssetId = $t020312071._1
72-    let priceAssetId = $t020312071._2
72+    let $t021042144 = pool
73+    let amountAssetId = $t021042144._1
74+    let priceAssetId = $t021042144._2
7375     makeString(["%s%s%s%d", "poolShare", amountAssetId, priceAssetId, toString(epoch)], separator)
7476     }
7577 
120122 let poolsListName = "pools"
121123 
122124 func getVotesListName (pool) = {
123-    let $t031773217 = pool
124-    let amountAssetId = $t031773217._1
125-    let priceAssetId = $t031773217._2
125+    let $t032503290 = pool
126+    let amountAssetId = $t032503290._1
127+    let priceAssetId = $t032503290._2
126128     makeString(["votes", amountAssetId, priceAssetId], separator)
127129     }
128130 
298300 
299301 
300302 @Callable(i)
301-func constructor (votingEmissionCandidateContract,boostingContract,epochLength) = {
302-    let cheks = [mustManager(i), if ((addressFromString(votingEmissionCandidateContract) != unit))
303+func constructor (factoryContract,votingEmissionCandidateContract,boostingContract,epochLength) = {
304+    let cheks = [mustManager(i), if ((addressFromString(factoryContract) != unit))
305+        then true
306+        else "invalid factory contract address", if ((addressFromString(votingEmissionCandidateContract) != unit))
303307         then true
304308         else "invalid voting emission candidate contract address", if ((addressFromString(boostingContract) != unit))
305309         then true
307311         then true
308312         else throw("invalid epoch length")]
309313     if ((cheks == cheks))
310-        then $Tuple2([StringEntry(keyVotingEmissionCandidateContract, votingEmissionCandidateContract), StringEntry(keyBoostingContract, boostingContract), IntegerEntry(keyEpochLength, epochLength)], unit)
314+        then $Tuple2([StringEntry(keyFactoryContract, factoryContract), StringEntry(keyVotingEmissionCandidateContract, votingEmissionCandidateContract), StringEntry(keyBoostingContract, boostingContract), IntegerEntry(keyEpochLength, epochLength)], unit)
311315         else throw("Strict value is not equal to itself.")
312316     }
313317 
499503             if ((checkTargetEpoch == checkTargetEpoch))
500504                 then {
501505                     let pool = stringToPool(poolStr)
506+                    let $t01678716827 = pool
507+                    let amountAssetId = $t01678716827._1
508+                    let priceAssetId = $t01678716827._2
502509                     let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(targetEpoch)), 0)
503510                     let votingResult = valueOrElse(getInteger(this, keyVotingResult(pool, targetEpoch)), 0)
504511                     let share = if ((totalVotes == 0))
505512                         then 0
506513                         else fraction(votingResult, poolWeightMult, totalVotes)
507-                    $Tuple2([IntegerEntry(keyPoolShare(pool, targetEpoch), share)], unit)
514+                    let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
515+                    let modifyWeightInv = invoke(factoryContract, "modifyWeight", [amountAssetId, priceAssetId, share], nil)
516+                    if ((modifyWeightInv == modifyWeightInv))
517+                        then $Tuple2([IntegerEntry(keyPoolShare(pool, targetEpoch), share)], unit)
518+                        else throw("Strict value is not equal to itself.")
508519                     }
509520                 else throw("Strict value is not equal to itself.")
510521             }

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let separator = "__"
55 
66 let poolWeightMult = 100000000
77 
88 let maxDepthDefault = 10
99 
1010 let finalizationStageTotal = 0
1111 
1212 let finalizationStageShares = 1
1313 
1414 let keyEpochLength = makeString(["%s", "epochLength"], separator)
1515 
1616 let keyCurrentEpoch = makeString(["%s", "currentEpoch"], separator)
1717 
1818 let keyMaxDepth = makeString(["%s", "maxDepth"], separator)
1919 
2020 let keyVotingEmissionCandidateContract = makeString(["%s", "votingEmissionCandidateContract"], separator)
21+
22+let keyFactoryContract = makeString(["%s", "factoryContract"], separator)
2123 
2224 let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
2325 
2426 let keyFinalizationStage = makeString(["%s", "finalizationStage"], separator)
2527 
2628 let keyNextPool = makeString(["%s", "nextPool"], separator)
2729 
2830 let keyNextUser = makeString(["%s", "nextUser"], separator)
2931 
3032 let keyStartHeight = makeString(["%s", "startHeight"], separator)
3133 
3234 let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], separator)
3335 
3436 let keyStartHeightUi = makeString(["%s", "startHeightUi"], separator)
3537 
3638 func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], separator)
3739 
3840 
3941 func keyFinalized (epoch) = makeString(["%s%d", "finalized", toString(epoch)], separator)
4042 
4143 
4244 func keyInList (pool) = {
43-    let $t012901330 = pool
44-    let amountAssetId = $t012901330._1
45-    let priceAssetId = $t012901330._2
45+    let $t013631403 = pool
46+    let amountAssetId = $t013631403._1
47+    let priceAssetId = $t013631403._2
4648     makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
4749     }
4850 
4951 
5052 func keyUsed (address,epoch) = makeString(["%s%s%d", "used", toString(address), toString(epoch)], separator)
5153 
5254 
5355 func keyVote (pool,address,epoch) = {
54-    let $t016041644 = pool
55-    let amountAssetId = $t016041644._1
56-    let priceAssetId = $t016041644._2
56+    let $t016771717 = pool
57+    let amountAssetId = $t016771717._1
58+    let priceAssetId = $t016771717._2
5759     makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], separator)
5860     }
5961 
6062 
6163 func keyVotingResult (pool,epoch) = {
62-    let $t018261866 = pool
63-    let amountAssetId = $t018261866._1
64-    let priceAssetId = $t018261866._2
64+    let $t018991939 = pool
65+    let amountAssetId = $t018991939._1
66+    let priceAssetId = $t018991939._2
6567     makeString(["%s%s%s%d", "votingResult", amountAssetId, priceAssetId, toString(epoch)], separator)
6668     }
6769 
6870 
6971 func keyPoolShare (pool,epoch) = {
70-    let $t020312071 = pool
71-    let amountAssetId = $t020312071._1
72-    let priceAssetId = $t020312071._2
72+    let $t021042144 = pool
73+    let amountAssetId = $t021042144._1
74+    let priceAssetId = $t021042144._2
7375     makeString(["%s%s%s%d", "poolShare", amountAssetId, priceAssetId, toString(epoch)], separator)
7476     }
7577 
7678 
7779 func keyTotalVotes (epoch) = makeString(["%s%d", "totalVotes", toString(epoch)], separator)
7880 
7981 
8082 func getValueOrFail (address,key,type) = {
8183     let error = makeString(["mandatory ", toString(address), ".", key, " is not defined"], "")
8284     valueOrErrorMessage(    match type {
8385         case str: String => 
8486             getString(address, key)
8587         case int: Int => 
8688             getInteger(address, key)
8789         case _ => 
8890             throw("invalid entry type")
8991     }, error)
9092     }
9193 
9294 
9395 func getStrOrFail (address,key) = {
9496     let @ = getValueOrFail(address, key, "")
9597     if ($isInstanceOf(@, "String"))
9698         then @
9799         else throw("Couldn't cast Int|String to String")
98100     }
99101 
100102 
101103 func getIntOrFail (address,key) = {
102104     let @ = getValueOrFail(address, key, 0)
103105     if ($isInstanceOf(@, "Int"))
104106         then @
105107         else throw("Couldn't cast Int|String to Int")
106108     }
107109 
108110 
109111 func poolToString (pool) = ((pool._1 + separator) + pool._2)
110112 
111113 
112114 func stringToPool (str) = {
113115     let parts = split(str, separator)
114116     if ((size(parts) == 2))
115117         then $Tuple2(parts[0], parts[1])
116118         else throw("invalid pool string")
117119     }
118120 
119121 
120122 let poolsListName = "pools"
121123 
122124 func getVotesListName (pool) = {
123-    let $t031773217 = pool
124-    let amountAssetId = $t031773217._1
125-    let priceAssetId = $t031773217._2
125+    let $t032503290 = pool
126+    let amountAssetId = $t032503290._1
127+    let priceAssetId = $t032503290._2
126128     makeString(["votes", amountAssetId, priceAssetId], separator)
127129     }
128130 
129131 
130132 func keyListHead (listName) = {
131133     let meta = if ((listName == poolsListName))
132134         then "%s%s"
133135         else "%s%s%s%s"
134136     makeString([meta, listName, "head"], separator)
135137     }
136138 
137139 
138140 func keyListSize (listName) = {
139141     let meta = if ((listName == poolsListName))
140142         then "%s%s"
141143         else "%s%s%s%s"
142144     makeString([meta, listName, "size"], separator)
143145     }
144146 
145147 
146148 func keyListPrev (listName,id) = {
147149     let meta = if ((listName == poolsListName))
148150         then "%s%s%s%s"
149151         else "%s%s%s%s%s"
150152     makeString([meta, listName, id, "prev"], separator)
151153     }
152154 
153155 
154156 func keyListNext (listName,id) = {
155157     let meta = if ((listName == poolsListName))
156158         then "%s%s%s%s"
157159         else "%s%s%s%s%s"
158160     makeString([meta, listName, id, "next"], separator)
159161     }
160162 
161163 
162164 func containsNode (listName,id) = {
163165     let headOrUnit = getString(this, keyListHead(listName))
164166     let prevOrUnit = getString(this, keyListPrev(listName, id))
165167     let nextOrUnit = getString(this, keyListNext(listName, id))
166168     if (if ((id == valueOrElse(headOrUnit, "")))
167169         then true
168170         else (prevOrUnit != unit))
169171         then true
170172         else (nextOrUnit != unit)
171173     }
172174 
173175 
174176 func insertNodeActions (listName,id) = {
175177     let headOrUnit = getString(this, keyListHead(listName))
176178     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
177179     let checkNode = if (!(containsNode(listName, id)))
178180         then true
179181         else throw("Node exists")
180182     if ((checkNode == checkNode))
181183         then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
182184             then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
183185             else nil)) ++ [StringEntry(keyListHead(listName), id)])
184186         else throw("Strict value is not equal to itself.")
185187     }
186188 
187189 
188190 func deleteNodeActions (listName,id) = {
189191     let headOrUnit = getString(this, keyListHead(listName))
190192     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
191193     let prevOrUnit = getString(this, keyListPrev(listName, id))
192194     let nextOrUnit = getString(this, keyListNext(listName, id))
193195     ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
194196         then (nextOrUnit != unit)
195197         else false)
196198         then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
197199         else if ((nextOrUnit != unit))
198200             then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
199201             else if ((prevOrUnit != unit))
200202                 then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
201203                 else if ((id == valueOrElse(headOrUnit, "")))
202204                     then [DeleteEntry(keyListHead(listName))]
203205                     else throw(((("invalid node: " + listName) + ".") + id))))
204206     }
205207 
206208 
207209 func keyManagerPublicKey () = "%s__managerPublicKey"
208210 
209211 
210212 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
211213 
212214 
213215 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
214216     case s: String => 
215217         fromBase58String(s)
216218     case _: Unit => 
217219         unit
218220     case _ => 
219221         throw("Match error")
220222 }
221223 
222224 
223225 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
224226     case s: String => 
225227         fromBase58String(s)
226228     case _: Unit => 
227229         unit
228230     case _ => 
229231         throw("Match error")
230232 }
231233 
232234 
233235 let permissionDeniedError = throw("Permission denied")
234236 
235237 func mustThis (i) = if ((i.caller == this))
236238     then true
237239     else permissionDeniedError
238240 
239241 
240242 func mustManager (i) = match managerPublicKeyOrUnit() {
241243     case pk: ByteVector => 
242244         if ((i.callerPublicKey == pk))
243245             then true
244246             else permissionDeniedError
245247     case _: Unit => 
246248         mustThis(i)
247249     case _ => 
248250         throw("Match error")
249251 }
250252 
251253 
252254 @Callable(i)
253255 func setManager (pendingManagerPublicKey) = {
254256     let checkCaller = mustManager(i)
255257     if ((checkCaller == checkCaller))
256258         then {
257259             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
258260             if ((checkManagerPublicKey == checkManagerPublicKey))
259261                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
260262                 else throw("Strict value is not equal to itself.")
261263             }
262264         else throw("Strict value is not equal to itself.")
263265     }
264266 
265267 
266268 
267269 @Callable(i)
268270 func confirmManager () = {
269271     let pm = pendingManagerPublicKeyOrUnit()
270272     let hasPM = if (isDefined(pm))
271273         then true
272274         else throw("No pending manager")
273275     if ((hasPM == hasPM))
274276         then {
275277             let checkPM = if ((i.callerPublicKey == value(pm)))
276278                 then true
277279                 else throw("You are not pending manager")
278280             if ((checkPM == checkPM))
279281                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
280282                 else throw("Strict value is not equal to itself.")
281283             }
282284         else throw("Strict value is not equal to itself.")
283285     }
284286 
285287 
286288 
287289 @Callable(i)
288290 func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
289291     let boostingContractAddress = valueOrErrorMessage(addressFromString(getStrOrFail(this, keyBoostingContract)), "invalid boosting contract address")
290292     $Tuple2(nil, {
291293         let @ = invoke(boostingContractAddress, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
292294         if ($isInstanceOf(@, "Int"))
293295             then @
294296             else throw("Couldn't cast Any to Int")
295297         })
296298     }
297299 
298300 
299301 
300302 @Callable(i)
301-func constructor (votingEmissionCandidateContract,boostingContract,epochLength) = {
302-    let cheks = [mustManager(i), if ((addressFromString(votingEmissionCandidateContract) != unit))
303+func constructor (factoryContract,votingEmissionCandidateContract,boostingContract,epochLength) = {
304+    let cheks = [mustManager(i), if ((addressFromString(factoryContract) != unit))
305+        then true
306+        else "invalid factory contract address", if ((addressFromString(votingEmissionCandidateContract) != unit))
303307         then true
304308         else "invalid voting emission candidate contract address", if ((addressFromString(boostingContract) != unit))
305309         then true
306310         else "invalid boosting contract address", if ((epochLength > 0))
307311         then true
308312         else throw("invalid epoch length")]
309313     if ((cheks == cheks))
310-        then $Tuple2([StringEntry(keyVotingEmissionCandidateContract, votingEmissionCandidateContract), StringEntry(keyBoostingContract, boostingContract), IntegerEntry(keyEpochLength, epochLength)], unit)
314+        then $Tuple2([StringEntry(keyFactoryContract, factoryContract), StringEntry(keyVotingEmissionCandidateContract, votingEmissionCandidateContract), StringEntry(keyBoostingContract, boostingContract), IntegerEntry(keyEpochLength, epochLength)], unit)
311315         else throw("Strict value is not equal to itself.")
312316     }
313317 
314318 
315319 
316320 @Callable(i)
317321 func create (amountAssetId,priceAssetId) = {
318322     let checks = [if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionCandidateContract), "")))
319323         then true
320324         else mustManager(i)]
321325     if ((checks == checks))
322326         then {
323327             let pool = $Tuple2(amountAssetId, priceAssetId)
324328             let inListActions = ([BooleanEntry(keyInList(pool), true)] ++ insertNodeActions(poolsListName, poolToString(pool)))
325329             let currentEpochIsNotDefined = (getInteger(this, keyCurrentEpoch) == unit)
326330             let startHeightActions = if (currentEpochIsNotDefined)
327331                 then {
328332                     let epoch = 0
329333 [IntegerEntry(keyCurrentEpoch, epoch), IntegerEntry(keyStartHeightByEpoch(epoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, height)]
330334                     }
331335                 else nil
332336             $Tuple2((inListActions ++ startHeightActions), unit)
333337             }
334338         else throw("Strict value is not equal to itself.")
335339     }
336340 
337341 
338342 
339343 @Callable(i)
340344 func vote (amountAssetId,priceAssetId,amount) = {
341345     let pool = $Tuple2(amountAssetId, priceAssetId)
342346     let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
343347     let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
344348     let epochLength = getIntOrFail(this, keyEpochLength)
345349     let endHeight = (startHeight + epochLength)
346350     let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
347351     let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
348352     let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
349353     let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
350354     let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
351355     let gwxAmountAtEndTotal = {
352356         let @ = invoke(this, "getUserGwxAmountAtHeight", [toBase58String(i.caller.bytes), endHeight], nil)
353357         if ($isInstanceOf(@, "Int"))
354358             then @
355359             else throw("Couldn't cast Any to Int")
356360         }
357361     let available = (gwxAmountAtEndTotal - used)
358362     let newVote = (vote + amount)
359363     let checks = [if ((getBoolean(keyInList(pool)) != unit))
360364         then true
361365         else throw("invalid assets"), if ((endHeight > height))
362366         then true
363367         else throw("invalid height"), if ((finalizationStageOrUnit == unit))
364368         then true
365369         else throw("finalization in progress"), if ((gwxAmountAtEndTotal > 0))
366370         then true
367371         else throw("you do not have gWX"), if (if ((amount > 0))
368372         then (available >= amount)
369373         else false)
370374         then true
371375         else throw("invalid amount")]
372376     if ((checks == checks))
373377         then {
374378             let votesListName = getVotesListName(pool)
375379             let userAddressStr = toString(i.caller)
376380             let votesListActions = if (containsNode(votesListName, userAddressStr))
377381                 then nil
378382                 else insertNodeActions(votesListName, userAddressStr)
379383             $Tuple2(([IntegerEntry(keyUsed(i.caller, epoch), (used + amount)), IntegerEntry(keyVote(pool, i.caller, epoch), newVote), IntegerEntry(keyVotingResult(pool, epoch), (poolResult + amount)), IntegerEntry(keyTotalVotes(epoch), (totalVotes + amount))] ++ votesListActions), unit)
380384             }
381385         else throw("Strict value is not equal to itself.")
382386     }
383387 
384388 
385389 
386390 @Callable(i)
387391 func cancelVote (amountAssetId,priceAssetId) = {
388392     let pool = $Tuple2(amountAssetId, priceAssetId)
389393     let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
390394     let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
391395     let epochLength = getIntOrFail(this, keyEpochLength)
392396     let endHeight = (startHeight + epochLength)
393397     let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
394398     let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
395399     let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
396400     let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
397401     let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
398402     let checks = [if ((getBoolean(keyInList(pool)) != unit))
399403         then true
400404         else throw("invalid assets"), if ((endHeight > height))
401405         then true
402406         else throw("invalid height"), if ((finalizationStageOrUnit == unit))
403407         then true
404408         else throw("finalization in progress"), if ((vote > 0))
405409         then true
406410         else throw("no vote")]
407411     if ((checks == checks))
408412         then {
409413             let votesListName = getVotesListName(pool)
410414             let userAddressStr = toString(i.caller)
411415             $Tuple2(([IntegerEntry(keyUsed(i.caller, epoch), max([(used - vote), 0])), DeleteEntry(keyVote(pool, i.caller, epoch)), IntegerEntry(keyVotingResult(pool, epoch), (poolResult - vote)), IntegerEntry(keyTotalVotes(epoch), (totalVotes - vote))] ++ deleteNodeActions(votesListName, userAddressStr)), unit)
412416             }
413417         else throw("Strict value is not equal to itself.")
414418     }
415419 
416420 
417421 
418422 @Callable(i)
419423 func setEpochLength (newEpochLength) = {
420424     let cheks = [mustManager(i), if ((newEpochLength > 0))
421425         then true
422426         else throw("invalid epoch length")]
423427     if ((cheks == cheks))
424428         then $Tuple2([IntegerEntry(keyEpochLength, newEpochLength)], unit)
425429         else throw("Strict value is not equal to itself.")
426430     }
427431 
428432 
429433 
430434 @Callable(i)
431435 func setMaxDepth (newMaxDepth) = {
432436     let cheks = [mustManager(i), if ((newMaxDepth > 0))
433437         then true
434438         else throw("invalid max depth")]
435439     if ((cheks == cheks))
436440         then $Tuple2([IntegerEntry(keyMaxDepth, newMaxDepth)], unit)
437441         else throw("Strict value is not equal to itself.")
438442     }
439443 
440444 
441445 
442446 @Callable(i)
443447 func processVoteINTERNAL (poolStr,userAddressStr) = {
444448     let checkCaller = mustThis(i)
445449     if ((checkCaller == checkCaller))
446450         then {
447451             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), ("processVoteINTERNAL: invalid user address " + userAddressStr))
448452             let epoch = getIntOrFail(this, keyCurrentEpoch)
449453             let epochPrevious = (epoch - 1)
450454             let epochLength = getIntOrFail(this, keyEpochLength)
451455             let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
452456             let endHeight = (startHeight + epochLength)
453457             let startHeightPrevious = getIntOrFail(this, keyStartHeightByEpoch(epochPrevious))
454458             let endHeightPrevious = (startHeightPrevious + epochLength)
455459             let checkTargetEpoch = if ((epochPrevious >= 0))
456460                 then true
457461                 else throw("processVoteINTERNAL: invalid previous epoch")
458462             if ((checkTargetEpoch == checkTargetEpoch))
459463                 then {
460464                     let pool = stringToPool(poolStr)
461465                     let gwxAmountAtEndTotal = {
462466                         let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeight], nil)
463467                         if ($isInstanceOf(@, "Int"))
464468                             then @
465469                             else throw("Couldn't cast Any to Int")
466470                         }
467471                     let gwxAmountAtEndTotalPrevious = {
468472                         let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeightPrevious], nil)
469473                         if ($isInstanceOf(@, "Int"))
470474                             then @
471475                             else throw("Couldn't cast Any to Int")
472476                         }
473477                     let totalVotes = valueOrElse(getInteger(keyTotalVotes(epoch)), 0)
474478                     let votingResult = valueOrElse(getInteger(keyVotingResult(pool, epoch)), 0)
475479                     let votePrevious = valueOrErrorMessage(getInteger(keyVote(pool, userAddress, epochPrevious)), (((("processVoteINTERNAL " + poolStr) + " ") + userAddressStr) + ": no previous vote"))
476480                     let used = valueOrElse(getInteger(this, keyUsed(userAddress, epoch)), 0)
477481                     let newVote = fraction(votePrevious, gwxAmountAtEndTotal, gwxAmountAtEndTotalPrevious)
478482                     let actions = if ((newVote > 0))
479483                         then [IntegerEntry(keyVote(pool, userAddress, epoch), newVote), IntegerEntry(keyTotalVotes(epoch), (totalVotes + newVote)), IntegerEntry(keyVotingResult(pool, epoch), (votingResult + newVote)), IntegerEntry(keyUsed(userAddress, epoch), (used + newVote))]
480484                         else deleteNodeActions(getVotesListName(pool), userAddressStr)
481485                     $Tuple2(actions, unit)
482486                     }
483487                 else throw("Strict value is not equal to itself.")
484488             }
485489         else throw("Strict value is not equal to itself.")
486490     }
487491 
488492 
489493 
490494 @Callable(i)
491495 func processPoolINTERNAL (poolStr) = {
492496     let checkCaller = mustThis(i)
493497     if ((checkCaller == checkCaller))
494498         then {
495499             let targetEpoch = (getIntOrFail(this, keyCurrentEpoch) - 1)
496500             let checkTargetEpoch = if ((targetEpoch >= 0))
497501                 then true
498502                 else throw("processPoolINTERNAL: invalid target epoch")
499503             if ((checkTargetEpoch == checkTargetEpoch))
500504                 then {
501505                     let pool = stringToPool(poolStr)
506+                    let $t01678716827 = pool
507+                    let amountAssetId = $t01678716827._1
508+                    let priceAssetId = $t01678716827._2
502509                     let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(targetEpoch)), 0)
503510                     let votingResult = valueOrElse(getInteger(this, keyVotingResult(pool, targetEpoch)), 0)
504511                     let share = if ((totalVotes == 0))
505512                         then 0
506513                         else fraction(votingResult, poolWeightMult, totalVotes)
507-                    $Tuple2([IntegerEntry(keyPoolShare(pool, targetEpoch), share)], unit)
514+                    let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
515+                    let modifyWeightInv = invoke(factoryContract, "modifyWeight", [amountAssetId, priceAssetId, share], nil)
516+                    if ((modifyWeightInv == modifyWeightInv))
517+                        then $Tuple2([IntegerEntry(keyPoolShare(pool, targetEpoch), share)], unit)
518+                        else throw("Strict value is not equal to itself.")
508519                     }
509520                 else throw("Strict value is not equal to itself.")
510521             }
511522         else throw("Strict value is not equal to itself.")
512523     }
513524 
514525 
515526 
516527 @Callable(i)
517528 func finalizeHelper () = {
518529     let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
519530     let previousEpoch = (epoch - 1)
520531     let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
521532     let epochLength = getIntOrFail(this, keyEpochLength)
522533     let endHeight = (startHeight + epochLength)
523534     let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
524535     if ((height >= endHeight))
525536         then {
526537             let newEpoch = (epoch + 1)
527538             $Tuple2([IntegerEntry(keyStartHeightByEpoch(newEpoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpoch, newEpoch), IntegerEntry(keyFinalizationStage, finalizationStageTotal)], true)
528539             }
529540         else if ((finalizationStageOrUnit == unit))
530541             then $Tuple2(nil, false)
531542             else if ((finalizationStageOrUnit == finalizationStageTotal))
532543                 then {
533544                     let poolOrUnit = getString(keyNextPool)
534545                     let userOrUnit = getString(keyNextUser)
535546                     match poolOrUnit {
536547                         case _: Unit => 
537548                             match getString(keyListHead(poolsListName)) {
538549                                 case _: Unit => 
539550                                     $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
540551                                 case poolsHeadStr: String => 
541552                                     $Tuple2([StringEntry(keyNextPool, poolsHeadStr)], true)
542553                                 case _ => 
543554                                     throw("Match error")
544555                             }
545556                         case poolStr: String => 
546557                             let pool = stringToPool(poolStr)
547558                             let nextUserOrUnit =                             match userOrUnit {
548559                                 case _: Unit => 
549560                                     getString(keyListHead(getVotesListName(pool)))
550561                                 case user: String => 
551562                                     let processVoteInv = invoke(this, "processVoteINTERNAL", [poolStr, user], nil)
552563                                     if ((processVoteInv == processVoteInv))
553564                                         then getString(keyListNext(getVotesListName(pool), user))
554565                                         else throw("Strict value is not equal to itself.")
555566                                 case _ => 
556567                                     throw("Match error")
557568                             }
558569                             match nextUserOrUnit {
559570                                 case _: Unit => 
560571                                     let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
561572                                     match nextPoolOrUnit {
562573                                         case _: Unit => 
563574                                             $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
564575                                         case s: String => 
565576                                             $Tuple2([StringEntry(keyNextPool, s), DeleteEntry(keyNextUser)], true)
566577                                         case _ => 
567578                                             throw("Match error")
568579                                     }
569580                                 case nextUser: String => 
570581                                     $Tuple2([StringEntry(keyNextUser, nextUser)], true)
571582                                 case _ => 
572583                                     throw("Match error")
573584                             }
574585                         case _ => 
575586                             throw("Match error")
576587                     }
577588                     }
578589                 else if ((finalizationStageOrUnit == finalizationStageShares))
579590                     then {
580591                         let poolOrUnit = getString(keyNextPool)
581592                         match poolOrUnit {
582593                             case _: Unit => 
583594                                 match getString(keyListHead(poolsListName)) {
584595                                     case _: Unit => 
585596                                         $Tuple2([DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight)], true)
586597                                     case nextPoolStr: String => 
587598                                         $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
588599                                     case _ => 
589600                                         throw("Match error")
590601                                 }
591602                             case poolStr: String => 
592603                                 let processPoolInv = invoke(this, "processPoolINTERNAL", [poolStr], nil)
593604                                 if ((processPoolInv == processPoolInv))
594605                                     then {
595606                                         let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
596607                                         match nextPoolOrUnit {
597608                                             case _: Unit => 
598609                                                 $Tuple2([DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight), DeleteEntry(keyNextPool)], true)
599610                                             case nextPoolStr: String => 
600611                                                 $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
601612                                             case _ => 
602613                                                 throw("Match error")
603614                                         }
604615                                         }
605616                                     else throw("Strict value is not equal to itself.")
606617                             case _ => 
607618                                 throw("Match error")
608619                         }
609620                         }
610621                     else throw("finalization is broken")
611622     }
612623 
613624 
614625 
615626 @Callable(i)
616627 func finalizeWrapper (counter) = {
617628     let result = {
618629         let @ = invoke(this, "finalizeHelper", nil, nil)
619630         if ($isInstanceOf(@, "Boolean"))
620631             then @
621632             else throw("Couldn't cast Any to Boolean")
622633         }
623634     if ((result == result))
624635         then if (!(result))
625636             then if ((counter == 0))
626637                 then throw("Current voting is not over yet")
627638                 else $Tuple2(nil, unit)
628639             else {
629640                 let maxDepth = valueOrElse(getInteger(this, keyMaxDepth), maxDepthDefault)
630641                 if ((maxDepth > counter))
631642                     then {
632643                         let inv = invoke(this, "finalizeWrapper", [(counter + 1)], nil)
633644                         if ((inv == inv))
634645                             then $Tuple2(nil, unit)
635646                             else throw("Strict value is not equal to itself.")
636647                         }
637648                     else $Tuple2(nil, unit)
638649                 }
639650         else throw("Strict value is not equal to itself.")
640651     }
641652 
642653 
643654 
644655 @Callable(i)
645656 func finalize () = {
646657     let inv = invoke(this, "finalizeWrapper", [0], nil)
647658     if ((inv == inv))
648659         then $Tuple2(nil, unit)
649660         else throw("Strict value is not equal to itself.")
650661     }
651662 
652663 
653664 
654665 @Callable(i)
655666 func onVerificationLoss (assetId) = $Tuple2(nil, unit)
656667 
657668 
658669 
659670 @Callable(i)
660671 func containsNodeREADONLY (listName,id) = $Tuple2(nil, containsNode(listName, id))
661672 
662673 
663674 
664675 @Callable(i)
665676 func insertNode (listName,id) = {
666677     let checkCaller = mustManager(i)
667678     if ((checkCaller == checkCaller))
668679         then $Tuple2(insertNodeActions(listName, id), unit)
669680         else throw("Strict value is not equal to itself.")
670681     }
671682 
672683 
673684 
674685 @Callable(i)
675686 func deleteNode (listName,id) = {
676687     let checkCaller = mustManager(i)
677688     if ((checkCaller == checkCaller))
678689         then $Tuple2(deleteNodeActions(listName, id), unit)
679690         else throw("Strict value is not equal to itself.")
680691     }
681692 
682693 
683694 @Verifier(tx)
684695 func verify () = {
685696     let targetPublicKey =     match managerPublicKeyOrUnit() {
686697         case pk: ByteVector => 
687698             pk
688699         case _: Unit => 
689700             tx.senderPublicKey
690701         case _ => 
691702             throw("Match error")
692703     }
693704     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
694705     }
695706 
github/deemru/w8io/169f3d6 
92.56 ms ◑