tx · 9EmYibUukjrhExF2mDz1tMrxeVZNbkr5UzvzWQU2U25s

3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA:  -0.02800000 Waves

2022.08.17 15:34 [2188469] smart account 3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA > SELF 0.00000000 Waves

{ "type": 13, "id": "9EmYibUukjrhExF2mDz1tMrxeVZNbkr5UzvzWQU2U25s", "fee": 2800000, "feeAssetId": null, "timestamp": 1660739767999, "version": 1, "sender": "3Mp3nG9T5fKGziHW8mcCqx3jMFx3towh3WA", "senderPublicKey": "D46gQxzmdzdCTYRg6dMcwFoUrc6ZmxF6GKd5ZoTkvzp1", "proofs": [ "ishH8wEfCcaakDKdoVVU9gE86nb5rkGVEYmjAyXwCNueWcu57MYNHKZDzowuxjiy7CTfSXBEX13qSkUTL7keXDR" ], "script": "base64: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", "chainId": 84, "height": 2188469, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: 9iCrmEypyWq8mkwSL7qywLhYBrSdLZ6CsRQ2vMxaT6jN Next: 2vyYkZp4HF8Fq8RcgVPTwG1FMP26XuELpzZEhUuieEDg Diff:
OldNewDifferences
517517 let votingResult = valueOrElse(getInteger(keyVotingResult(pool, epoch)), 0)
518518 let votePrevious = valueOrErrorMessage(getInteger(keyVote(pool, userAddress, epochPrevious)), (((("processVoteINTERNAL " + poolStr) + " ") + userAddressStr) + ": no previous vote"))
519519 let used = valueOrElse(getInteger(this, keyUsed(userAddress, epoch)), 0)
520- let newVote = fraction(votePrevious, gwxAmountAtEndTotal, gwxAmountAtEndTotalPrevious)
520+ let newVote = if ((gwxAmountAtEndTotalPrevious > 0))
521+ then fraction(votePrevious, gwxAmountAtEndTotal, gwxAmountAtEndTotalPrevious)
522+ else 0
521523 let actions = if (if ((newVote > 0))
522524 then wxEmission
523525 else false)
544546 if ((checkTargetEpoch == checkTargetEpoch))
545547 then {
546548 let pool = stringToPool(poolStr)
547- let $t01875218792 = pool
548- let amountAssetId = $t01875218792._1
549- let priceAssetId = $t01875218792._2
549+ let $t01880118841 = pool
550+ let amountAssetId = $t01880118841._1
551+ let priceAssetId = $t01880118841._2
550552 let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract))
551553 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
552554 let lpAssetId = getLpAssetByPoolAssets(amountAssetId, priceAssetId)
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)
1515
1616 let keyCurrentEpoch = makeString(["%s", "currentEpoch"], separator)
1717
1818 let keyMaxDepth = makeString(["%s", "maxDepth"], separator)
1919
2020 let keyVotingEmissionCandidateContract = makeString(["%s", "votingEmissionCandidateContract"], separator)
2121
2222 let keyFactoryContract = makeString(["%s", "factoryContract"], separator)
2323
2424 let keyBoostingContract = makeString(["%s", "boostingContract"], separator)
2525
2626 let keyStakingContract = makeString(["%s", "stakingContract"], separator)
2727
2828 let keyFinalizationStage = makeString(["%s", "finalizationStage"], separator)
2929
3030 let keyNextPool = makeString(["%s", "nextPool"], separator)
3131
3232 let keyNextUser = makeString(["%s", "nextUser"], separator)
3333
3434 let keyStartHeight = makeString(["%s", "startHeight"], separator)
3535
3636 let keyCurrentEpochUi = makeString(["%s", "currentEpochUi"], separator)
3737
3838 let keyStartHeightUi = makeString(["%s", "startHeightUi"], separator)
3939
4040 func keyStartHeightByEpoch (epoch) = makeString(["%s%d", "startHeight", toString(epoch)], separator)
4141
4242
4343 func keyFinalized (epoch) = makeString(["%s%d", "finalized", toString(epoch)], separator)
4444
4545
4646 func keyInList (pool) = {
4747 let $t014361476 = pool
4848 let amountAssetId = $t014361476._1
4949 let priceAssetId = $t014361476._2
5050 makeString(["%s%s%s", "inList", amountAssetId, priceAssetId], separator)
5151 }
5252
5353
5454 func keyUsed (address,epoch) = makeString(["%s%s%d", "used", toString(address), toString(epoch)], separator)
5555
5656
5757 func keyVote (pool,address,epoch) = {
5858 let $t017501790 = pool
5959 let amountAssetId = $t017501790._1
6060 let priceAssetId = $t017501790._2
6161 makeString(["%s%s%s%s%d", "vote", amountAssetId, priceAssetId, toString(address), toString(epoch)], separator)
6262 }
6363
6464
6565 func keyVotingResult (pool,epoch) = {
6666 let $t019722012 = pool
6767 let amountAssetId = $t019722012._1
6868 let priceAssetId = $t019722012._2
6969 makeString(["%s%s%s%d", "votingResult", amountAssetId, priceAssetId, toString(epoch)], separator)
7070 }
7171
7272
7373 func keyPoolShare (pool,epoch) = {
7474 let $t021772217 = pool
7575 let amountAssetId = $t021772217._1
7676 let priceAssetId = $t021772217._2
7777 makeString(["%s%s%s%d", "poolShare", amountAssetId, priceAssetId, toString(epoch)], separator)
7878 }
7979
8080
8181 func keyTotalVotes (epoch) = makeString(["%s%d", "totalVotes", toString(epoch)], separator)
8282
8383
8484 func getValueOrFail (address,key,type) = {
8585 let error = makeString(["mandatory ", toString(address), ".", key, " is not defined"], "")
8686 valueOrErrorMessage( match type {
8787 case str: String =>
8888 getString(address, key)
8989 case int: Int =>
9090 getInteger(address, key)
9191 case _ =>
9292 throw("invalid entry type")
9393 }, error)
9494 }
9595
9696
9797 func getStrOrFail (address,key) = {
9898 let @ = getValueOrFail(address, key, "")
9999 if ($isInstanceOf(@, "String"))
100100 then @
101101 else throw(($getType(getValueOrFail(address, key, "")) + " couldn't be cast to String"))
102102 }
103103
104104
105105 func getIntOrFail (address,key) = {
106106 let @ = getValueOrFail(address, key, 0)
107107 if ($isInstanceOf(@, "Int"))
108108 then @
109109 else throw(($getType(getValueOrFail(address, key, 0)) + " couldn't be cast to Int"))
110110 }
111111
112112
113113 func poolToString (pool) = ((pool._1 + separator) + pool._2)
114114
115115
116116 func stringToPool (str) = {
117117 let parts = split(str, separator)
118118 if ((size(parts) == 2))
119119 then $Tuple2(parts[0], parts[1])
120120 else throw("invalid pool string")
121121 }
122122
123123
124124 func getLpAssetByPoolAssets (amountAssetId,priceAssetId) = {
125125 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
126126
127127 func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
128128
129129 func keyMappingPoolContractToLPAsset (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
130130
131131 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
132132 let amountAssetInternalId = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amountAssetId))
133133 let priceAssetInternalId = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAssetId))
134134 let poolContractAddress = getStrOrFail(factoryContract, keyMappingPoolAssetsToPoolContractAddress(amountAssetInternalId, priceAssetInternalId))
135135 let lpAssetId = getStrOrFail(factoryContract, keyMappingPoolContractToLPAsset(poolContractAddress))
136136 lpAssetId
137137 }
138138
139139
140140 func checkWxEmissionPoolLabel (pool) = {
141141 let $t044594499 = pool
142142 let amountAssetId = $t044594499._1
143143 let priceAssetId = $t044594499._2
144144 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
145145 let @ = invoke(factoryContract, "checkWxEmissionPoolLabel", [amountAssetId, priceAssetId], nil)
146146 if ($isInstanceOf(@, "Boolean"))
147147 then @
148148 else throw(($getType(invoke(factoryContract, "checkWxEmissionPoolLabel", [amountAssetId, priceAssetId], nil)) + " couldn't be cast to Boolean"))
149149 }
150150
151151
152152 let poolsListName = "pools"
153153
154154 func getVotesListName (pool) = {
155155 let $t048004840 = pool
156156 let amountAssetId = $t048004840._1
157157 let priceAssetId = $t048004840._2
158158 makeString(["votes", amountAssetId, priceAssetId], separator)
159159 }
160160
161161
162162 func keyListHead (listName) = {
163163 let meta = if ((listName == poolsListName))
164164 then "%s%s"
165165 else "%s%s%s%s"
166166 makeString([meta, listName, "head"], separator)
167167 }
168168
169169
170170 func keyListSize (listName) = {
171171 let meta = if ((listName == poolsListName))
172172 then "%s%s"
173173 else "%s%s%s%s"
174174 makeString([meta, listName, "size"], separator)
175175 }
176176
177177
178178 func keyListPrev (listName,id) = {
179179 let meta = if ((listName == poolsListName))
180180 then "%s%s%s%s"
181181 else "%s%s%s%s%s"
182182 makeString([meta, listName, id, "prev"], separator)
183183 }
184184
185185
186186 func keyListNext (listName,id) = {
187187 let meta = if ((listName == poolsListName))
188188 then "%s%s%s%s"
189189 else "%s%s%s%s%s"
190190 makeString([meta, listName, id, "next"], separator)
191191 }
192192
193193
194194 func containsNode (listName,id) = {
195195 let headOrUnit = getString(this, keyListHead(listName))
196196 let prevOrUnit = getString(this, keyListPrev(listName, id))
197197 let nextOrUnit = getString(this, keyListNext(listName, id))
198198 if (if ((id == valueOrElse(headOrUnit, "")))
199199 then true
200200 else (prevOrUnit != unit))
201201 then true
202202 else (nextOrUnit != unit)
203203 }
204204
205205
206206 func insertNodeActions (listName,id) = {
207207 let headOrUnit = getString(this, keyListHead(listName))
208208 let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
209209 let checkNode = if (!(containsNode(listName, id)))
210210 then true
211211 else throw("Node exists")
212212 if ((checkNode == checkNode))
213213 then (([IntegerEntry(keyListSize(listName), (listSize + 1))] ++ (if ((headOrUnit != unit))
214214 then [StringEntry(keyListNext(listName, id), value(headOrUnit)), StringEntry(keyListPrev(listName, value(headOrUnit)), id)]
215215 else nil)) ++ [StringEntry(keyListHead(listName), id)])
216216 else throw("Strict value is not equal to itself.")
217217 }
218218
219219
220220 func deleteNodeActions (listName,id) = {
221221 let headOrUnit = getString(this, keyListHead(listName))
222222 let listSize = valueOrElse(getInteger(this, keyListSize(listName)), 0)
223223 let prevOrUnit = getString(this, keyListPrev(listName, id))
224224 let nextOrUnit = getString(this, keyListNext(listName, id))
225225 ([IntegerEntry(keyListSize(listName), (listSize - 1))] ++ (if (if ((prevOrUnit != unit))
226226 then (nextOrUnit != unit)
227227 else false)
228228 then [StringEntry(keyListNext(listName, value(prevOrUnit)), value(nextOrUnit)), StringEntry(keyListPrev(listName, value(nextOrUnit)), value(prevOrUnit)), DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, id))]
229229 else if ((nextOrUnit != unit))
230230 then [StringEntry(keyListHead(listName), value(nextOrUnit)), DeleteEntry(keyListNext(listName, id)), DeleteEntry(keyListPrev(listName, value(nextOrUnit)))]
231231 else if ((prevOrUnit != unit))
232232 then [DeleteEntry(keyListPrev(listName, id)), DeleteEntry(keyListNext(listName, value(prevOrUnit)))]
233233 else if ((id == valueOrElse(headOrUnit, "")))
234234 then [DeleteEntry(keyListHead(listName))]
235235 else throw(((("invalid node: " + listName) + ".") + id))))
236236 }
237237
238238
239239 func keyManagerPublicKey () = "%s__managerPublicKey"
240240
241241
242242 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
243243
244244
245245 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
246246 case s: String =>
247247 fromBase58String(s)
248248 case _: Unit =>
249249 unit
250250 case _ =>
251251 throw("Match error")
252252 }
253253
254254
255255 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
256256 case s: String =>
257257 fromBase58String(s)
258258 case _: Unit =>
259259 unit
260260 case _ =>
261261 throw("Match error")
262262 }
263263
264264
265265 let permissionDeniedError = throw("Permission denied")
266266
267267 func mustThis (i) = if ((i.caller == this))
268268 then true
269269 else permissionDeniedError
270270
271271
272272 func mustManager (i) = match managerPublicKeyOrUnit() {
273273 case pk: ByteVector =>
274274 if ((i.callerPublicKey == pk))
275275 then true
276276 else permissionDeniedError
277277 case _: Unit =>
278278 mustThis(i)
279279 case _ =>
280280 throw("Match error")
281281 }
282282
283283
284284 @Callable(i)
285285 func setManager (pendingManagerPublicKey) = {
286286 let checkCaller = mustManager(i)
287287 if ((checkCaller == checkCaller))
288288 then {
289289 let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
290290 if ((checkManagerPublicKey == checkManagerPublicKey))
291291 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
292292 else throw("Strict value is not equal to itself.")
293293 }
294294 else throw("Strict value is not equal to itself.")
295295 }
296296
297297
298298
299299 @Callable(i)
300300 func confirmManager () = {
301301 let pm = pendingManagerPublicKeyOrUnit()
302302 let hasPM = if (isDefined(pm))
303303 then true
304304 else throw("No pending manager")
305305 if ((hasPM == hasPM))
306306 then {
307307 let checkPM = if ((i.callerPublicKey == value(pm)))
308308 then true
309309 else throw("You are not pending manager")
310310 if ((checkPM == checkPM))
311311 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
312312 else throw("Strict value is not equal to itself.")
313313 }
314314 else throw("Strict value is not equal to itself.")
315315 }
316316
317317
318318
319319 @Callable(i)
320320 func getUserGwxAmountAtHeight (userAddress,targetHeight) = {
321321 let boostingContractAddress = valueOrErrorMessage(addressFromString(getStrOrFail(this, keyBoostingContract)), "invalid boosting contract address")
322322 $Tuple2(nil, {
323323 let @ = invoke(boostingContractAddress, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)
324324 if ($isInstanceOf(@, "Int"))
325325 then @
326326 else throw(($getType(invoke(boostingContractAddress, "getUserGwxAmountAtHeightREADONLY", [userAddress, targetHeight], nil)) + " couldn't be cast to Int"))
327327 })
328328 }
329329
330330
331331
332332 @Callable(i)
333333 func constructor (factoryContract,votingEmissionCandidateContract,boostingContract,stakingContract,epochLength) = {
334334 let checks = [mustManager(i), if ((addressFromString(factoryContract) != unit))
335335 then true
336336 else "invalid factory contract address", if ((addressFromString(votingEmissionCandidateContract) != unit))
337337 then true
338338 else "invalid voting emission candidate contract address", if ((addressFromString(boostingContract) != unit))
339339 then true
340340 else "invalid boosting contract address", if ((addressFromString(stakingContract) != unit))
341341 then true
342342 else "invalid staking contract address", if ((epochLength > 0))
343343 then true
344344 else throw("invalid epoch length")]
345345 if ((checks == checks))
346346 then $Tuple2([StringEntry(keyFactoryContract, factoryContract), StringEntry(keyVotingEmissionCandidateContract, votingEmissionCandidateContract), StringEntry(keyBoostingContract, boostingContract), StringEntry(keyStakingContract, stakingContract), IntegerEntry(keyEpochLength, epochLength)], unit)
347347 else throw("Strict value is not equal to itself.")
348348 }
349349
350350
351351
352352 @Callable(i)
353353 func create (amountAssetId,priceAssetId) = {
354354 let checks = [if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionCandidateContract), "")))
355355 then true
356356 else mustManager(i)]
357357 if ((checks == checks))
358358 then {
359359 let pool = $Tuple2(amountAssetId, priceAssetId)
360360 let inListActions = ([BooleanEntry(keyInList(pool), true)] ++ insertNodeActions(poolsListName, poolToString(pool)))
361361 let currentEpochIsNotDefined = (getInteger(this, keyCurrentEpoch) == unit)
362362 let startHeightActions = if (currentEpochIsNotDefined)
363363 then {
364364 let epoch = 0
365365 [IntegerEntry(keyCurrentEpoch, epoch), IntegerEntry(keyStartHeightByEpoch(epoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, height)]
366366 }
367367 else nil
368368 $Tuple2((inListActions ++ startHeightActions), unit)
369369 }
370370 else throw("Strict value is not equal to itself.")
371371 }
372372
373373
374374
375375 @Callable(i)
376376 func vote (amountAssetId,priceAssetId,amount) = {
377377 let pool = $Tuple2(amountAssetId, priceAssetId)
378378 let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
379379 let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
380380 let epochLength = getIntOrFail(this, keyEpochLength)
381381 let endHeight = (startHeight + epochLength)
382382 let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
383383 let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
384384 let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
385385 let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
386386 let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
387387 let gwxAmountAtEndTotal = {
388388 let @ = invoke(this, "getUserGwxAmountAtHeight", [toBase58String(i.caller.bytes), endHeight], nil)
389389 if ($isInstanceOf(@, "Int"))
390390 then @
391391 else throw(($getType(invoke(this, "getUserGwxAmountAtHeight", [toBase58String(i.caller.bytes), endHeight], nil)) + " couldn't be cast to Int"))
392392 }
393393 let available = (gwxAmountAtEndTotal - used)
394394 let newVote = (vote + amount)
395395 let wxEmission = checkWxEmissionPoolLabel(pool)
396396 let checks = [if ((getBoolean(keyInList(pool)) != unit))
397397 then true
398398 else throw("invalid assets"), if ((endHeight > height))
399399 then true
400400 else throw("invalid height"), if ((finalizationStageOrUnit == unit))
401401 then true
402402 else throw("finalization in progress"), if ((gwxAmountAtEndTotal > 0))
403403 then true
404404 else throw("you do not have gWX"), if (if ((amount > 0))
405405 then (available >= amount)
406406 else false)
407407 then true
408408 else throw("invalid amount"), if (wxEmission)
409409 then true
410410 else throw("pool hasn't WX_EMISSION label")]
411411 if ((checks == checks))
412412 then {
413413 let votesListName = getVotesListName(pool)
414414 let userAddressStr = toString(i.caller)
415415 let votesListActions = if (containsNode(votesListName, userAddressStr))
416416 then nil
417417 else insertNodeActions(votesListName, userAddressStr)
418418 $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)
419419 }
420420 else throw("Strict value is not equal to itself.")
421421 }
422422
423423
424424
425425 @Callable(i)
426426 func cancelVote (amountAssetId,priceAssetId) = {
427427 let pool = $Tuple2(amountAssetId, priceAssetId)
428428 let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
429429 let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
430430 let epochLength = getIntOrFail(this, keyEpochLength)
431431 let endHeight = (startHeight + epochLength)
432432 let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
433433 let used = valueOrElse(getInteger(this, keyUsed(i.caller, epoch)), 0)
434434 let vote = valueOrElse(getInteger(this, keyVote(pool, i.caller, epoch)), 0)
435435 let poolResult = valueOrElse(getInteger(this, keyVotingResult(pool, epoch)), 0)
436436 let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(epoch)), 0)
437437 let checks = [if ((getBoolean(keyInList(pool)) != unit))
438438 then true
439439 else throw("invalid assets"), if ((endHeight > height))
440440 then true
441441 else throw("invalid height"), if ((finalizationStageOrUnit == unit))
442442 then true
443443 else throw("finalization in progress"), if ((vote > 0))
444444 then true
445445 else throw("no vote")]
446446 if ((checks == checks))
447447 then {
448448 let votesListName = getVotesListName(pool)
449449 let userAddressStr = toString(i.caller)
450450 $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)
451451 }
452452 else throw("Strict value is not equal to itself.")
453453 }
454454
455455
456456
457457 @Callable(i)
458458 func setEpochLength (newEpochLength) = {
459459 let checks = [mustManager(i), if ((newEpochLength > 0))
460460 then true
461461 else throw("invalid epoch length")]
462462 if ((checks == checks))
463463 then $Tuple2([IntegerEntry(keyEpochLength, newEpochLength)], unit)
464464 else throw("Strict value is not equal to itself.")
465465 }
466466
467467
468468
469469 @Callable(i)
470470 func setMaxDepth (newMaxDepth) = {
471471 let checks = [mustManager(i), if ((newMaxDepth > 0))
472472 then true
473473 else throw("invalid max depth")]
474474 if ((checks == checks))
475475 then $Tuple2([IntegerEntry(keyMaxDepth, newMaxDepth)], unit)
476476 else throw("Strict value is not equal to itself.")
477477 }
478478
479479
480480
481481 @Callable(i)
482482 func processVoteINTERNAL (poolStr,userAddressStr) = {
483483 let checkCaller = mustThis(i)
484484 if ((checkCaller == checkCaller))
485485 then {
486486 let userAddress = valueOrErrorMessage(addressFromString(userAddressStr), ("processVoteINTERNAL: invalid user address " + userAddressStr))
487487 let epoch = getIntOrFail(this, keyCurrentEpoch)
488488 let epochPrevious = (epoch - 1)
489489 let epochLength = getIntOrFail(this, keyEpochLength)
490490 let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
491491 let endHeight = (startHeight + epochLength)
492492 let startHeightPrevious = getIntOrFail(this, keyStartHeightByEpoch(epochPrevious))
493493 let endHeightPrevious = (startHeightPrevious + epochLength)
494494 let checkTargetEpoch = if ((epochPrevious >= 0))
495495 then true
496496 else throw("processVoteINTERNAL: invalid previous epoch")
497497 if ((checkTargetEpoch == checkTargetEpoch))
498498 then {
499499 let pool = stringToPool(poolStr)
500500 let $t01719517235 = pool
501501 let amountAssetId = $t01719517235._1
502502 let priceAssetId = $t01719517235._2
503503 let wxEmission = checkWxEmissionPoolLabel(pool)
504504 let gwxAmountAtEndTotal = {
505505 let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeight], nil)
506506 if ($isInstanceOf(@, "Int"))
507507 then @
508508 else throw(($getType(invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeight], nil)) + " couldn't be cast to Int"))
509509 }
510510 let gwxAmountAtEndTotalPrevious = {
511511 let @ = invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeightPrevious], nil)
512512 if ($isInstanceOf(@, "Int"))
513513 then @
514514 else throw(($getType(invoke(this, "getUserGwxAmountAtHeight", [userAddressStr, endHeightPrevious], nil)) + " couldn't be cast to Int"))
515515 }
516516 let totalVotes = valueOrElse(getInteger(keyTotalVotes(epoch)), 0)
517517 let votingResult = valueOrElse(getInteger(keyVotingResult(pool, epoch)), 0)
518518 let votePrevious = valueOrErrorMessage(getInteger(keyVote(pool, userAddress, epochPrevious)), (((("processVoteINTERNAL " + poolStr) + " ") + userAddressStr) + ": no previous vote"))
519519 let used = valueOrElse(getInteger(this, keyUsed(userAddress, epoch)), 0)
520- let newVote = fraction(votePrevious, gwxAmountAtEndTotal, gwxAmountAtEndTotalPrevious)
520+ let newVote = if ((gwxAmountAtEndTotalPrevious > 0))
521+ then fraction(votePrevious, gwxAmountAtEndTotal, gwxAmountAtEndTotalPrevious)
522+ else 0
521523 let actions = if (if ((newVote > 0))
522524 then wxEmission
523525 else false)
524526 then [IntegerEntry(keyVote(pool, userAddress, epoch), newVote), IntegerEntry(keyTotalVotes(epoch), (totalVotes + newVote)), IntegerEntry(keyVotingResult(pool, epoch), (votingResult + newVote)), IntegerEntry(keyUsed(userAddress, epoch), (used + newVote))]
525527 else deleteNodeActions(getVotesListName(pool), userAddressStr)
526528 $Tuple2(actions, unit)
527529 }
528530 else throw("Strict value is not equal to itself.")
529531 }
530532 else throw("Strict value is not equal to itself.")
531533 }
532534
533535
534536
535537 @Callable(i)
536538 func processPoolINTERNAL (poolStr) = {
537539 let checkCaller = mustThis(i)
538540 if ((checkCaller == checkCaller))
539541 then {
540542 let targetEpoch = (getIntOrFail(this, keyCurrentEpoch) - 1)
541543 let checkTargetEpoch = if ((targetEpoch >= 0))
542544 then true
543545 else throw("processPoolINTERNAL: invalid target epoch")
544546 if ((checkTargetEpoch == checkTargetEpoch))
545547 then {
546548 let pool = stringToPool(poolStr)
547- let $t01875218792 = pool
548- let amountAssetId = $t01875218792._1
549- let priceAssetId = $t01875218792._2
549+ let $t01880118841 = pool
550+ let amountAssetId = $t01880118841._1
551+ let priceAssetId = $t01880118841._2
550552 let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract))
551553 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract))
552554 let lpAssetId = getLpAssetByPoolAssets(amountAssetId, priceAssetId)
553555 let r = {
554556 let @ = invoke(stakingContract, "usersListTraversal", [lpAssetId], nil)
555557 if ($isInstanceOf(@, "Boolean"))
556558 then @
557559 else throw(($getType(invoke(stakingContract, "usersListTraversal", [lpAssetId], nil)) + " couldn't be cast to Boolean"))
558560 }
559561 if ((r == r))
560562 then if (r)
561563 then $Tuple2(nil, true)
562564 else {
563565 let wxEmission = checkWxEmissionPoolLabel(pool)
564566 let totalVotes = valueOrElse(getInteger(this, keyTotalVotes(targetEpoch)), 0)
565567 let votingResult = valueOrElse(getInteger(this, keyVotingResult(pool, targetEpoch)), 0)
566568 let share = if (if ((totalVotes == 0))
567569 then true
568570 else !(wxEmission))
569571 then 0
570572 else fraction(votingResult, poolWeightMult, totalVotes)
571573 let modifyWeightInv = invoke(factoryContract, "modifyWeight", [lpAssetId, share], nil)
572574 if ((modifyWeightInv == modifyWeightInv))
573575 then {
574576 let poolsListActions = if (wxEmission)
575577 then nil
576578 else ([DeleteEntry(keyInList(pool))] ++ deleteNodeActions(poolsListName, poolStr))
577579 $Tuple2(([IntegerEntry(keyPoolShare(pool, targetEpoch), share)] ++ poolsListActions), false)
578580 }
579581 else throw("Strict value is not equal to itself.")
580582 }
581583 else throw("Strict value is not equal to itself.")
582584 }
583585 else throw("Strict value is not equal to itself.")
584586 }
585587 else throw("Strict value is not equal to itself.")
586588 }
587589
588590
589591
590592 @Callable(i)
591593 func finalizeHelper () = {
592594 let epoch = valueOrElse(getInteger(this, keyCurrentEpoch), 0)
593595 let previousEpoch = (epoch - 1)
594596 let startHeight = getIntOrFail(this, keyStartHeightByEpoch(epoch))
595597 let epochLength = getIntOrFail(this, keyEpochLength)
596598 let endHeight = (startHeight + epochLength)
597599 let finalizationStageOrUnit = getInteger(this, keyFinalizationStage)
598600 if (if ((height >= endHeight))
599601 then (finalizationStageOrUnit == unit)
600602 else false)
601603 then {
602604 let newEpoch = (epoch + 1)
603605 $Tuple2([IntegerEntry(keyStartHeightByEpoch(newEpoch), height), IntegerEntry(keyStartHeight, height), IntegerEntry(keyCurrentEpoch, newEpoch), IntegerEntry(keyFinalizationStage, finalizationStageTotal)], true)
604606 }
605607 else if ((finalizationStageOrUnit == unit))
606608 then $Tuple2(nil, false)
607609 else if ((finalizationStageOrUnit == finalizationStageTotal))
608610 then {
609611 let poolOrUnit = getString(keyNextPool)
610612 let userOrUnit = getString(keyNextUser)
611613 match poolOrUnit {
612614 case _: Unit =>
613615 match getString(keyListHead(poolsListName)) {
614616 case _: Unit =>
615617 $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
616618 case poolsHeadStr: String =>
617619 $Tuple2([StringEntry(keyNextPool, poolsHeadStr)], true)
618620 case _ =>
619621 throw("Match error")
620622 }
621623 case poolStr: String =>
622624 let pool = stringToPool(poolStr)
623625 let nextUserOrUnit = match userOrUnit {
624626 case _: Unit =>
625627 getString(keyListHead(getVotesListName(pool)))
626628 case user: String =>
627629 let next = getString(keyListNext(getVotesListName(pool), user))
628630 if ((next == next))
629631 then {
630632 let processVoteInv = invoke(this, "processVoteINTERNAL", [poolStr, user], nil)
631633 if ((processVoteInv == processVoteInv))
632634 then next
633635 else throw("Strict value is not equal to itself.")
634636 }
635637 else throw("Strict value is not equal to itself.")
636638 case _ =>
637639 throw("Match error")
638640 }
639641 match nextUserOrUnit {
640642 case _: Unit =>
641643 let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
642644 match nextPoolOrUnit {
643645 case _: Unit =>
644646 $Tuple2([IntegerEntry(keyFinalizationStage, finalizationStageShares), DeleteEntry(keyNextPool), DeleteEntry(keyNextUser)], true)
645647 case s: String =>
646648 $Tuple2([StringEntry(keyNextPool, s), DeleteEntry(keyNextUser)], true)
647649 case _ =>
648650 throw("Match error")
649651 }
650652 case nextUser: String =>
651653 $Tuple2([StringEntry(keyNextUser, nextUser)], true)
652654 case _ =>
653655 throw("Match error")
654656 }
655657 case _ =>
656658 throw("Match error")
657659 }
658660 }
659661 else if ((finalizationStageOrUnit == finalizationStageShares))
660662 then {
661663 let poolOrUnit = getString(keyNextPool)
662664 match poolOrUnit {
663665 case _: Unit =>
664666 match getString(keyListHead(poolsListName)) {
665667 case _: Unit =>
666668 $Tuple2([DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight)], true)
667669 case nextPoolStr: String =>
668670 $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
669671 case _ =>
670672 throw("Match error")
671673 }
672674 case poolStr: String =>
673675 let nextPoolOrUnit = getString(keyListNext(poolsListName, poolStr))
674676 if ((nextPoolOrUnit == nextPoolOrUnit))
675677 then {
676678 let r = {
677679 let @ = invoke(this, "processPoolINTERNAL", [poolStr], nil)
678680 if ($isInstanceOf(@, "Boolean"))
679681 then @
680682 else throw(($getType(invoke(this, "processPoolINTERNAL", [poolStr], nil)) + " couldn't be cast to Boolean"))
681683 }
682684 if ((r == r))
683685 then if (r)
684686 then $Tuple2(nil, true)
685687 else match nextPoolOrUnit {
686688 case _: Unit =>
687689 $Tuple2([DeleteEntry(keyFinalizationStage), BooleanEntry(keyFinalized(previousEpoch), true), IntegerEntry(keyCurrentEpochUi, epoch), IntegerEntry(keyStartHeightUi, startHeight), DeleteEntry(keyNextPool)], true)
688690 case nextPoolStr: String =>
689691 $Tuple2([StringEntry(keyNextPool, nextPoolStr)], true)
690692 case _ =>
691693 throw("Match error")
692694 }
693695 else throw("Strict value is not equal to itself.")
694696 }
695697 else throw("Strict value is not equal to itself.")
696698 case _ =>
697699 throw("Match error")
698700 }
699701 }
700702 else throw("finalization is broken")
701703 }
702704
703705
704706
705707 @Callable(i)
706708 func finalizeWrapper (counter) = {
707709 let result = {
708710 let @ = invoke(this, "finalizeHelper", nil, nil)
709711 if ($isInstanceOf(@, "Boolean"))
710712 then @
711713 else throw(($getType(invoke(this, "finalizeHelper", nil, nil)) + " couldn't be cast to Boolean"))
712714 }
713715 if ((result == result))
714716 then if (!(result))
715717 then if ((counter == 0))
716718 then throw("Current voting is not over yet")
717719 else $Tuple2(nil, unit)
718720 else {
719721 let maxDepth = valueOrElse(getInteger(this, keyMaxDepth), maxDepthDefault)
720722 if ((maxDepth > counter))
721723 then {
722724 let inv = invoke(this, "finalizeWrapper", [(counter + 1)], nil)
723725 if ((inv == inv))
724726 then $Tuple2(nil, unit)
725727 else throw("Strict value is not equal to itself.")
726728 }
727729 else $Tuple2(nil, unit)
728730 }
729731 else throw("Strict value is not equal to itself.")
730732 }
731733
732734
733735
734736 @Callable(i)
735737 func finalize () = {
736738 let inv = invoke(this, "finalizeWrapper", [0], nil)
737739 if ((inv == inv))
738740 then $Tuple2(nil, unit)
739741 else throw("Strict value is not equal to itself.")
740742 }
741743
742744
743745
744746 @Callable(i)
745747 func containsNodeREADONLY (listName,id) = $Tuple2(nil, containsNode(listName, id))
746748
747749
748750
749751 @Callable(i)
750752 func insertNode (listName,id) = {
751753 let checkCaller = mustManager(i)
752754 if ((checkCaller == checkCaller))
753755 then $Tuple2(insertNodeActions(listName, id), unit)
754756 else throw("Strict value is not equal to itself.")
755757 }
756758
757759
758760
759761 @Callable(i)
760762 func deleteNode (listName,id) = {
761763 let checkCaller = mustManager(i)
762764 if ((checkCaller == checkCaller))
763765 then $Tuple2(deleteNodeActions(listName, id), unit)
764766 else throw("Strict value is not equal to itself.")
765767 }
766768
767769
768770 @Verifier(tx)
769771 func verify () = {
770772 let targetPublicKey = match managerPublicKeyOrUnit() {
771773 case pk: ByteVector =>
772774 pk
773775 case _: Unit =>
774776 tx.senderPublicKey
775777 case _ =>
776778 throw("Match error")
777779 }
778780 sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
779781 }
780782

github/deemru/w8io/169f3d6 
74.98 ms