tx · Bjrq5ZKKTXBH7kVYjFrqip8Zue5XQsyunE7JCEV1FkxF

3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA:  -0.02500000 Waves

2023.02.10 16:52 [2443630] smart account 3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Bjrq5ZKKTXBH7kVYjFrqip8Zue5XQsyunE7JCEV1FkxF",
    "fee": 2500000,
    "feeAssetId": null,
    "timestamp": 1676037141470,
    "version": 2,
    "chainId": 84,
    "sender": "3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA",
    "senderPublicKey": "D46gQxzmdzdCTYRg6dMcwFoUrc6ZmxF6GKd5ZoTkvzp1",
    "proofs": [
        "gXTDEENYyHYyEKcKVJhfqWS1jsX1ePNwMuA9JJTEup8EtdzjvNN8wFNH8KKSiFbaCFEisC4Jnq2mcLA8oBjUFP3"
    ],
    "script": "base64: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",
    "height": 2443630,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: H1K2u4rQ2pRmD3uGHNEUoJimbdsBVXhfL6seYoYTnzkv
Next: 8Dc3rz8vFzdXbt4xEhP8R5gVdE2AksPq7dTmwGAyWKov

Diff: 

OldNewDifferences
1212 let finalizationStageShares = 1
1313 
1414 let keyEpochLength = makeString(["%s", "epochLength"], separator)
15+
16+let keyEpochLengthNew = makeString(["%s%s", "epochLength__new"], separator)
17+
18+func keyEpochLengthByEpoch (epoch) = makeString(["%s%d", "epochLength", toString(epoch)], separator)
19+
1520 
1621 let keyCurrentEpoch = makeString(["%s", "currentEpoch"], separator)
1722 
4651 
4752 
4853 func keyInList (pool) = {
49-    let $t015111551 = pool
50-    let amountAssetId = $t015111551._1
51-    let priceAssetId = $t015111551._2
54+    let $t016931733 = pool
55+    let amountAssetId = $t016931733._1
56+    let priceAssetId = $t016931733._2
5257     makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
5358     }
5459 
5762 
5863 
5964 func keyVote (pool,address,epoch) = {
60-    let $t018251865 = pool
61-    let amountAssetId = $t018251865._1
62-    let priceAssetId = $t018251865._2
65+    let $t020072047 = pool
66+    let amountAssetId = $t020072047._1
67+    let priceAssetId = $t020072047._2
6368     makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], separator)
6469     }
6570 
6671 
6772 func keyVotingResult (pool,epoch) = {
68-    let $t020472087 = pool
69-    let amountAssetId = $t020472087._1
70-    let priceAssetId = $t020472087._2
73+    let $t022292269 = pool
74+    let amountAssetId = $t022292269._1
75+    let priceAssetId = $t022292269._2
7176     makeString(["%s%s%s%d", "votingResult", amountAssetId, priceAssetId, toString(epoch)], separator)
7277     }
7378 
7479 
7580 func keyPoolShare (pool,epoch) = {
76-    let $t022522292 = pool
77-    let amountAssetId = $t022522292._1
78-    let priceAssetId = $t022522292._2
81+    let $t024342474 = pool
82+    let amountAssetId = $t024342474._1
83+    let priceAssetId = $t024342474._2
7984     makeString(["%s%s%s%d", "poolShare", amountAssetId, priceAssetId, toString(epoch)], separator)
8085     }
8186 
140145 
141146 
142147 func checkWxEmissionPoolLabel (pool) = {
143-    let $t045344574 = pool
144-    let amountAssetId = $t045344574._1
145-    let priceAssetId = $t045344574._2
148+    let $t047164756 = pool
149+    let amountAssetId = $t047164756._1
150+    let priceAssetId = $t047164756._2
146151     let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
147152     let @ = invoke(factoryContract, "checkWxEmissionPoolLabel", [amountAssetId, priceAssetId], nil)
148153     if ($isInstanceOf(@, "Boolean"))
154159 let poolsListName = "pools"
155160 
156161 func getVotesListName (pool) = {
157-    let $t048754915 = pool
158-    let amountAssetId = $t048754915._1
159-    let priceAssetId = $t048754915._2
162+    let $t050575097 = pool
163+    let amountAssetId = $t050575097._1
164+    let priceAssetId = $t050575097._2
160165     makeString(["votes", amountAssetId, priceAssetId], separator)
161166     }
162167 
462467         then true
463468         else throw("invalid epoch length")]
464469     if ((checks == checks))
465-        then $Tuple2([IntegerEntry(keyEpochLength, newEpochLength)], unit)
470+        then $Tuple2([IntegerEntry(keyEpochLengthNew, newEpochLength)], unit)
466471         else throw("Strict value is not equal to itself.")
467472     }
468473 
492497             let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
493498             let endHeight = (startHeight + epochLength)
494499             let startHeightPrevious = getIntOrFail(this, keyStartHeightByEpoch(epochPrevious))
495-            let endHeightPrevious = (startHeightPrevious + epochLength)
500+            let epochLengthPrevious = getIntOrFail(this, keyEpochLengthByEpoch(epochPrevious))
501+            let endHeightPrevious = (startHeightPrevious + epochLengthPrevious)
496502             let checkTargetEpoch = if ((epochPrevious >= 0))
497503                 then true
498504                 else throw("processVoteINTERNAL: invalid previous epoch")
499505             if ((checkTargetEpoch == checkTargetEpoch))
500506                 then {
501507                     let pool = stringToPool(poolStr)
502-                    let $t01727017310 = pool
503-                    let amountAssetId = $t01727017310._1
504-                    let priceAssetId = $t01727017310._2
508+                    let $t01754817588 = pool
509+                    let amountAssetId = $t01754817588._1
510+                    let priceAssetId = $t01754817588._2
505511                     let wxEmission = checkWxEmissionPoolLabel(pool)
506512                     let gwxAmountAtEndTotal = {
507513                         let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeight], nil)
553559             if ((checkTargetEpoch == checkTargetEpoch))
554560                 then {
555561                     let pool = stringToPool(poolStr)
556-                    let $t01903619076 = pool
557-                    let amountAssetId = $t01903619076._1
558-                    let priceAssetId = $t01903619076._2
562+                    let $t01931419354 = pool
563+                    let amountAssetId = $t01931419354._1
564+                    let priceAssetId = $t01931419354._2
559565                     let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract))
560566                     let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
561567                     let lpAssetId = getLpAssetByPoolAssets(amountAssetId, priceAssetId)
614620         else false)
615621         then {
616622             let newEpoch = (epoch + 1)
617-            $Tuple2([IntegerEntry(keyStartHeightByEpoch(newEpoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpoch, newEpoch), IntegerEntry(keyFinalizationStage, finalizationStageTotal)], true)
623+            let newEpochLengthOption = getInteger(this, keyEpochLengthNew)
624+            let newEpochLengthActions =             match newEpochLengthOption {
625+                case newEpochLength: Int => 
626+[IntegerEntry(keyEpochLength, newEpochLength), DeleteEntry(keyEpochLengthNew)]
627+                case _: Unit => 
628+                    nil
629+                case _ => 
630+                    throw("Match error")
631+            }
632+            $Tuple2(([IntegerEntry(keyStartHeightByEpoch(newEpoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpoch, newEpoch), IntegerEntry(keyFinalizationStage, finalizationStageTotal), IntegerEntry(keyEpochLengthByEpoch(epoch), epochLength)] ++ newEpochLengthActions), true)
618633             }
619634         else if (if (force)
620635             then (finalizationStageOrUnit == unit)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
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)
15+
16+let keyEpochLengthNew = makeString(["%s%s", "epochLength__new"], separator)
17+
18+func keyEpochLengthByEpoch (epoch) = makeString(["%s%d", "epochLength", toString(epoch)], separator)
19+
1520 
1621 let keyCurrentEpoch = makeString(["%s", "currentEpoch"], separator)
1722 
1823 let keyMaxDepth = makeString(["%s", "maxDepth"], separator)
1924 
2025 let keyVotingEmissionCandidateContract = makeString(["%s", "votingEmissionCandidateContract"], separator)
2126 
2227 let keyFactoryContract = makeString(["%s", "factoryContract"], separator)
2328 
2429 let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
2530 
2631 let keyStakingContract = makeString(["%s", "stakingContract"], separator)
2732 
2833 let keyFinalizationStage = makeString(["%s", "finalizationStage"], separator)
2934 
3035 let keyNextPool = makeString(["%s", "nextPool"], separator)
3136 
3237 let keyNextUser = makeString(["%s", "nextUser"], separator)
3338 
3439 let keyStartHeight = makeString(["%s", "startHeight"], separator)
3540 
3641 let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], separator)
3742 
3843 let keyStartHeightUi = makeString(["%s", "startHeightUi"], separator)
3944 
4045 let keyFinalizationShouldBeForced = makeString(["%s", "force"], separator)
4146 
4247 func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], separator)
4348 
4449 
4550 func keyFinalized (epoch) = makeString(["%s%d", "finalized", toString(epoch)], separator)
4651 
4752 
4853 func keyInList (pool) = {
49-    let $t015111551 = pool
50-    let amountAssetId = $t015111551._1
51-    let priceAssetId = $t015111551._2
54+    let $t016931733 = pool
55+    let amountAssetId = $t016931733._1
56+    let priceAssetId = $t016931733._2
5257     makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
5358     }
5459 
5560 
5661 func keyUsed (address,epoch) = makeString(["%s%s%d", "used", toString(address), toString(epoch)], separator)
5762 
5863 
5964 func keyVote (pool,address,epoch) = {
60-    let $t018251865 = pool
61-    let amountAssetId = $t018251865._1
62-    let priceAssetId = $t018251865._2
65+    let $t020072047 = pool
66+    let amountAssetId = $t020072047._1
67+    let priceAssetId = $t020072047._2
6368     makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], separator)
6469     }
6570 
6671 
6772 func keyVotingResult (pool,epoch) = {
68-    let $t020472087 = pool
69-    let amountAssetId = $t020472087._1
70-    let priceAssetId = $t020472087._2
73+    let $t022292269 = pool
74+    let amountAssetId = $t022292269._1
75+    let priceAssetId = $t022292269._2
7176     makeString(["%s%s%s%d", "votingResult", amountAssetId, priceAssetId, toString(epoch)], separator)
7277     }
7378 
7479 
7580 func keyPoolShare (pool,epoch) = {
76-    let $t022522292 = pool
77-    let amountAssetId = $t022522292._1
78-    let priceAssetId = $t022522292._2
81+    let $t024342474 = pool
82+    let amountAssetId = $t024342474._1
83+    let priceAssetId = $t024342474._2
7984     makeString(["%s%s%s%d", "poolShare", amountAssetId, priceAssetId, toString(epoch)], separator)
8085     }
8186 
8287 
8388 func keyTotalVotes (epoch) = makeString(["%s%d", "totalVotes", toString(epoch)], separator)
8489 
8590 
8691 func getValueOrFail (address,key,type) = {
8792     let error = makeString(["mandatory ", toString(address), ".", key, " is not defined"], "")
8893     valueOrErrorMessage(    match type {
8994         case str: String => 
9095             getString(address, key)
9196         case int: Int => 
9297             getInteger(address, key)
9398         case _ => 
9499             throw("invalid entry type")
95100     }, error)
96101     }
97102 
98103 
99104 func getStrOrFail (address,key) = {
100105     let @ = getValueOrFail(address, key, "")
101106     if ($isInstanceOf(@, "String"))
102107         then @
103108         else throw(($getType(@) + " couldn't be cast to String"))
104109     }
105110 
106111 
107112 func getIntOrFail (address,key) = {
108113     let @ = getValueOrFail(address, key, 0)
109114     if ($isInstanceOf(@, "Int"))
110115         then @
111116         else throw(($getType(@) + " couldn't be cast to Int"))
112117     }
113118 
114119 
115120 func poolToString (pool) = ((pool._1 + separator) + pool._2)
116121 
117122 
118123 func stringToPool (str) = {
119124     let parts = split(str, separator)
120125     if ((size(parts) == 2))
121126         then $Tuple2(parts[0], parts[1])
122127         else throw("invalid pool string")
123128     }
124129 
125130 
126131 func getLpAssetByPoolAssets (amountAssetId,priceAssetId) = {
127132     func keyMappingsBaseAsset2internalId (baseAssetStr) =     ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
128133 
129134     func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) =     (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
130135 
131136     func keyMappingPoolContractToLPAsset (poolContractAddress) =     (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
132137 
133138     let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
134139     let amountAssetInternalId = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amountAssetId))
135140     let priceAssetInternalId = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAssetId))
136141     let poolContractAddress = getStrOrFail(factoryContract, keyMappingPoolAssetsToPoolContractAddress(amountAssetInternalId, priceAssetInternalId))
137142     let lpAssetId = getStrOrFail(factoryContract, keyMappingPoolContractToLPAsset(poolContractAddress))
138143     lpAssetId
139144     }
140145 
141146 
142147 func checkWxEmissionPoolLabel (pool) = {
143-    let $t045344574 = pool
144-    let amountAssetId = $t045344574._1
145-    let priceAssetId = $t045344574._2
148+    let $t047164756 = pool
149+    let amountAssetId = $t047164756._1
150+    let priceAssetId = $t047164756._2
146151     let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
147152     let @ = invoke(factoryContract, "checkWxEmissionPoolLabel", [amountAssetId, priceAssetId], nil)
148153     if ($isInstanceOf(@, "Boolean"))
149154         then @
150155         else throw(($getType(@) + " couldn't be cast to Boolean"))
151156     }
152157 
153158 
154159 let poolsListName = "pools"
155160 
156161 func getVotesListName (pool) = {
157-    let $t048754915 = pool
158-    let amountAssetId = $t048754915._1
159-    let priceAssetId = $t048754915._2
162+    let $t050575097 = pool
163+    let amountAssetId = $t050575097._1
164+    let priceAssetId = $t050575097._2
160165     makeString(["votes", amountAssetId, priceAssetId], separator)
161166     }
162167 
163168 
164169 func keyListHead (listName) = {
165170     let meta = if ((listName == poolsListName))
166171         then "%s%s"
167172         else "%s%s%s%s"
168173     makeString([meta, listName, "head"], separator)
169174     }
170175 
171176 
172177 func keyListSize (listName) = {
173178     let meta = if ((listName == poolsListName))
174179         then "%s%s"
175180         else "%s%s%s%s"
176181     makeString([meta, listName, "size"], separator)
177182     }
178183 
179184 
180185 func keyListPrev (listName,id) = {
181186     let meta = if ((listName == poolsListName))
182187         then "%s%s%s%s"
183188         else "%s%s%s%s%s"
184189     makeString([meta, listName, id, "prev"], separator)
185190     }
186191 
187192 
188193 func keyListNext (listName,id) = {
189194     let meta = if ((listName == poolsListName))
190195         then "%s%s%s%s"
191196         else "%s%s%s%s%s"
192197     makeString([meta, listName, id, "next"], separator)
193198     }
194199 
195200 
196201 func containsNode (listName,id) = {
197202     let headOrUnit = getString(this, keyListHead(listName))
198203     let prevOrUnit = getString(this, keyListPrev(listName, id))
199204     let nextOrUnit = getString(this, keyListNext(listName, id))
200205     if (if ((id == valueOrElse(headOrUnit, "")))
201206         then true
202207         else (prevOrUnit != unit))
203208         then true
204209         else (nextOrUnit != unit)
205210     }
206211 
207212 
208213 func insertNodeActions (listName,id) = {
209214     let headOrUnit = getString(this, keyListHead(listName))
210215     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
211216     let checkNode = if (!(containsNode(listName, id)))
212217         then true
213218         else throw("Node exists")
214219     if ((checkNode == checkNode))
215220         then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
216221             then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
217222             else nil)) ++ [StringEntry(keyListHead(listName), id)])
218223         else throw("Strict value is not equal to itself.")
219224     }
220225 
221226 
222227 func deleteNodeActions (listName,id) = {
223228     let headOrUnit = getString(this, keyListHead(listName))
224229     let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
225230     let prevOrUnit = getString(this, keyListPrev(listName, id))
226231     let nextOrUnit = getString(this, keyListNext(listName, id))
227232     ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
228233         then (nextOrUnit != unit)
229234         else false)
230235         then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
231236         else if ((nextOrUnit != unit))
232237             then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
233238             else if ((prevOrUnit != unit))
234239                 then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
235240                 else if ((id == valueOrElse(headOrUnit, "")))
236241                     then [DeleteEntry(keyListHead(listName))]
237242                     else throw(((("invalid node: " + listName) + ".") + id))))
238243     }
239244 
240245 
241246 func keyManagerPublicKey () = "%s__managerPublicKey"
242247 
243248 
244249 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
245250 
246251 
247252 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
248253     case s: String => 
249254         fromBase58String(s)
250255     case _: Unit => 
251256         unit
252257     case _ => 
253258         throw("Match error")
254259 }
255260 
256261 
257262 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
258263     case s: String => 
259264         fromBase58String(s)
260265     case _: Unit => 
261266         unit
262267     case _ => 
263268         throw("Match error")
264269 }
265270 
266271 
267272 let permissionDeniedError = throw("Permission denied")
268273 
269274 func mustThis (i) = if ((i.caller == this))
270275     then true
271276     else permissionDeniedError
272277 
273278 
274279 func mustManager (i) = match managerPublicKeyOrUnit() {
275280     case pk: ByteVector => 
276281         if ((i.callerPublicKey == pk))
277282             then true
278283             else permissionDeniedError
279284     case _: Unit => 
280285         mustThis(i)
281286     case _ => 
282287         throw("Match error")
283288 }
284289 
285290 
286291 @Callable(i)
287292 func setManager (pendingManagerPublicKey) = {
288293     let checkCaller = mustManager(i)
289294     if ((checkCaller == checkCaller))
290295         then {
291296             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
292297             if ((checkManagerPublicKey == checkManagerPublicKey))
293298                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
294299                 else throw("Strict value is not equal to itself.")
295300             }
296301         else throw("Strict value is not equal to itself.")
297302     }
298303 
299304 
300305 
301306 @Callable(i)
302307 func confirmManager () = {
303308     let pm = pendingManagerPublicKeyOrUnit()
304309     let hasPM = if (isDefined(pm))
305310         then true
306311         else throw("No pending manager")
307312     if ((hasPM == hasPM))
308313         then {
309314             let checkPM = if ((i.callerPublicKey == value(pm)))
310315                 then true
311316                 else throw("You are not pending manager")
312317             if ((checkPM == checkPM))
313318                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
314319                 else throw("Strict value is not equal to itself.")
315320             }
316321         else throw("Strict value is not equal to itself.")
317322     }
318323 
319324 
320325 
321326 @Callable(i)
322327 func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
323328     let boostingContractAddress = valueOrErrorMessage(addressFromString(getStrOrFail(this, keyBoostingContract)), "invalid boosting contract address")
324329     $Tuple2(nil, {
325330         let @ = invoke(boostingContractAddress, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
326331         if ($isInstanceOf(@, "Int"))
327332             then @
328333             else throw(($getType(@) + " couldn't be cast to Int"))
329334         })
330335     }
331336 
332337 
333338 
334339 @Callable(i)
335340 func constructor (factoryContract,votingEmissionCandidateContract,boostingContract,stakingContract,epochLength) = {
336341     let checks = [mustManager(i), if ((addressFromString(factoryContract) != unit))
337342         then true
338343         else "invalid factory contract address", if ((addressFromString(votingEmissionCandidateContract) != unit))
339344         then true
340345         else "invalid voting emission candidate contract address", if ((addressFromString(boostingContract) != unit))
341346         then true
342347         else "invalid boosting contract address", if ((addressFromString(stakingContract) != unit))
343348         then true
344349         else "invalid staking contract address", if ((epochLength > 0))
345350         then true
346351         else throw("invalid epoch length")]
347352     if ((checks == checks))
348353         then $Tuple2([StringEntry(keyFactoryContract, factoryContract), StringEntry(keyVotingEmissionCandidateContract, votingEmissionCandidateContract), StringEntry(keyBoostingContract, boostingContract), StringEntry(keyStakingContract, stakingContract), IntegerEntry(keyEpochLength, epochLength)], unit)
349354         else throw("Strict value is not equal to itself.")
350355     }
351356 
352357 
353358 
354359 @Callable(i)
355360 func create (amountAssetId,priceAssetId) = {
356361     let checks = [if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionCandidateContract), "")))
357362         then true
358363         else mustManager(i)]
359364     if ((checks == checks))
360365         then {
361366             let pool = $Tuple2(amountAssetId, priceAssetId)
362367             let inListActions = ([BooleanEntry(keyInList(pool), true)] ++ insertNodeActions(poolsListName, poolToString(pool)))
363368             let currentEpochIsNotDefined = (getInteger(this, keyCurrentEpoch) == unit)
364369             let startHeightActions = if (currentEpochIsNotDefined)
365370                 then {
366371                     let epoch = 0
367372 [IntegerEntry(keyCurrentEpoch, epoch), IntegerEntry(keyStartHeightByEpoch(epoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, height)]
368373                     }
369374                 else nil
370375             $Tuple2((inListActions ++ startHeightActions), unit)
371376             }
372377         else throw("Strict value is not equal to itself.")
373378     }
374379 
375380 
376381 
377382 @Callable(i)
378383 func vote (amountAssetId,priceAssetId,amount) = {
379384     let pool = $Tuple2(amountAssetId, priceAssetId)
380385     let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
381386     let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
382387     let epochLength = getIntOrFail(this, keyEpochLength)
383388     let endHeight = (startHeight + epochLength)
384389     let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
385390     let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
386391     let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
387392     let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
388393     let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
389394     let gwxAmountAtEndTotal = {
390395         let @ = invoke(this, "getUserGwxAmountAtHeight", [toBase58String(i.caller.bytes), endHeight], nil)
391396         if ($isInstanceOf(@, "Int"))
392397             then @
393398             else throw(($getType(@) + " couldn't be cast to Int"))
394399         }
395400     let available = (gwxAmountAtEndTotal - used)
396401     let newVote = (vote + amount)
397402     let wxEmission = checkWxEmissionPoolLabel(pool)
398403     let checks = [if ((getBoolean(keyInList(pool)) != unit))
399404         then true
400405         else throw("invalid assets"), if ((endHeight > height))
401406         then true
402407         else throw("invalid height"), if ((finalizationStageOrUnit == unit))
403408         then true
404409         else throw("finalization in progress"), if ((gwxAmountAtEndTotal > 0))
405410         then true
406411         else throw("you do not have gWX"), if (if ((amount > 0))
407412         then (available >= amount)
408413         else false)
409414         then true
410415         else throw("invalid amount"), if (wxEmission)
411416         then true
412417         else throw("pool hasn't WX_EMISSION label")]
413418     if ((checks == checks))
414419         then {
415420             let votesListName = getVotesListName(pool)
416421             let userAddressStr = toString(i.caller)
417422             let votesListActions = if (containsNode(votesListName, userAddressStr))
418423                 then nil
419424                 else insertNodeActions(votesListName, userAddressStr)
420425             $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)
421426             }
422427         else throw("Strict value is not equal to itself.")
423428     }
424429 
425430 
426431 
427432 @Callable(i)
428433 func cancelVote (amountAssetId,priceAssetId) = {
429434     let pool = $Tuple2(amountAssetId, priceAssetId)
430435     let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
431436     let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
432437     let epochLength = getIntOrFail(this, keyEpochLength)
433438     let endHeight = (startHeight + epochLength)
434439     let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
435440     let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
436441     let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
437442     let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
438443     let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
439444     let checks = [if ((getBoolean(keyInList(pool)) != unit))
440445         then true
441446         else throw("invalid assets"), if ((endHeight > height))
442447         then true
443448         else throw("invalid height"), if ((finalizationStageOrUnit == unit))
444449         then true
445450         else throw("finalization in progress"), if ((vote > 0))
446451         then true
447452         else throw("no vote")]
448453     if ((checks == checks))
449454         then {
450455             let votesListName = getVotesListName(pool)
451456             let userAddressStr = toString(i.caller)
452457             $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)
453458             }
454459         else throw("Strict value is not equal to itself.")
455460     }
456461 
457462 
458463 
459464 @Callable(i)
460465 func setEpochLength (newEpochLength) = {
461466     let checks = [mustManager(i), if ((newEpochLength > 0))
462467         then true
463468         else throw("invalid epoch length")]
464469     if ((checks == checks))
465-        then $Tuple2([IntegerEntry(keyEpochLength, newEpochLength)], unit)
470+        then $Tuple2([IntegerEntry(keyEpochLengthNew, newEpochLength)], unit)
466471         else throw("Strict value is not equal to itself.")
467472     }
468473 
469474 
470475 
471476 @Callable(i)
472477 func setMaxDepth (newMaxDepth) = {
473478     let checks = [mustManager(i), if ((newMaxDepth > 0))
474479         then true
475480         else throw("invalid max depth")]
476481     if ((checks == checks))
477482         then $Tuple2([IntegerEntry(keyMaxDepth, newMaxDepth)], unit)
478483         else throw("Strict value is not equal to itself.")
479484     }
480485 
481486 
482487 
483488 @Callable(i)
484489 func processVoteINTERNAL (poolStr,userAddressStr) = {
485490     let checkCaller = mustThis(i)
486491     if ((checkCaller == checkCaller))
487492         then {
488493             let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), ("processVoteINTERNAL: invalid user address " + userAddressStr))
489494             let epoch = getIntOrFail(this, keyCurrentEpoch)
490495             let epochPrevious = (epoch - 1)
491496             let epochLength = getIntOrFail(this, keyEpochLength)
492497             let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
493498             let endHeight = (startHeight + epochLength)
494499             let startHeightPrevious = getIntOrFail(this, keyStartHeightByEpoch(epochPrevious))
495-            let endHeightPrevious = (startHeightPrevious + epochLength)
500+            let epochLengthPrevious = getIntOrFail(this, keyEpochLengthByEpoch(epochPrevious))
501+            let endHeightPrevious = (startHeightPrevious + epochLengthPrevious)
496502             let checkTargetEpoch = if ((epochPrevious >= 0))
497503                 then true
498504                 else throw("processVoteINTERNAL: invalid previous epoch")
499505             if ((checkTargetEpoch == checkTargetEpoch))
500506                 then {
501507                     let pool = stringToPool(poolStr)
502-                    let $t01727017310 = pool
503-                    let amountAssetId = $t01727017310._1
504-                    let priceAssetId = $t01727017310._2
508+                    let $t01754817588 = pool
509+                    let amountAssetId = $t01754817588._1
510+                    let priceAssetId = $t01754817588._2
505511                     let wxEmission = checkWxEmissionPoolLabel(pool)
506512                     let gwxAmountAtEndTotal = {
507513                         let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeight], nil)
508514                         if ($isInstanceOf(@, "Int"))
509515                             then @
510516                             else throw(($getType(@) + " couldn't be cast to Int"))
511517                         }
512518                     let gwxAmountAtEndTotalPrevious = {
513519                         let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeightPrevious], nil)
514520                         if ($isInstanceOf(@, "Int"))
515521                             then @
516522                             else throw(($getType(@) + " couldn't be cast to Int"))
517523                         }
518524                     let totalVotes = valueOrElse(getInteger(keyTotalVotes(epoch)), 0)
519525                     let votingResult = valueOrElse(getInteger(keyVotingResult(pool, epoch)), 0)
520526                     let votePrevious = valueOrErrorMessage(getInteger(keyVote(pool, userAddress, epochPrevious)), (((("processVoteINTERNAL " + poolStr) + " ") + userAddressStr) + ": no previous vote"))
521527                     let used = valueOrElse(getInteger(this, keyUsed(userAddress, epoch)), 0)
522528                     let newVote = if ((gwxAmountAtEndTotalPrevious > 0))
523529                         then fraction(votePrevious, gwxAmountAtEndTotal, gwxAmountAtEndTotalPrevious)
524530                         else 0
525531                     let actions = if (if ((newVote > 0))
526532                         then wxEmission
527533                         else false)
528534                         then [IntegerEntry(keyVote(pool, userAddress, epoch), newVote), IntegerEntry(keyTotalVotes(epoch), (totalVotes + newVote)), IntegerEntry(keyVotingResult(pool, epoch), (votingResult + newVote)), IntegerEntry(keyUsed(userAddress, epoch), (used + newVote))]
529535                         else deleteNodeActions(getVotesListName(pool), userAddressStr)
530536                     $Tuple2(actions, unit)
531537                     }
532538                 else throw("Strict value is not equal to itself.")
533539             }
534540         else throw("Strict value is not equal to itself.")
535541     }
536542 
537543 
538544 
539545 @Callable(i)
540546 func processPoolINTERNAL (poolStr,force) = {
541547     let checkCaller = mustThis(i)
542548     if ((checkCaller == checkCaller))
543549         then {
544550             let targetEpoch = {
545551                 let currentEpoch = getIntOrFail(this, keyCurrentEpoch)
546552                 if (force)
547553                     then currentEpoch
548554                     else (currentEpoch - 1)
549555                 }
550556             let checkTargetEpoch = if ((targetEpoch >= 0))
551557                 then true
552558                 else throw("processPoolINTERNAL: invalid target epoch")
553559             if ((checkTargetEpoch == checkTargetEpoch))
554560                 then {
555561                     let pool = stringToPool(poolStr)
556-                    let $t01903619076 = pool
557-                    let amountAssetId = $t01903619076._1
558-                    let priceAssetId = $t01903619076._2
562+                    let $t01931419354 = pool
563+                    let amountAssetId = $t01931419354._1
564+                    let priceAssetId = $t01931419354._2
559565                     let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract))
560566                     let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
561567                     let lpAssetId = getLpAssetByPoolAssets(amountAssetId, priceAssetId)
562568                     let r = {
563569                         let @ = invoke(stakingContract, "usersListTraversal", [lpAssetId], nil)
564570                         if ($isInstanceOf(@, "Boolean"))
565571                             then @
566572                             else throw(($getType(@) + " couldn't be cast to Boolean"))
567573                         }
568574                     if ((r == r))
569575                         then if (r)
570576                             then $Tuple2(nil, true)
571577                             else {
572578                                 let wxEmission = checkWxEmissionPoolLabel(pool)
573579                                 let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(targetEpoch)), 0)
574580                                 let votingResult = valueOrElse(getInteger(this, keyVotingResult(pool, targetEpoch)), 0)
575581                                 let share = if (if ((totalVotes == 0))
576582                                     then true
577583                                     else !(wxEmission))
578584                                     then 0
579585                                     else fraction(votingResult, poolWeightMult, totalVotes)
580586                                 let modifyWeightInv = invoke(factoryContract, "modifyWeight", [lpAssetId, share], nil)
581587                                 if ((modifyWeightInv == modifyWeightInv))
582588                                     then {
583589                                         let poolsListActions = if (if (wxEmission)
584590                                             then true
585591                                             else force)
586592                                             then nil
587593                                             else ([DeleteEntry(keyInList(pool))] ++ deleteNodeActions(poolsListName, poolStr))
588594                                         $Tuple2(([IntegerEntry(keyPoolShare(pool, targetEpoch), share)] ++ poolsListActions), false)
589595                                         }
590596                                     else throw("Strict value is not equal to itself.")
591597                                 }
592598                         else throw("Strict value is not equal to itself.")
593599                     }
594600                 else throw("Strict value is not equal to itself.")
595601             }
596602         else throw("Strict value is not equal to itself.")
597603     }
598604 
599605 
600606 
601607 @Callable(i)
602608 func finalizeHelper () = {
603609     let force = valueOrElse(getBoolean(keyFinalizationShouldBeForced), false)
604610     let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
605611     let previousEpoch = (epoch - 1)
606612     let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
607613     let epochLength = getIntOrFail(this, keyEpochLength)
608614     let endHeight = (startHeight + epochLength)
609615     let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
610616     if (if (if ((height >= endHeight))
611617         then (finalizationStageOrUnit == unit)
612618         else false)
613619         then !(force)
614620         else false)
615621         then {
616622             let newEpoch = (epoch + 1)
617-            $Tuple2([IntegerEntry(keyStartHeightByEpoch(newEpoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpoch, newEpoch), IntegerEntry(keyFinalizationStage, finalizationStageTotal)], true)
623+            let newEpochLengthOption = getInteger(this, keyEpochLengthNew)
624+            let newEpochLengthActions =             match newEpochLengthOption {
625+                case newEpochLength: Int => 
626+[IntegerEntry(keyEpochLength, newEpochLength), DeleteEntry(keyEpochLengthNew)]
627+                case _: Unit => 
628+                    nil
629+                case _ => 
630+                    throw("Match error")
631+            }
632+            $Tuple2(([IntegerEntry(keyStartHeightByEpoch(newEpoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpoch, newEpoch), IntegerEntry(keyFinalizationStage, finalizationStageTotal), IntegerEntry(keyEpochLengthByEpoch(epoch), epochLength)] ++ newEpochLengthActions), true)
618633             }
619634         else if (if (force)
620635             then (finalizationStageOrUnit == unit)
621636             else false)
622637             then $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares)], true)
623638             else if ((finalizationStageOrUnit == unit))
624639                 then $Tuple2(nil, false)
625640                 else if ((finalizationStageOrUnit == finalizationStageTotal))
626641                     then {
627642                         let poolOrUnit = getString(keyNextPool)
628643                         let userOrUnit = getString(keyNextUser)
629644                         match poolOrUnit {
630645                             case _: Unit => 
631646                                 match getString(keyListHead(poolsListName)) {
632647                                     case _: Unit => 
633648                                         $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
634649                                     case poolsHeadStr: String => 
635650                                         $Tuple2([StringEntry(keyNextPool, poolsHeadStr)], true)
636651                                     case _ => 
637652                                         throw("Match error")
638653                                 }
639654                             case poolStr: String => 
640655                                 let pool = stringToPool(poolStr)
641656                                 let nextUserOrUnit =                                 match userOrUnit {
642657                                     case _: Unit => 
643658                                         getString(keyListHead(getVotesListName(pool)))
644659                                     case user: String => 
645660                                         let next = getString(keyListNext(getVotesListName(pool), user))
646661                                         if ((next == next))
647662                                             then {
648663                                                 let processVoteInv = invoke(this, "processVoteINTERNAL", [poolStr, user], nil)
649664                                                 if ((processVoteInv == processVoteInv))
650665                                                     then next
651666                                                     else throw("Strict value is not equal to itself.")
652667                                                 }
653668                                             else throw("Strict value is not equal to itself.")
654669                                     case _ => 
655670                                         throw("Match error")
656671                                 }
657672                                 match nextUserOrUnit {
658673                                     case _: Unit => 
659674                                         let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
660675                                         match nextPoolOrUnit {
661676                                             case _: Unit => 
662677                                                 $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
663678                                             case s: String => 
664679                                                 $Tuple2([StringEntry(keyNextPool, s), DeleteEntry(keyNextUser)], true)
665680                                             case _ => 
666681                                                 throw("Match error")
667682                                         }
668683                                     case nextUser: String => 
669684                                         $Tuple2([StringEntry(keyNextUser, nextUser)], true)
670685                                     case _ => 
671686                                         throw("Match error")
672687                                 }
673688                             case _ => 
674689                                 throw("Match error")
675690                         }
676691                         }
677692                     else if ((finalizationStageOrUnit == finalizationStageShares))
678693                         then {
679694                             let poolOrUnit = getString(keyNextPool)
680695                             match poolOrUnit {
681696                                 case _: Unit => 
682697                                     match getString(keyListHead(poolsListName)) {
683698                                         case _: Unit => 
684699                                             let actions = if (force)
685700                                                 then [DeleteEntry(keyFinalizationStage), DeleteEntry(keyFinalizationShouldBeForced)]
686701                                                 else [DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight)]
687702                                             $Tuple2(actions, true)
688703                                         case nextPoolStr: String => 
689704                                             $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
690705                                         case _ => 
691706                                             throw("Match error")
692707                                     }
693708                                 case poolStr: String => 
694709                                     let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
695710                                     if ((nextPoolOrUnit == nextPoolOrUnit))
696711                                         then {
697712                                             let r = {
698713                                                 let @ = invoke(this, "processPoolINTERNAL", [poolStr, force], nil)
699714                                                 if ($isInstanceOf(@, "Boolean"))
700715                                                     then @
701716                                                     else throw(($getType(@) + " couldn't be cast to Boolean"))
702717                                                 }
703718                                             if ((r == r))
704719                                                 then if (r)
705720                                                     then $Tuple2(nil, true)
706721                                                     else                                                     match nextPoolOrUnit {
707722                                                         case _: Unit => 
708723                                                             let actions = if (force)
709724                                                                 then [DeleteEntry(keyFinalizationStage), DeleteEntry(keyFinalizationShouldBeForced), DeleteEntry(keyNextPool)]
710725                                                                 else [DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight), DeleteEntry(keyNextPool)]
711726                                                             $Tuple2(actions, true)
712727                                                         case nextPoolStr: String => 
713728                                                             $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
714729                                                         case _ => 
715730                                                             throw("Match error")
716731                                                     }
717732                                                 else throw("Strict value is not equal to itself.")
718733                                             }
719734                                         else throw("Strict value is not equal to itself.")
720735                                 case _ => 
721736                                     throw("Match error")
722737                             }
723738                             }
724739                         else throw("finalization is broken")
725740     }
726741 
727742 
728743 
729744 @Callable(i)
730745 func finalizeWrapper (counter) = {
731746     let result = {
732747         let @ = invoke(this, "finalizeHelper", nil, nil)
733748         if ($isInstanceOf(@, "Boolean"))
734749             then @
735750             else throw(($getType(@) + " couldn't be cast to Boolean"))
736751         }
737752     if ((result == result))
738753         then if (!(result))
739754             then if ((counter == 0))
740755                 then throw("Current voting is not over yet")
741756                 else $Tuple2(nil, unit)
742757             else {
743758                 let maxDepth = valueOrElse(getInteger(this, keyMaxDepth), maxDepthDefault)
744759                 if ((maxDepth > counter))
745760                     then {
746761                         let inv = invoke(this, "finalizeWrapper", [(counter + 1)], nil)
747762                         if ((inv == inv))
748763                             then $Tuple2(nil, unit)
749764                             else throw("Strict value is not equal to itself.")
750765                         }
751766                     else $Tuple2(nil, unit)
752767                 }
753768         else throw("Strict value is not equal to itself.")
754769     }
755770 
756771 
757772 
758773 @Callable(i)
759774 func finalize () = {
760775     let inv = invoke(this, "finalizeWrapper", [0], nil)
761776     if ((inv == inv))
762777         then $Tuple2(nil, unit)
763778         else throw("Strict value is not equal to itself.")
764779     }
765780 
766781 
767782 
768783 @Callable(i)
769784 func containsNodeREADONLY (listName,id) = $Tuple2(nil, containsNode(listName, id))
770785 
771786 
772787 
773788 @Callable(i)
774789 func insertNode (listName,id) = {
775790     let checkCaller = mustManager(i)
776791     if ((checkCaller == checkCaller))
777792         then $Tuple2(insertNodeActions(listName, id), unit)
778793         else throw("Strict value is not equal to itself.")
779794     }
780795 
781796 
782797 
783798 @Callable(i)
784799 func deleteNode (listName,id) = {
785800     let checkCaller = mustManager(i)
786801     if ((checkCaller == checkCaller))
787802         then $Tuple2(deleteNodeActions(listName, id), unit)
788803         else throw("Strict value is not equal to itself.")
789804     }
790805 
791806 
792807 @Verifier(tx)
793808 func verify () = {
794809     let targetPublicKey =     match managerPublicKeyOrUnit() {
795810         case pk: ByteVector => 
796811             pk
797812         case _: Unit => 
798813             tx.senderPublicKey
799814         case _ => 
800815             throw("Match error")
801816     }
802817     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
803818     }
804819 
github/deemru/w8io/026f985 
101.63 ms ◑