tx · G5PH2HgsX53FmJ1aYeViXQsxTuPvCf4XogMtSW3tEvZa

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.03400000 Waves

2023.08.18 10:45 [2715759] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "G5PH2HgsX53FmJ1aYeViXQsxTuPvCf4XogMtSW3tEvZa",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1692344780412,
    "version": 1,
    "sender": "3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP",
    "senderPublicKey": "AoKo4segKHU4DeJnxXQYJj2u7J6XJeux6r8KLW52cd2Q",
    "proofs": [
        "2Tj5qJgjFxHRh7MQGgdo7o6N9Hnj8t7EWjESJs2Lkd3AtsQSxhVmZM1Jrg8EP9yoXktEGrtAjX2areqQzw9SWmYu"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2715759,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 3pfspFhKeMtRC9i4f24UrLaiowdW8mi78gXtjVF7oFUi
Next: 6rLD4CDndN4tFiVth23tXZQL7cguVsyQKC2KWQgMH7a2

Diff: 

OldNewDifferences
766766                             let transferAction = [invoke(factoryAddressOrFail, "transferFromProxyTreasury", [factoryAddressOrFail.bytes, amountToPowerTotal], nil)]
767767                             if ((transferAction == transferAction))
768768                                 then {
769-                                    let totalPowerAmount = invoke(factoryAddressOrFail, "swap", [powerAssetIdStringOrFail, unit, amountToPowerTotal], nil)
769+                                    let totalPowerAmount = invoke(factoryAddressOrFail, "swap", [powerAssetIdStringOrFail, WAVES, amountToPowerTotal], nil)
770770                                     if ((totalPowerAmount == totalPowerAmount))
771771                                         then {
772772                                             let totalPowerAmountInt =                                             match totalPowerAmount {
776776                                                     0
777777                                             }
778778                                             func stakePowerInvoke (acc,next) =                                             {
779-                                                let $t02844028475 = next
780-                                                let generator = $t02844028475._1
781-                                                let shareAmount = $t02844028475._2
779+                                                let $t02844128476 = next
780+                                                let generator = $t02844128476._1
781+                                                let shareAmount = $t02844128476._2
782782                                                 if ((amountToPowerTotal > 0))
783783                                                     then {
784784                                                         let powerAmount = fraction(shareAmount, totalPowerAmountInt, amountToPowerTotal)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 let CONTRACT_NAME = "calculator.ride"
77 
88 let SCALE8 = 100000000
99 
1010 let PENDING = "PENDING"
1111 
1212 let WAVES = "WAVES"
1313 
1414 func wrapErr (s) = ((CONTRACT_NAME + ": ") + s)
1515 
1616 
1717 func throwErr (s) = throw(wrapErr(s))
1818 
1919 
2020 func assetIdToString (assetId) = match assetId {
2121     case b: ByteVector => 
2222         toBase58String(b)
2323     case _: Unit => 
2424         WAVES
2525     case _ => 
2626         throw("Match error")
2727 }
2828 
2929 
3030 func stringToAssetId (s) = if ((s == WAVES))
3131     then unit
3232     else fromBase58String(s)
3333 
3434 
3535 func abs (n) = if ((0 > n))
3636     then -(n)
3737     else n
3838 
3939 
4040 func keyFactoryAddress () = makeString(["%s", "factory"], SEP)
4141 
4242 
4343 func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
4444 
4545 
4646 func keyLpAssetId () = makeString(["%s", "lpAssetId"], SEP)
4747 
4848 
4949 func keyProxyTreasuryAddress () = makeString(["%s", "proxyTreasury"], SEP)
5050 
5151 
5252 func keyMainTreasuryAddress () = makeString(["%s", "mainTreasury"], SEP)
5353 
5454 
5555 func keyBusinessTreasuryAddress () = makeString(["%s", "businessTreasury"], SEP)
5656 
5757 
5858 func keyBusinessTreasuryPart () = makeString(["%s", "businessTreasuryPart"], SEP)
5959 
6060 
6161 func keyPowerContractAddress () = makeString(["%s", "powerContract"], SEP)
6262 
6363 
6464 func keyPowerShareRatio () = makeString(["%s", "powerShareRatio"], SEP)
6565 
6666 
6767 func keyPowerAssetId () = makeString(["%s", "powerAssetId"], SEP)
6868 
6969 
7070 func keyInvested (assetId) = makeString(["%s%s", "invested", assetIdToString(assetId)], SEP)
7171 
7272 
7373 func keyDonated (assetId) = makeString(["%s%s", "donated", assetIdToString(assetId)], SEP)
7474 
7575 
7676 func keyAvailable (userAddress) = makeString(["%s%s", "available", toString(userAddress)], SEP)
7777 
7878 
7979 func keyClaimed (userAddress) = makeString(["%s%s", "claimed", toString(userAddress)], SEP)
8080 
8181 
8282 func keyCurrentPeriod () = makeString(["%s", "currentPeriod"], SEP)
8383 
8484 
8585 func keyPriceForPeriod (period) = makeString(["%s%d", "price", toString(period)], SEP)
8686 
8787 
8888 func keyStartHeight (period) = makeString(["%s%d", "startHeight", toString(period)], SEP)
8989 
9090 
9191 func keyPowerManagerBonus (period) = makeString(["%s%d", "powerManagerBonus", toString(period)], SEP)
9292 
9393 
9494 func keyClaimWavesAmount (period) = makeString(["%s%d", "claimWavesAmount", toString(period)], SEP)
9595 
9696 
9797 func keyPeriodLength () = "%s__periodLength"
9898 
9999 
100100 func keyInvestPeriodLength () = "%s__investPeriodLength"
101101 
102102 
103103 func keyBlockProcessingReward () = "%s__blockProcessingReward"
104104 
105105 
106106 func keyNextBlockToProcess () = "%s__nextBlockToProcess"
107107 
108108 
109109 func keyBlockProcessed (height) = makeString(["%s%d", "blockProcessed", toString(height)], SEP)
110110 
111111 
112112 func keyWithdrawal () = "%s__withdrawal"
113113 
114114 
115115 func keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
116116 
117117 
118118 func valueWithdrawalRequest (status,lpAssetAmount,targetPeriod,claimTxId) = {
119119     let claimTxIdStr =     match claimTxId {
120120         case b: ByteVector => 
121121             toBase58String(b)
122122         case _: Unit => 
123123             "SOON"
124124         case _ => 
125125             throw("Match error")
126126     }
127127     makeString(["%s%d%d%s", status, toString(lpAssetAmount), toString(targetPeriod), claimTxIdStr], SEP)
128128     }
129129 
130130 
131131 func keyWithdrawalHistory (userAddress,txId) = makeString(["%s%s%s", "withdrawalHistory", toString(userAddress), toBase58String(txId)], SEP)
132132 
133133 
134134 func keyPeriodWithdrawalAssetIds (period) = makeString(["%s%d", "periodReward", toString(period)], SEP)
135135 
136136 
137137 func keyPeriodWithdrawalAmounts (period) = makeString(["%s%d", "periodRewardAmount", toString(period)], SEP)
138138 
139139 
140140 func parseWithdrawalRequestValueOrFail (s) = {
141141     let parts = split(s, SEP)
142142     if ((size(parts) == 5))
143143         then {
144144             let status = parts[1]
145145             let lpAssetAmount = valueOrErrorMessage(parseInt(parts[2]), wrapErr("invalid lpAssetAmount"))
146146             let targetPeriod = valueOrErrorMessage(parseInt(parts[3]), wrapErr("invalid targetPeriod"))
147147             let claimTxId = parts[4]
148148             $Tuple4(status, lpAssetAmount, targetPeriod, claimTxId)
149149             }
150150         else throwErr("invalid withdrawal request value")
151151     }
152152 
153153 
154154 let factoryAddressOption = match getString(this, keyFactoryAddress()) {
155155     case s: String => 
156156         addressFromString(s)
157157     case _: Unit => 
158158         unit
159159     case _ => 
160160         throw("Match error")
161161 }
162162 
163163 let factoryAddressOrFail = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
164164 
165165 let lpAssetIdOption = match factoryAddressOption {
166166     case a: Address => 
167167         match getString(a, keyLpAssetId()) {
168168             case s: String => 
169169                 fromBase58String(s)
170170             case _: Unit => 
171171                 unit
172172             case _ => 
173173                 throw("Match error")
174174         }
175175     case _: Unit => 
176176         unit
177177     case _ => 
178178         throw("Match error")
179179 }
180180 
181181 let lpAssetIdOrFail = valueOrErrorMessage(lpAssetIdOption, wrapErr("invalid lpAssetId"))
182182 
183183 let proxyTreasuryAddressOption = match factoryAddressOption {
184184     case a: Address => 
185185         match getString(a, keyProxyTreasuryAddress()) {
186186             case s: String => 
187187                 addressFromString(s)
188188             case _: Unit => 
189189                 unit
190190             case _ => 
191191                 throw("Match error")
192192         }
193193     case _: Unit => 
194194         unit
195195     case _ => 
196196         throw("Match error")
197197 }
198198 
199199 let proxyTreasuryAddressOrFail = valueOrErrorMessage(proxyTreasuryAddressOption, wrapErr("invalid proxy treasury address"))
200200 
201201 let mainTreasuryAddressOption = match factoryAddressOption {
202202     case a: Address => 
203203         match getString(a, keyMainTreasuryAddress()) {
204204             case s: String => 
205205                 addressFromString(s)
206206             case _: Unit => 
207207                 unit
208208             case _ => 
209209                 throw("Match error")
210210         }
211211     case _: Unit => 
212212         unit
213213     case _ => 
214214         throw("Match error")
215215 }
216216 
217217 let businessTreasuryAddressOption = match factoryAddressOption {
218218     case a: Address => 
219219         match getString(a, keyBusinessTreasuryAddress()) {
220220             case s: String => 
221221                 addressFromString(s)
222222             case _: Unit => 
223223                 unit
224224             case _ => 
225225                 throw("Match error")
226226         }
227227     case _: Unit => 
228228         unit
229229     case _ => 
230230         throw("Match error")
231231 }
232232 
233233 let mainTreasuryAddressOrFail = valueOrErrorMessage(mainTreasuryAddressOption, wrapErr("invalid main treasury address"))
234234 
235235 let businessTreasuryAddressOrFail = valueOrErrorMessage(businessTreasuryAddressOption, wrapErr("invalid business treasury address"))
236236 
237237 let powerContractAddressOption = match factoryAddressOption {
238238     case a: Address => 
239239         match getString(a, keyPowerContractAddress()) {
240240             case s: String => 
241241                 addressFromString(s)
242242             case _: Unit => 
243243                 unit
244244             case _ => 
245245                 throw("Match error")
246246         }
247247     case _: Unit => 
248248         unit
249249     case _ => 
250250         throw("Match error")
251251 }
252252 
253253 let powerContractAddressOrFail = valueOrErrorMessage(powerContractAddressOption, wrapErr("invalid power contract address"))
254254 
255255 let powerAssetIdStringOrFail = valueOrErrorMessage(getString(factoryAddressOrFail, keyPowerAssetId()), wrapErr("power asset id not found"))
256256 
257257 func getManagerPublicKeyOrUnit () = match factoryAddressOption {
258258     case fa: Address => 
259259         match getString(fa, keyManagerPublicKey()) {
260260             case pub: String => 
261261                 fromBase58String(pub)
262262             case _ => 
263263                 unit
264264         }
265265     case _ => 
266266         unit
267267 }
268268 
269269 
270270 func onlyAddress (i,address) = if ((i.caller == address))
271271     then true
272272     else throwErr("permission denied")
273273 
274274 
275275 func onlyFactory (i) = onlyAddress(i, factoryAddressOrFail)
276276 
277277 
278278 func rewardForOption (rewards,target) = {
279279     let s = size(rewards)
280280     let $t066316656 = rewards[0]
281281     let a0 = $t066316656._1
282282     let r0 = $t066316656._2
283283     let $t066596684 = rewards[1]
284284     let a1 = $t066596684._1
285285     let r1 = $t066596684._2
286286     let $t066876712 = rewards[2]
287287     let a2 = $t066876712._1
288288     let r2 = $t066876712._2
289289     if (if ((s > 0))
290290         then (a0 == target)
291291         else false)
292292         then r0
293293         else if (if ((s > 1))
294294             then (a1 == target)
295295             else false)
296296             then r1
297297             else if (if ((s > 2))
298298                 then (a2 == target)
299299                 else false)
300300                 then r2
301301                 else unit
302302     }
303303 
304304 
305305 func calculatePrice (lpPartInWaves) = {
306306     let lpAssetAmountToBurn = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
307307     let lpAssetQuantity = valueOrErrorMessage(assetInfo(lpAssetIdOrFail), wrapErr("invalid lpAsset info")).quantity
308308     let newPrice = fraction(lpPartInWaves, SCALE8, (lpAssetQuantity - lpAssetAmountToBurn))
309309     let checkIfPriceNotZero = if ((newPrice != 0))
310310         then true
311311         else throwErr("LP price cannot be 0")
312312     if ((checkIfPriceNotZero == checkIfPriceNotZero))
313313         then {
314314             let lpAssetFinalQuantity = (lpAssetQuantity - lpAssetAmountToBurn)
315315             $Tuple3(newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity)
316316             }
317317         else throw("Strict value is not equal to itself.")
318318     }
319319 
320320 
321321 func claimCollateralINTERNAL (userAddressBytes,txId) = {
322322     let userAddress = Address(userAddressBytes)
323323     let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
324324     let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
325325     let $t078797992 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
326326     let status = $t078797992._1
327327     let lpAssetAmount = $t078797992._2
328328     let targetPeriod = $t078797992._3
329329     let claimTxId = $t078797992._4
330330     if ((targetPeriod > currentPeriodOrFail))
331331         then throwErr("invalid withdrawal request period")
332332         else {
333333             let priceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(targetPeriod)), wrapErr("invalid price"))
334334             let wavesAmount = if ((priceOrFail > 0))
335335                 then fraction(lpAssetAmount, priceOrFail, SCALE8)
336336                 else 0
337337             let assetsString = getStringValue(factoryAddressOrFail, keyPeriodWithdrawalAssetIds(currentPeriodOrFail))
338338             let amountsString = getStringValue(factoryAddressOrFail, keyPeriodWithdrawalAmounts(currentPeriodOrFail))
339339             $Tuple6(userAddress, lpAssetAmount, targetPeriod, wavesAmount, assetsString, amountsString)
340340             }
341341     }
342342 
343343 
344344 func claimCollateralREADONLYStringResponse (userAddressBytes,txId) = {
345345     let $t087798945 = claimCollateralINTERNAL(userAddressBytes, txId)
346346     let userAddress = $t087798945._1
347347     let lpAssetAmount = $t087798945._2
348348     let targetPeriod = $t087798945._3
349349     let wavesAmount = $t087798945._4
350350     let assetsString = $t087798945._5
351351     let amountsString = $t087798945._6
352352     let assets = makeString(removeByIndex(split_51C(assetsString, SEP), 0), ":")
353353     let amounts = makeString(removeByIndex(split_51C(amountsString, SEP), 0), ":")
354354     makeString(["%d%s%s", toString(wavesAmount), assets, amounts], SEP)
355355     }
356356 
357357 
358358 @Callable(i)
359359 func claimLP (userAddressBytes) = {
360360     let checkCaller = onlyFactory(i)
361361     if ((checkCaller == checkCaller))
362362         then {
363363             let userAddress = Address(userAddressBytes)
364364             let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
365365             let claimed = valueOrElse(getInteger(factoryAddressOrFail, keyClaimed(userAddress)), 0)
366366             let factoryActions = if ((available > 0))
367367                 then [invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, available, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), 0], nil), invoke(factoryAddressOrFail, "integerEntry", [keyClaimed(userAddress), (claimed + available)], nil)]
368368                 else throwErr("nothing to claim")
369369             $Tuple2(nil, factoryActions)
370370             }
371371         else throw("Strict value is not equal to itself.")
372372     }
373373 
374374 
375375 
376376 @Callable(i)
377377 func finalize (userAddressBytes,donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
378378     let checkCaller = onlyFactory(i)
379379     if ((checkCaller == checkCaller))
380380         then {
381381             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
382382             let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
383383             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
384384             let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
385385             let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
386386             let periodEndHeight = ((currentStartHeight + periodLength) - 1)
387387             let checks = [if ((i.originCaller == mainTreasuryAddressOrFail))
388388                 then true
389389                 else throwErr("permission denied"), if ((nextBlockToProcess > periodEndHeight))
390390                 then true
391391                 else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
392392                 then true
393393                 else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
394394                 then true
395395                 else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
396396                 then true
397397                 else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
398398                 then true
399399                 else throwErr("invalid PWR stake part")]
400400             if ((checks == checks))
401401                 then {
402402                     let $t01150211607 = calculatePrice(lpPartInWaves)
403403                     let newPrice = $t01150211607._1
404404                     let lpAssetAmountToBurn = $t01150211607._2
405405                     let lpAssetFinalQuantity = $t01150211607._3
406406                     let newPeriod = (currentPeriodOrFail + 1)
407407                     func addNewAction (actions,payment) =                     {
408408                         let $t01175511817 = actions
409409                         let scriptTransfers = $t01175511817._1
410410                         let assetIdsString = $t01175511817._2
411411                         let amountsString = $t01175511817._3
412412                         let paymentAmount = payment.amount
413413                         let paymentAssetId = payment.assetId
414414                         let newAssetIdsString = ("%s" + makeString([assetIdsString, assetIdToString(paymentAssetId)], SEP))
415415                         let newAmountsString = ("%d" + makeString([amountsString, toString(paymentAmount)], SEP))
416416                         let newScriptTransfer = ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)
417417                         $Tuple3((scriptTransfers :+ newScriptTransfer), newAssetIdsString, newAmountsString)
418418                         }
419419 
420420                     let $t01227712368 = {
421421                         let $l = i.payments
422422                         let $s = size($l)
423423                         let $acc0 = $Tuple3(nil, "", "")
424424                         func $f0_1 ($a,$i) =                         if (($i >= $s))
425425                             then $a
426426                             else addNewAction($a, $l[$i])
427427 
428428                         func $f0_2 ($a,$i) =                         if (($i >= $s))
429429                             then $a
430430                             else throw("List size exceeds 10")
431431 
432432                         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
433433                         }
434434                     let scriptTransfers = $t01227712368._1
435435                     let AssetIds = $t01227712368._2
436436                     let Amounts = $t01227712368._3
437437                     let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyPowerManagerBonus(currentPeriodOrFail), powerStakePartInWaves], nil), invoke(factoryAddressOrFail, "integerEntry", [keyClaimWavesAmount(currentPeriodOrFail), claimPartInWaves], nil), invoke(factoryAddressOrFail, "integerEntry", [keyCurrentPeriod(), newPeriod], nil), invoke(factoryAddressOrFail, "integerEntry", [keyPriceForPeriod(newPeriod), newPrice], nil), invoke(factoryAddressOrFail, "integerEntry", [keyStartHeight(newPeriod), (periodEndHeight + 1)], nil), invoke(factoryAddressOrFail, "burn", [lpAssetAmountToBurn], nil), invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), 0], nil), invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), lpPartInWaves], nil), invoke(factoryAddressOrFail, "integerEntry", [keyDonated(unit), donationPartInWaves], nil), invoke(factoryAddressOrFail, "stringEntry", [keyPeriodWithdrawalAssetIds(newPeriod), AssetIds], nil), invoke(factoryAddressOrFail, "stringEntry", [keyPeriodWithdrawalAmounts(newPeriod), Amounts], nil)]
438438                     $Tuple2(scriptTransfers, factoryActions)
439439                     }
440440                 else throw("Strict value is not equal to itself.")
441441             }
442442         else throw("Strict value is not equal to itself.")
443443     }
444444 
445445 
446446 
447447 @Callable(i)
448448 func finalizeREADONLY (donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
449449     let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
450450     let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
451451     let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
452452     let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
453453     let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
454454     let periodEndHeight = ((currentStartHeight + periodLength) - 1)
455455     let checks = [if ((nextBlockToProcess > periodEndHeight))
456456         then true
457457         else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
458458         then true
459459         else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
460460         then true
461461         else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
462462         then true
463463         else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
464464         then true
465465         else throwErr("invalid PWR stake part")]
466466     if ((checks == checks))
467467         then {
468468             let $t01524715352 = calculatePrice(lpPartInWaves)
469469             let newPrice = $t01524715352._1
470470             let lpAssetAmountToBurn = $t01524715352._2
471471             let lpAssetFinalQuantity = $t01524715352._3
472472             $Tuple2(nil, $Tuple6(claimPartInWaves, lpPartInWaves, donationPartInWaves, newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity))
473473             }
474474         else throw("Strict value is not equal to itself.")
475475     }
476476 
477477 
478478 
479479 @Callable(i)
480480 func invest (userAddressBytes) = {
481481     let checkCaller = onlyFactory(i)
482482     if ((checkCaller == checkCaller))
483483         then {
484484             let userAddress = Address(userAddressBytes)
485485             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
486486             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
487487             let investPeriodLength = getIntegerValue(factoryAddressOrFail, keyInvestPeriodLength())
488488             let heightCheck = if (((currentStartHeight + investPeriodLength) > height))
489489                 then true
490490                 else throwErr("too late to invest in this period")
491491             if ((heightCheck == heightCheck))
492492                 then {
493493                     let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
494494                     let payment = if ((size(i.payments) == 1))
495495                         then i.payments[0]
496496                         else throwErr("invalid payments")
497497                     let $t01646116638 = if (if ((payment.assetId == unit))
498498                         then (payment.amount > 0)
499499                         else false)
500500                         then $Tuple2(payment.amount, payment.assetId)
501501                         else throwErr("invalid payment amount")
502502                     let paymentAmount = $t01646116638._1
503503                     let paymentAssetId = $t01646116638._2
504504                     let treasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
505505                     let paymentsWithoutTreasuryPart = fraction(paymentAmount, (SCALE8 - treasuryPart), SCALE8)
506506                     let lpAssetAmount = if ((currentPriceOrFail > 0))
507507                         then fraction(paymentsWithoutTreasuryPart, SCALE8, currentPriceOrFail)
508508                         else 0
509509                     let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
510510                     let actions = [ScriptTransfer(mainTreasuryAddressOrFail, paymentsWithoutTreasuryPart, paymentAssetId), ScriptTransfer(businessTreasuryAddressOrFail, treasuryPart, paymentAssetId)]
511511                     let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), (invested + paymentsWithoutTreasuryPart)], nil), invoke(factoryAddressOrFail, "reissue", [lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
512512                     $Tuple2(actions, factoryActions)
513513                     }
514514                 else throw("Strict value is not equal to itself.")
515515             }
516516         else throw("Strict value is not equal to itself.")
517517     }
518518 
519519 
520520 
521521 @Callable(i)
522522 func withdraw (userAddressBytes) = {
523523     let checkCaller = onlyFactory(i)
524524     if ((checkCaller == checkCaller))
525525         then {
526526             let userAddress = Address(userAddressBytes)
527527             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
528528             let payment = if ((size(i.payments) == 1))
529529                 then i.payments[0]
530530                 else throwErr(wrapErr("invalid payments"))
531531             let paymentAssetId = if ((payment.assetId == lpAssetIdOrFail))
532532                 then lpAssetIdOrFail
533533                 else throwErr("invalid payment asset")
534534             let paymentAmount = if ((payment.amount > 0))
535535                 then payment.amount
536536                 else throwErr("invalid payment amount")
537537             let withdrawal = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
538538             let actions = [ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)]
539539             let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), (withdrawal + paymentAmount)], nil), invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, i.transactionId), valueWithdrawalRequest(PENDING, paymentAmount, (currentPeriodOrFail + 1), unit)], nil)]
540540             if ((factoryActions == factoryActions))
541541                 then $Tuple2(actions, factoryActions)
542542                 else throw("Strict value is not equal to itself.")
543543             }
544544         else throw("Strict value is not equal to itself.")
545545     }
546546 
547547 
548548 
549549 @Callable(i)
550550 func cancelWithdraw (userAddressBytes,txId) = {
551551     let checkCaller = onlyFactory(i)
552552     if ((checkCaller == checkCaller))
553553         then {
554554             let userAddress = Address(userAddressBytes)
555555             let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
556556             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
557557             let $t01937219485 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
558558             let status = $t01937219485._1
559559             let lpAssetAmount = $t01937219485._2
560560             let targetPeriod = $t01937219485._3
561561             let claimTxId = $t01937219485._4
562562             let checks = [if ((status == PENDING))
563563                 then true
564564                 else throwErr("invalid withdrawal request status"), if ((targetPeriod > currentPeriodOrFail))
565565                 then true
566566                 else throwErr("invalid withdrawal request period")]
567567             if ((checks == checks))
568568                 then {
569569                     let withdrawal = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyWithdrawal()), wrapErr("invalid total withdrawal amount"))
570570                     let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), if ((withdrawal >= lpAssetAmount))
571571                         then (withdrawal - lpAssetAmount)
572572                         else throwErr("invalid withdrawal amount")], nil), invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
573573                     if ((factoryActions == factoryActions))
574574                         then $Tuple2(nil, factoryActions)
575575                         else throw("Strict value is not equal to itself.")
576576                     }
577577                 else throw("Strict value is not equal to itself.")
578578             }
579579         else throw("Strict value is not equal to itself.")
580580     }
581581 
582582 
583583 
584584 @Callable(i)
585585 func claimCollateral (userAddressBytes,txId) = {
586586     let checkCaller = onlyFactory(i)
587587     if ((checkCaller == checkCaller))
588588         then {
589589             let $t02047120656 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
590590             let userAddress = $t02047120656._1
591591             let lpAssetAmount = $t02047120656._2
592592             let targetPeriod = $t02047120656._3
593593             let wavesAmount = $t02047120656._4
594594             let assetsString = $t02047120656._5
595595             let amountsString = $t02047120656._6
596596             let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
597597             let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
598598             let factoryActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, fromBase58String(txId))], nil), invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawalHistory(userAddress, fromBase58String(txId)), lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAssets", [userAddressBytes, assetsList, amountsList], nil)]
599599             $Tuple2(nil, factoryActions)
600600             }
601601         else throw("Strict value is not equal to itself.")
602602     }
603603 
604604 
605605 
606606 @Callable(i)
607607 func claimCollateralBulk (userAddressBytes,txIds) = {
608608     let checkCaller = onlyFactory(i)
609609     if ((checkCaller == checkCaller))
610610         then {
611611             func addNewAction (state,txId) =             {
612612                 let $t02141421613 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
613613                 let userAddress = $t02141421613._1
614614                 let lpAssetAmount = $t02141421613._2
615615                 let targetPeriod = $t02141421613._3
616616                 let wavesAmount = $t02141421613._4
617617                 let assetsString = $t02141421613._5
618618                 let amountsString = $t02141421613._6
619619                 let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
620620                 let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
621621                 let newActions = [invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, fromBase58String(txId))], nil), invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawalHistory(userAddress, fromBase58String(txId)), lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAssets", [userAddressBytes, assetsList, amountsList], nil)]
622622                 (state ++ newActions)
623623                 }
624624 
625625             let allFactoryActions = {
626626                 let $l = txIds
627627                 let $s = size($l)
628628                 let $acc0 = nil
629629                 func $f0_1 ($a,$i) =                 if (($i >= $s))
630630                     then $a
631631                     else addNewAction($a, $l[$i])
632632 
633633                 func $f0_2 ($a,$i) =                 if (($i >= $s))
634634                     then $a
635635                     else throw("List size exceeds 10")
636636 
637637                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
638638                 }
639639             $Tuple2(nil, allFactoryActions)
640640             }
641641         else throw("Strict value is not equal to itself.")
642642     }
643643 
644644 
645645 
646646 @Callable(i)
647647 func claimCollateralREADONLY (userAddressBytes,txId) = {
648648     let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
649649     $Tuple2(nil, response)
650650     }
651651 
652652 
653653 
654654 @Callable(i)
655655 func claimCollateralBulkREADONLY (userAddressBytes,txIds) = {
656656     func processTxId (state,txId) =     {
657657         let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
658658         (state :+ response)
659659         }
660660 
661661     let allResponses = {
662662         let $l = txIds
663663         let $s = size($l)
664664         let $acc0 = nil
665665         func $f0_1 ($a,$i) =         if (($i >= $s))
666666             then $a
667667             else processTxId($a, $l[$i])
668668 
669669         func $f0_2 ($a,$i) =         if (($i >= $s))
670670             then $a
671671             else throw("List size exceeds 10")
672672 
673673         $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
674674         }
675675     $Tuple2(nil, allResponses)
676676     }
677677 
678678 
679679 
680680 @Callable(i)
681681 func processBlocks (userAddressBytes) = {
682682     let checkCaller = onlyFactory(i)
683683     if ((checkCaller == checkCaller))
684684         then {
685685             let userAddress = Address(userAddressBytes)
686686             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
687687             let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
688688             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
689689             let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
690690             let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
691691             let periodEndHeight = ((currentStartHeight + periodLength) - 1)
692692             let blocksProcessingBatchSizeMax = 20
693693             let blocksProcessingBatchSize = if (if (if ((height >= nextBlockToProcess))
694694                 then if ((nextBlockToProcess >= currentStartHeight))
695695                     then true
696696                     else (currentPeriodOrFail == 0)
697697                 else false)
698698                 then (periodEndHeight >= nextBlockToProcess)
699699                 else false)
700700                 then min([((periodEndHeight - nextBlockToProcess) + 1), blocksProcessingBatchSizeMax])
701701                 else throwErr(wrapErr("invalid target block"))
702702             let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
703703             let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSize)
704704             let blockProcessingRewardByGeneratorRemainder = (blockProcessingReward - (blockProcessingRewardByGenerator * blocksProcessingBatchSize))
705705             func map (acc,inc) =             if ((inc >= blocksProcessingBatchSize))
706706                 then acc
707707                 else {
708708                     let targetBlockHeight = (nextBlockToProcess + inc)
709709                     let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
710710                     let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, proxyTreasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
711711                     let generator = targetBlockInfo.generator
712712                     let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
713713                     let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
714714                         then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
715715                         else blockProcessingRewardByGenerator
716716                     let powerShareRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyPowerShareRatio()), 0), SCALE8])])
717717                     let shareAmountToPower = fraction((treasuryRewardOrFail - callerReward), powerShareRatio, SCALE8)
718718                     let lpAssetAmount = if ((currentPriceOrFail > 0))
719719                         then fraction(((treasuryRewardOrFail - callerReward) - shareAmountToPower), SCALE8, currentPriceOrFail)
720720                         else 0
721721                     let factoryActionsSingle = [invoke(factoryAddressOrFail, "stringEntry", [keyBlockProcessed(targetBlockHeight), makeString([toBase58String(i.transactionId), toString(currentPeriodOrFail), toString(generator), toBase58String(userAddressBytes), toString(treasuryRewardOrFail), toString(callerReward), toString(lpAssetAmount), toString(shareAmountToPower)], SEP)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(generator), (available + lpAssetAmount)], nil)]
722722                     if ((factoryActionsSingle == factoryActionsSingle))
723723                         then {
724724                             let $t02670426758 = acc
725725                             let lpAssetAcc = $t02670426758._1
726726                             let rewardAcc = $t02670426758._2
727727                             let powerShareDataTuple = $t02670426758._3
728728                             let $t02676526831 = powerShareDataTuple
729729                             let powerShareAcc = $t02676526831._1
730730                             let generatorPowerShareList = $t02676526831._2
731731                             let newGeneratorPowerShareList = (generatorPowerShareList :+ $Tuple2(toString(generator), shareAmountToPower))
732732                             $Tuple3((lpAssetAcc + lpAssetAmount), (rewardAcc + treasuryRewardOrFail), $Tuple2((powerShareAcc + shareAmountToPower), newGeneratorPowerShareList))
733733                             }
734734                         else throw("Strict value is not equal to itself.")
735735                     }
736736 
737737             let list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
738738             let $t02718627292 = {
739739                 let $l = list
740740                 let $s = size($l)
741741                 let $acc0 = $Tuple3(0, 0, $Tuple2(0, nil))
742742                 func $f0_1 ($a,$i) =                 if (($i >= $s))
743743                     then $a
744744                     else map($a, $l[$i])
745745 
746746                 func $f0_2 ($a,$i) =                 if (($i >= $s))
747747                     then $a
748748                     else throw("List size exceeds 20")
749749 
750750                 $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
751751                 }
752752             if (($t02718627292 == $t02718627292))
753753                 then {
754754                     let powerShareDataTuple = $t02718627292._3
755755                     let rewardAmountTotal = $t02718627292._2
756756                     let lpAssetAmountTotal = $t02718627292._1
757757                     let $t02729627365 = powerShareDataTuple
758758                     let amountToPowerTotal = $t02729627365._1
759759                     let powerShareAmountsList = $t02729627365._2
760760                     let businessTreasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
761761                     let rewardToBusinessTreasuryAmount = fraction(rewardAmountTotal, businessTreasuryPart, SCALE8)
762762                     let rewardToMainTreasuryAmount = (((rewardAmountTotal - rewardToBusinessTreasuryAmount) - blockProcessingReward) - amountToPowerTotal)
763763                     let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
764764                     let powerShareActions = if ((amountToPowerTotal > 0))
765765                         then {
766766                             let transferAction = [invoke(factoryAddressOrFail, "transferFromProxyTreasury", [factoryAddressOrFail.bytes, amountToPowerTotal], nil)]
767767                             if ((transferAction == transferAction))
768768                                 then {
769-                                    let totalPowerAmount = invoke(factoryAddressOrFail, "swap", [powerAssetIdStringOrFail, unit, amountToPowerTotal], nil)
769+                                    let totalPowerAmount = invoke(factoryAddressOrFail, "swap", [powerAssetIdStringOrFail, WAVES, amountToPowerTotal], nil)
770770                                     if ((totalPowerAmount == totalPowerAmount))
771771                                         then {
772772                                             let totalPowerAmountInt =                                             match totalPowerAmount {
773773                                                 case pAmount: Int => 
774774                                                     pAmount
775775                                                 case _ => 
776776                                                     0
777777                                             }
778778                                             func stakePowerInvoke (acc,next) =                                             {
779-                                                let $t02844028475 = next
780-                                                let generator = $t02844028475._1
781-                                                let shareAmount = $t02844028475._2
779+                                                let $t02844128476 = next
780+                                                let generator = $t02844128476._1
781+                                                let shareAmount = $t02844128476._2
782782                                                 if ((amountToPowerTotal > 0))
783783                                                     then {
784784                                                         let powerAmount = fraction(shareAmount, totalPowerAmountInt, amountToPowerTotal)
785785                                                         let inv = invoke(factoryAddressOrFail, "powerStake", [fromBase58String(generator), fromBase58String(powerAssetIdStringOrFail), powerAmount], nil)
786786                                                         if ((inv == inv))
787787                                                             then nil
788788                                                             else throw("Strict value is not equal to itself.")
789789                                                         }
790790                                                     else nil
791791                                                 }
792792 
793793                                             let powerStakesActions = {
794794                                                 let $l = powerShareAmountsList
795795                                                 let $s = size($l)
796796                                                 let $acc0 = 0
797797                                                 func $f1_1 ($a,$i) =                                                 if (($i >= $s))
798798                                                     then $a
799799                                                     else stakePowerInvoke($a, $l[$i])
800800 
801801                                                 func $f1_2 ($a,$i) =                                                 if (($i >= $s))
802802                                                     then $a
803803                                                     else throw("List size exceeds 20")
804804 
805805                                                 $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
806806                                                 }
807807                                             if ((powerStakesActions == powerStakesActions))
808808                                                 then nil
809809                                                 else throw("Strict value is not equal to itself.")
810810                                             }
811811                                         else throw("Strict value is not equal to itself.")
812812                                     }
813813                                 else throw("Strict value is not equal to itself.")
814814                             }
815815                         else nil
816816                     if ((powerShareActions == powerShareActions))
817817                         then {
818818                             let actions = [invoke(factoryAddressOrFail, "reissue", [lpAssetAmountTotal], nil), invoke(factoryAddressOrFail, "integerEntry", [keyNextBlockToProcess(), (nextBlockToProcess + blocksProcessingBatchSize)], nil), invoke(factoryAddressOrFail, "transferFromProxyTreasury", [mainTreasuryAddressOrFail.bytes, rewardToMainTreasuryAmount], nil), invoke(factoryAddressOrFail, "transferFromProxyTreasury", [userAddressBytes, blockProcessingReward], nil), invoke(factoryAddressOrFail, "transferFromProxyTreasury", [businessTreasuryAddressOrFail.bytes, rewardToBusinessTreasuryAmount], nil), invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), (invested + rewardToMainTreasuryAmount)], nil)]
819819                             if ((actions == actions))
820820                                 then $Tuple2(nil, unit)
821821                                 else throw("Strict value is not equal to itself.")
822822                             }
823823                         else throw("Strict value is not equal to itself.")
824824                     }
825825                 else throw("Strict value is not equal to itself.")
826826             }
827827         else throw("Strict value is not equal to itself.")
828828     }
829829 
830830 
831831 @Verifier(tx)
832832 func verify () = {
833833     let publicKey =     match getManagerPublicKeyOrUnit() {
834834         case pub: ByteVector => 
835835             pub
836836         case _ => 
837837             tx.senderPublicKey
838838     }
839839     sigVerify(tx.bodyBytes, tx.proofs[0], publicKey)
840840     }
841841 
github/deemru/w8io/169f3d6 
83.25 ms ◑