tx · 6rLD4CDndN4tFiVth23tXZQL7cguVsyQKC2KWQgMH7a2

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.03500000 Waves

2023.08.18 12:44 [2715872] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6rLD4CDndN4tFiVth23tXZQL7cguVsyQKC2KWQgMH7a2",
    "fee": 3500000,
    "feeAssetId": null,
    "timestamp": 1692351884920,
    "version": 1,
    "sender": "3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP",
    "senderPublicKey": "AoKo4segKHU4DeJnxXQYJj2u7J6XJeux6r8KLW52cd2Q",
    "proofs": [
        "2bexnAQwzNAYPdUEqouvgQPcZK3C1dVmL5i5bNuZRyCkMiZ85C1SuGg7AkdbCkSUaTmY9UDrhaewbbWdZyFagPoP"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2715872,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: G5PH2HgsX53FmJ1aYeViXQsxTuPvCf4XogMtSW3tEvZa
Next: CphUDDL8wy6DDW4P13GA5Up16NHqiMwP9TkSLAjEchGk

Diff: 

OldNewDifferences
355355     }
356356 
357357 
358+func getRewardSplit (generatorRewardAmount) = {
359+    let powerShareRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyPowerShareRatio()), 0), SCALE8])])
360+    let businessPartRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0), SCALE8])])
361+    let amountToPowerPart = fraction(generatorRewardAmount, powerShareRatio, SCALE8)
362+    let businessTreasuryAmountPart = fraction(generatorRewardAmount, businessPartRatio, SCALE8)
363+    let rewardRemainder = ((generatorRewardAmount - amountToPowerPart) - businessTreasuryAmountPart)
364+    if ((rewardRemainder > 0))
365+        then $Tuple3(amountToPowerPart, businessTreasuryAmountPart, rewardRemainder)
366+        else throwErr("amount to main treasury cannot be negative")
367+    }
368+
369+
370+func calcRewardSplitForAmount (amount) = {
371+    let blocksProcessingBatchSizeMax = 20
372+    let $t01008410177 = getRewardSplit(amount)
373+    let amountToPowerPart = $t01008410177._1
374+    let businessTreasuryAmountPart = $t01008410177._2
375+    let rewardRemainder = $t01008410177._3
376+    let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
377+    let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSizeMax)
378+    let toLpAmount = (rewardRemainder - blockProcessingReward)
379+    $Tuple5(amountToPowerPart, businessTreasuryAmountPart, blockProcessingReward, toLpAmount, amount)
380+    }
381+
382+
383+@Callable(i)
384+func rewardSplitREADONLY () = {
385+    let targetBlockHeight = (height - 1)
386+    let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
387+    let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, proxyTreasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
388+    $Tuple2(nil, calcRewardSplitForAmount(treasuryRewardOrFail))
389+    }
390+
391+
392+
358393 @Callable(i)
359394 func claimLP (userAddressBytes) = {
360395     let checkCaller = onlyFactory(i)
399434                 else throwErr("invalid PWR stake part")]
400435             if ((checks == checks))
401436                 then {
402-                    let $t01150211607 = calculatePrice(lpPartInWaves)
403-                    let newPrice = $t01150211607._1
404-                    let lpAssetAmountToBurn = $t01150211607._2
405-                    let lpAssetFinalQuantity = $t01150211607._3
437+                    let $t01351513620 = calculatePrice(lpPartInWaves)
438+                    let newPrice = $t01351513620._1
439+                    let lpAssetAmountToBurn = $t01351513620._2
440+                    let lpAssetFinalQuantity = $t01351513620._3
406441                     let newPeriod = (currentPeriodOrFail + 1)
407442                     func addNewAction (actions,payment) =                     {
408-                        let $t01175511817 = actions
409-                        let scriptTransfers = $t01175511817._1
410-                        let assetIdsString = $t01175511817._2
411-                        let amountsString = $t01175511817._3
443+                        let $t01376813830 = actions
444+                        let scriptTransfers = $t01376813830._1
445+                        let assetIdsString = $t01376813830._2
446+                        let amountsString = $t01376813830._3
412447                         let paymentAmount = payment.amount
413448                         let paymentAssetId = payment.assetId
414449                         let newAssetIdsString = ("%s" + makeString([assetIdsString, assetIdToString(paymentAssetId)], SEP))
417452                         $Tuple3((scriptTransfers :+ newScriptTransfer), newAssetIdsString, newAmountsString)
418453                         }
419454 
420-                    let $t01227712368 = {
455+                    let $t01429014381 = {
421456                         let $l = i.payments
422457                         let $s = size($l)
423458                         let $acc0 = $Tuple3(nil, "", "")
431466 
432467                         $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)
433468                         }
434-                    let scriptTransfers = $t01227712368._1
435-                    let AssetIds = $t01227712368._2
436-                    let Amounts = $t01227712368._3
469+                    let scriptTransfers = $t01429014381._1
470+                    let AssetIds = $t01429014381._2
471+                    let Amounts = $t01429014381._3
437472                     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)]
438473                     $Tuple2(scriptTransfers, factoryActions)
439474                     }
465500         else throwErr("invalid PWR stake part")]
466501     if ((checks == checks))
467502         then {
468-            let $t01524715352 = calculatePrice(lpPartInWaves)
469-            let newPrice = $t01524715352._1
470-            let lpAssetAmountToBurn = $t01524715352._2
471-            let lpAssetFinalQuantity = $t01524715352._3
503+            let $t01726017365 = calculatePrice(lpPartInWaves)
504+            let newPrice = $t01726017365._1
505+            let lpAssetAmountToBurn = $t01726017365._2
506+            let lpAssetFinalQuantity = $t01726017365._3
472507             $Tuple2(nil, $Tuple6(claimPartInWaves, lpPartInWaves, donationPartInWaves, newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity))
473508             }
474509         else throw("Strict value is not equal to itself.")
494529                     let payment = if ((size(i.payments) == 1))
495530                         then i.payments[0]
496531                         else throwErr("invalid payments")
497-                    let $t01646116638 = if (if ((payment.assetId == unit))
532+                    let $t01847418651 = if (if ((payment.assetId == unit))
498533                         then (payment.amount > 0)
499534                         else false)
500535                         then $Tuple2(payment.amount, payment.assetId)
501536                         else throwErr("invalid payment amount")
502-                    let paymentAmount = $t01646116638._1
503-                    let paymentAssetId = $t01646116638._2
537+                    let paymentAmount = $t01847418651._1
538+                    let paymentAssetId = $t01847418651._2
504539                     let treasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
505540                     let paymentsWithoutTreasuryPart = fraction(paymentAmount, (SCALE8 - treasuryPart), SCALE8)
506541                     let lpAssetAmount = if ((currentPriceOrFail > 0))
554589             let userAddress = Address(userAddressBytes)
555590             let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
556591             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
557-            let $t01937219485 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
558-            let status = $t01937219485._1
559-            let lpAssetAmount = $t01937219485._2
560-            let targetPeriod = $t01937219485._3
561-            let claimTxId = $t01937219485._4
592+            let $t02138521498 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
593+            let status = $t02138521498._1
594+            let lpAssetAmount = $t02138521498._2
595+            let targetPeriod = $t02138521498._3
596+            let claimTxId = $t02138521498._4
562597             let checks = [if ((status == PENDING))
563598                 then true
564599                 else throwErr("invalid withdrawal request status"), if ((targetPeriod > currentPeriodOrFail))
586621     let checkCaller = onlyFactory(i)
587622     if ((checkCaller == checkCaller))
588623         then {
589-            let $t02047120656 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
590-            let userAddress = $t02047120656._1
591-            let lpAssetAmount = $t02047120656._2
592-            let targetPeriod = $t02047120656._3
593-            let wavesAmount = $t02047120656._4
594-            let assetsString = $t02047120656._5
595-            let amountsString = $t02047120656._6
624+            let $t02248422669 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
625+            let userAddress = $t02248422669._1
626+            let lpAssetAmount = $t02248422669._2
627+            let targetPeriod = $t02248422669._3
628+            let wavesAmount = $t02248422669._4
629+            let assetsString = $t02248422669._5
630+            let amountsString = $t02248422669._6
596631             let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
597632             let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
598633             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)]
609644     if ((checkCaller == checkCaller))
610645         then {
611646             func addNewAction (state,txId) =             {
612-                let $t02141421613 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
613-                let userAddress = $t02141421613._1
614-                let lpAssetAmount = $t02141421613._2
615-                let targetPeriod = $t02141421613._3
616-                let wavesAmount = $t02141421613._4
617-                let assetsString = $t02141421613._5
618-                let amountsString = $t02141421613._6
647+                let $t02342723626 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
648+                let userAddress = $t02342723626._1
649+                let lpAssetAmount = $t02342723626._2
650+                let targetPeriod = $t02342723626._3
651+                let wavesAmount = $t02342723626._4
652+                let assetsString = $t02342723626._5
653+                let amountsString = $t02342723626._6
619654                 let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
620655                 let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
621656                 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)]
713748                     let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
714749                         then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
715750                         else blockProcessingRewardByGenerator
716-                    let powerShareRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyPowerShareRatio()), 0), SCALE8])])
717-                    let shareAmountToPower = fraction((treasuryRewardOrFail - callerReward), powerShareRatio, SCALE8)
751+                    let $t02756627674 = getRewardSplit(treasuryRewardOrFail)
752+                    let shareAmountToPower = $t02756627674._1
753+                    let businessTreasuryAmountPart = $t02756627674._2
754+                    let rewardRemainder = $t02756627674._3
718755                     let lpAssetAmount = if ((currentPriceOrFail > 0))
719-                        then fraction(((treasuryRewardOrFail - callerReward) - shareAmountToPower), SCALE8, currentPriceOrFail)
756+                        then fraction((rewardRemainder - callerReward), SCALE8, currentPriceOrFail)
720757                         else 0
721758                     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)]
722759                     if ((factoryActionsSingle == factoryActionsSingle))
723760                         then {
724-                            let $t02670426758 = acc
725-                            let lpAssetAcc = $t02670426758._1
726-                            let rewardAcc = $t02670426758._2
727-                            let powerShareDataTuple = $t02670426758._3
728-                            let $t02676526831 = powerShareDataTuple
729-                            let powerShareAcc = $t02676526831._1
730-                            let generatorPowerShareList = $t02676526831._2
761+                            let $t02852228597 = acc
762+                            let lpAssetAcc = $t02852228597._1
763+                            let rewardAcc = $t02852228597._2
764+                            let businessTreasuryAcc = $t02852228597._3
765+                            let powerShareDataTuple = $t02852228597._4
766+                            let $t02860428670 = powerShareDataTuple
767+                            let powerShareAcc = $t02860428670._1
768+                            let generatorPowerShareList = $t02860428670._2
731769                             let newGeneratorPowerShareList = (generatorPowerShareList :+ $Tuple2(toString(generator), shareAmountToPower))
732-                            $Tuple3((lpAssetAcc + lpAssetAmount), (rewardAcc + treasuryRewardOrFail), $Tuple2((powerShareAcc + shareAmountToPower), newGeneratorPowerShareList))
770+                            $Tuple4((lpAssetAcc + lpAssetAmount), (rewardAcc + treasuryRewardOrFail), (businessTreasuryAcc + businessTreasuryAmountPart), $Tuple2((powerShareAcc + shareAmountToPower), newGeneratorPowerShareList))
733771                             }
734772                         else throw("Strict value is not equal to itself.")
735773                     }
736774 
737775             let list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
738-            let $t02718627292 = {
776+            let $t02911829280 = {
739777                 let $l = list
740778                 let $s = size($l)
741-                let $acc0 = $Tuple3(0, 0, $Tuple2(0, nil))
779+                let $acc0 = $Tuple4(0, 0, 0, $Tuple2(0, nil))
742780                 func $f0_1 ($a,$i) =                 if (($i >= $s))
743781                     then $a
744782                     else map($a, $l[$i])
749787 
750788                 $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)
751789                 }
752-            if (($t02718627292 == $t02718627292))
790+            if (($t02911829280 == $t02911829280))
753791                 then {
754-                    let powerShareDataTuple = $t02718627292._3
755-                    let rewardAmountTotal = $t02718627292._2
756-                    let lpAssetAmountTotal = $t02718627292._1
757-                    let $t02729627365 = powerShareDataTuple
758-                    let amountToPowerTotal = $t02729627365._1
759-                    let powerShareAmountsList = $t02729627365._2
760-                    let businessTreasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
761-                    let rewardToBusinessTreasuryAmount = fraction(rewardAmountTotal, businessTreasuryPart, SCALE8)
792+                    let powerShareDataTuple = $t02911829280._4
793+                    let rewardToBusinessTreasuryAmount = $t02911829280._3
794+                    let rewardAmountTotal = $t02911829280._2
795+                    let lpAssetAmountTotal = $t02911829280._1
796+                    let $t02928429353 = powerShareDataTuple
797+                    let amountToPowerTotal = $t02928429353._1
798+                    let powerShareAmountsList = $t02928429353._2
762799                     let rewardToMainTreasuryAmount = (((rewardAmountTotal - rewardToBusinessTreasuryAmount) - blockProcessingReward) - amountToPowerTotal)
763800                     let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
764801                     let powerShareActions = if ((amountToPowerTotal > 0))
776813                                                     0
777814                                             }
778815                                             func stakePowerInvoke (acc,next) =                                             {
779-                                                let $t02844128476 = next
780-                                                let generator = $t02844128476._1
781-                                                let shareAmount = $t02844128476._2
816+                                                let $t03022730262 = next
817+                                                let generator = $t03022730262._1
818+                                                let shareAmount = $t03022730262._2
782819                                                 if ((amountToPowerTotal > 0))
783820                                                     then {
784821                                                         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 
358+func getRewardSplit (generatorRewardAmount) = {
359+    let powerShareRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyPowerShareRatio()), 0), SCALE8])])
360+    let businessPartRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0), SCALE8])])
361+    let amountToPowerPart = fraction(generatorRewardAmount, powerShareRatio, SCALE8)
362+    let businessTreasuryAmountPart = fraction(generatorRewardAmount, businessPartRatio, SCALE8)
363+    let rewardRemainder = ((generatorRewardAmount - amountToPowerPart) - businessTreasuryAmountPart)
364+    if ((rewardRemainder > 0))
365+        then $Tuple3(amountToPowerPart, businessTreasuryAmountPart, rewardRemainder)
366+        else throwErr("amount to main treasury cannot be negative")
367+    }
368+
369+
370+func calcRewardSplitForAmount (amount) = {
371+    let blocksProcessingBatchSizeMax = 20
372+    let $t01008410177 = getRewardSplit(amount)
373+    let amountToPowerPart = $t01008410177._1
374+    let businessTreasuryAmountPart = $t01008410177._2
375+    let rewardRemainder = $t01008410177._3
376+    let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
377+    let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSizeMax)
378+    let toLpAmount = (rewardRemainder - blockProcessingReward)
379+    $Tuple5(amountToPowerPart, businessTreasuryAmountPart, blockProcessingReward, toLpAmount, amount)
380+    }
381+
382+
383+@Callable(i)
384+func rewardSplitREADONLY () = {
385+    let targetBlockHeight = (height - 1)
386+    let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
387+    let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, proxyTreasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
388+    $Tuple2(nil, calcRewardSplitForAmount(treasuryRewardOrFail))
389+    }
390+
391+
392+
358393 @Callable(i)
359394 func claimLP (userAddressBytes) = {
360395     let checkCaller = onlyFactory(i)
361396     if ((checkCaller == checkCaller))
362397         then {
363398             let userAddress = Address(userAddressBytes)
364399             let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(userAddress)), 0)
365400             let claimed = valueOrElse(getInteger(factoryAddressOrFail, keyClaimed(userAddress)), 0)
366401             let factoryActions = if ((available > 0))
367402                 then [invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, available, lpAssetIdOrFail], nil), invoke(factoryAddressOrFail, "integerEntry", [keyAvailable(userAddress), 0], nil), invoke(factoryAddressOrFail, "integerEntry", [keyClaimed(userAddress), (claimed + available)], nil)]
368403                 else throwErr("nothing to claim")
369404             $Tuple2(nil, factoryActions)
370405             }
371406         else throw("Strict value is not equal to itself.")
372407     }
373408 
374409 
375410 
376411 @Callable(i)
377412 func finalize (userAddressBytes,donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
378413     let checkCaller = onlyFactory(i)
379414     if ((checkCaller == checkCaller))
380415         then {
381416             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
382417             let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
383418             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
384419             let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
385420             let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
386421             let periodEndHeight = ((currentStartHeight + periodLength) - 1)
387422             let checks = [if ((i.originCaller == mainTreasuryAddressOrFail))
388423                 then true
389424                 else throwErr("permission denied"), if ((nextBlockToProcess > periodEndHeight))
390425                 then true
391426                 else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
392427                 then true
393428                 else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
394429                 then true
395430                 else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
396431                 then true
397432                 else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
398433                 then true
399434                 else throwErr("invalid PWR stake part")]
400435             if ((checks == checks))
401436                 then {
402-                    let $t01150211607 = calculatePrice(lpPartInWaves)
403-                    let newPrice = $t01150211607._1
404-                    let lpAssetAmountToBurn = $t01150211607._2
405-                    let lpAssetFinalQuantity = $t01150211607._3
437+                    let $t01351513620 = calculatePrice(lpPartInWaves)
438+                    let newPrice = $t01351513620._1
439+                    let lpAssetAmountToBurn = $t01351513620._2
440+                    let lpAssetFinalQuantity = $t01351513620._3
406441                     let newPeriod = (currentPeriodOrFail + 1)
407442                     func addNewAction (actions,payment) =                     {
408-                        let $t01175511817 = actions
409-                        let scriptTransfers = $t01175511817._1
410-                        let assetIdsString = $t01175511817._2
411-                        let amountsString = $t01175511817._3
443+                        let $t01376813830 = actions
444+                        let scriptTransfers = $t01376813830._1
445+                        let assetIdsString = $t01376813830._2
446+                        let amountsString = $t01376813830._3
412447                         let paymentAmount = payment.amount
413448                         let paymentAssetId = payment.assetId
414449                         let newAssetIdsString = ("%s" + makeString([assetIdsString, assetIdToString(paymentAssetId)], SEP))
415450                         let newAmountsString = ("%d" + makeString([amountsString, toString(paymentAmount)], SEP))
416451                         let newScriptTransfer = ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)
417452                         $Tuple3((scriptTransfers :+ newScriptTransfer), newAssetIdsString, newAmountsString)
418453                         }
419454 
420-                    let $t01227712368 = {
455+                    let $t01429014381 = {
421456                         let $l = i.payments
422457                         let $s = size($l)
423458                         let $acc0 = $Tuple3(nil, "", "")
424459                         func $f0_1 ($a,$i) =                         if (($i >= $s))
425460                             then $a
426461                             else addNewAction($a, $l[$i])
427462 
428463                         func $f0_2 ($a,$i) =                         if (($i >= $s))
429464                             then $a
430465                             else throw("List size exceeds 10")
431466 
432467                         $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)
433468                         }
434-                    let scriptTransfers = $t01227712368._1
435-                    let AssetIds = $t01227712368._2
436-                    let Amounts = $t01227712368._3
469+                    let scriptTransfers = $t01429014381._1
470+                    let AssetIds = $t01429014381._2
471+                    let Amounts = $t01429014381._3
437472                     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)]
438473                     $Tuple2(scriptTransfers, factoryActions)
439474                     }
440475                 else throw("Strict value is not equal to itself.")
441476             }
442477         else throw("Strict value is not equal to itself.")
443478     }
444479 
445480 
446481 
447482 @Callable(i)
448483 func finalizeREADONLY (donationPartInWaves,lpPartInWaves,claimPartInWaves,powerStakePartInWaves) = {
449484     let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
450485     let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
451486     let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
452487     let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
453488     let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
454489     let periodEndHeight = ((currentStartHeight + periodLength) - 1)
455490     let checks = [if ((nextBlockToProcess > periodEndHeight))
456491         then true
457492         else throwErr("unprocessed blocks"), if ((donationPartInWaves >= 0))
458493         then true
459494         else throwErr("invalid donation part"), if ((lpPartInWaves >= 0))
460495         then true
461496         else throwErr("invalid lp part"), if ((claimPartInWaves >= 0))
462497         then true
463498         else throwErr("invalid claim part"), if ((powerStakePartInWaves >= 0))
464499         then true
465500         else throwErr("invalid PWR stake part")]
466501     if ((checks == checks))
467502         then {
468-            let $t01524715352 = calculatePrice(lpPartInWaves)
469-            let newPrice = $t01524715352._1
470-            let lpAssetAmountToBurn = $t01524715352._2
471-            let lpAssetFinalQuantity = $t01524715352._3
503+            let $t01726017365 = calculatePrice(lpPartInWaves)
504+            let newPrice = $t01726017365._1
505+            let lpAssetAmountToBurn = $t01726017365._2
506+            let lpAssetFinalQuantity = $t01726017365._3
472507             $Tuple2(nil, $Tuple6(claimPartInWaves, lpPartInWaves, donationPartInWaves, newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity))
473508             }
474509         else throw("Strict value is not equal to itself.")
475510     }
476511 
477512 
478513 
479514 @Callable(i)
480515 func invest (userAddressBytes) = {
481516     let checkCaller = onlyFactory(i)
482517     if ((checkCaller == checkCaller))
483518         then {
484519             let userAddress = Address(userAddressBytes)
485520             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
486521             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
487522             let investPeriodLength = getIntegerValue(factoryAddressOrFail, keyInvestPeriodLength())
488523             let heightCheck = if (((currentStartHeight + investPeriodLength) > height))
489524                 then true
490525                 else throwErr("too late to invest in this period")
491526             if ((heightCheck == heightCheck))
492527                 then {
493528                     let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
494529                     let payment = if ((size(i.payments) == 1))
495530                         then i.payments[0]
496531                         else throwErr("invalid payments")
497-                    let $t01646116638 = if (if ((payment.assetId == unit))
532+                    let $t01847418651 = if (if ((payment.assetId == unit))
498533                         then (payment.amount > 0)
499534                         else false)
500535                         then $Tuple2(payment.amount, payment.assetId)
501536                         else throwErr("invalid payment amount")
502-                    let paymentAmount = $t01646116638._1
503-                    let paymentAssetId = $t01646116638._2
537+                    let paymentAmount = $t01847418651._1
538+                    let paymentAssetId = $t01847418651._2
504539                     let treasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
505540                     let paymentsWithoutTreasuryPart = fraction(paymentAmount, (SCALE8 - treasuryPart), SCALE8)
506541                     let lpAssetAmount = if ((currentPriceOrFail > 0))
507542                         then fraction(paymentsWithoutTreasuryPart, SCALE8, currentPriceOrFail)
508543                         else 0
509544                     let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
510545                     let actions = [ScriptTransfer(mainTreasuryAddressOrFail, paymentsWithoutTreasuryPart, paymentAssetId), ScriptTransfer(businessTreasuryAddressOrFail, treasuryPart, paymentAssetId)]
511546                     let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), (invested + paymentsWithoutTreasuryPart)], nil), invoke(factoryAddressOrFail, "reissue", [lpAssetAmount], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
512547                     $Tuple2(actions, factoryActions)
513548                     }
514549                 else throw("Strict value is not equal to itself.")
515550             }
516551         else throw("Strict value is not equal to itself.")
517552     }
518553 
519554 
520555 
521556 @Callable(i)
522557 func withdraw (userAddressBytes) = {
523558     let checkCaller = onlyFactory(i)
524559     if ((checkCaller == checkCaller))
525560         then {
526561             let userAddress = Address(userAddressBytes)
527562             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
528563             let payment = if ((size(i.payments) == 1))
529564                 then i.payments[0]
530565                 else throwErr(wrapErr("invalid payments"))
531566             let paymentAssetId = if ((payment.assetId == lpAssetIdOrFail))
532567                 then lpAssetIdOrFail
533568                 else throwErr("invalid payment asset")
534569             let paymentAmount = if ((payment.amount > 0))
535570                 then payment.amount
536571                 else throwErr("invalid payment amount")
537572             let withdrawal = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
538573             let actions = [ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)]
539574             let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), (withdrawal + paymentAmount)], nil), invoke(factoryAddressOrFail, "stringEntry", [keyWithdrawalRequest(userAddress, i.transactionId), valueWithdrawalRequest(PENDING, paymentAmount, (currentPeriodOrFail + 1), unit)], nil)]
540575             if ((factoryActions == factoryActions))
541576                 then $Tuple2(actions, factoryActions)
542577                 else throw("Strict value is not equal to itself.")
543578             }
544579         else throw("Strict value is not equal to itself.")
545580     }
546581 
547582 
548583 
549584 @Callable(i)
550585 func cancelWithdraw (userAddressBytes,txId) = {
551586     let checkCaller = onlyFactory(i)
552587     if ((checkCaller == checkCaller))
553588         then {
554589             let userAddress = Address(userAddressBytes)
555590             let withdrawalRequestOption = valueOrErrorMessage(getString(factoryAddressOrFail, keyWithdrawalRequest(userAddress, txId)), wrapErr("invalid withdrawal request"))
556591             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
557-            let $t01937219485 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
558-            let status = $t01937219485._1
559-            let lpAssetAmount = $t01937219485._2
560-            let targetPeriod = $t01937219485._3
561-            let claimTxId = $t01937219485._4
592+            let $t02138521498 = parseWithdrawalRequestValueOrFail(withdrawalRequestOption)
593+            let status = $t02138521498._1
594+            let lpAssetAmount = $t02138521498._2
595+            let targetPeriod = $t02138521498._3
596+            let claimTxId = $t02138521498._4
562597             let checks = [if ((status == PENDING))
563598                 then true
564599                 else throwErr("invalid withdrawal request status"), if ((targetPeriod > currentPeriodOrFail))
565600                 then true
566601                 else throwErr("invalid withdrawal request period")]
567602             if ((checks == checks))
568603                 then {
569604                     let withdrawal = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyWithdrawal()), wrapErr("invalid total withdrawal amount"))
570605                     let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), if ((withdrawal >= lpAssetAmount))
571606                         then (withdrawal - lpAssetAmount)
572607                         else throwErr("invalid withdrawal amount")], nil), invoke(factoryAddressOrFail, "deleteEntry", [keyWithdrawalRequest(userAddress, txId)], nil), invoke(factoryAddressOrFail, "transferAsset", [userAddressBytes, lpAssetAmount, lpAssetIdOrFail], nil)]
573608                     if ((factoryActions == factoryActions))
574609                         then $Tuple2(nil, factoryActions)
575610                         else throw("Strict value is not equal to itself.")
576611                     }
577612                 else throw("Strict value is not equal to itself.")
578613             }
579614         else throw("Strict value is not equal to itself.")
580615     }
581616 
582617 
583618 
584619 @Callable(i)
585620 func claimCollateral (userAddressBytes,txId) = {
586621     let checkCaller = onlyFactory(i)
587622     if ((checkCaller == checkCaller))
588623         then {
589-            let $t02047120656 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
590-            let userAddress = $t02047120656._1
591-            let lpAssetAmount = $t02047120656._2
592-            let targetPeriod = $t02047120656._3
593-            let wavesAmount = $t02047120656._4
594-            let assetsString = $t02047120656._5
595-            let amountsString = $t02047120656._6
624+            let $t02248422669 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
625+            let userAddress = $t02248422669._1
626+            let lpAssetAmount = $t02248422669._2
627+            let targetPeriod = $t02248422669._3
628+            let wavesAmount = $t02248422669._4
629+            let assetsString = $t02248422669._5
630+            let amountsString = $t02248422669._6
596631             let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
597632             let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
598633             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)]
599634             $Tuple2(nil, factoryActions)
600635             }
601636         else throw("Strict value is not equal to itself.")
602637     }
603638 
604639 
605640 
606641 @Callable(i)
607642 func claimCollateralBulk (userAddressBytes,txIds) = {
608643     let checkCaller = onlyFactory(i)
609644     if ((checkCaller == checkCaller))
610645         then {
611646             func addNewAction (state,txId) =             {
612-                let $t02141421613 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
613-                let userAddress = $t02141421613._1
614-                let lpAssetAmount = $t02141421613._2
615-                let targetPeriod = $t02141421613._3
616-                let wavesAmount = $t02141421613._4
617-                let assetsString = $t02141421613._5
618-                let amountsString = $t02141421613._6
647+                let $t02342723626 = claimCollateralINTERNAL(userAddressBytes, fromBase58String(txId))
648+                let userAddress = $t02342723626._1
649+                let lpAssetAmount = $t02342723626._2
650+                let targetPeriod = $t02342723626._3
651+                let wavesAmount = $t02342723626._4
652+                let assetsString = $t02342723626._5
653+                let amountsString = $t02342723626._6
619654                 let assetsList = removeByIndex(split_51C(assetsString, SEP), 0)
620655                 let amountsList = removeByIndex(split_51C(amountsString, SEP), 0)
621656                 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)]
622657                 (state ++ newActions)
623658                 }
624659 
625660             let allFactoryActions = {
626661                 let $l = txIds
627662                 let $s = size($l)
628663                 let $acc0 = nil
629664                 func $f0_1 ($a,$i) =                 if (($i >= $s))
630665                     then $a
631666                     else addNewAction($a, $l[$i])
632667 
633668                 func $f0_2 ($a,$i) =                 if (($i >= $s))
634669                     then $a
635670                     else throw("List size exceeds 10")
636671 
637672                 $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)
638673                 }
639674             $Tuple2(nil, allFactoryActions)
640675             }
641676         else throw("Strict value is not equal to itself.")
642677     }
643678 
644679 
645680 
646681 @Callable(i)
647682 func claimCollateralREADONLY (userAddressBytes,txId) = {
648683     let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
649684     $Tuple2(nil, response)
650685     }
651686 
652687 
653688 
654689 @Callable(i)
655690 func claimCollateralBulkREADONLY (userAddressBytes,txIds) = {
656691     func processTxId (state,txId) =     {
657692         let response = claimCollateralREADONLYStringResponse(userAddressBytes, fromBase58String(txId))
658693         (state :+ response)
659694         }
660695 
661696     let allResponses = {
662697         let $l = txIds
663698         let $s = size($l)
664699         let $acc0 = nil
665700         func $f0_1 ($a,$i) =         if (($i >= $s))
666701             then $a
667702             else processTxId($a, $l[$i])
668703 
669704         func $f0_2 ($a,$i) =         if (($i >= $s))
670705             then $a
671706             else throw("List size exceeds 10")
672707 
673708         $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)
674709         }
675710     $Tuple2(nil, allResponses)
676711     }
677712 
678713 
679714 
680715 @Callable(i)
681716 func processBlocks (userAddressBytes) = {
682717     let checkCaller = onlyFactory(i)
683718     if ((checkCaller == checkCaller))
684719         then {
685720             let userAddress = Address(userAddressBytes)
686721             let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
687722             let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
688723             let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
689724             let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
690725             let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
691726             let periodEndHeight = ((currentStartHeight + periodLength) - 1)
692727             let blocksProcessingBatchSizeMax = 20
693728             let blocksProcessingBatchSize = if (if (if ((height >= nextBlockToProcess))
694729                 then if ((nextBlockToProcess >= currentStartHeight))
695730                     then true
696731                     else (currentPeriodOrFail == 0)
697732                 else false)
698733                 then (periodEndHeight >= nextBlockToProcess)
699734                 else false)
700735                 then min([((periodEndHeight - nextBlockToProcess) + 1), blocksProcessingBatchSizeMax])
701736                 else throwErr(wrapErr("invalid target block"))
702737             let blockProcessingReward = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyBlockProcessingReward()), wrapErr("invalid block processing reward"))
703738             let blockProcessingRewardByGenerator = (blockProcessingReward / blocksProcessingBatchSize)
704739             let blockProcessingRewardByGeneratorRemainder = (blockProcessingReward - (blockProcessingRewardByGenerator * blocksProcessingBatchSize))
705740             func map (acc,inc) =             if ((inc >= blocksProcessingBatchSize))
706741                 then acc
707742                 else {
708743                     let targetBlockHeight = (nextBlockToProcess + inc)
709744                     let targetBlockInfo = valueOrErrorMessage(blockInfoByHeight(targetBlockHeight), wrapErr("invalid block info"))
710745                     let treasuryRewardOrFail = valueOrErrorMessage(rewardForOption(targetBlockInfo.rewards, proxyTreasuryAddressOrFail), wrapErr(("invalid treasury reward for height " + toString(targetBlockHeight))))
711746                     let generator = targetBlockInfo.generator
712747                     let available = valueOrElse(getInteger(factoryAddressOrFail, keyAvailable(generator)), 0)
713748                     let callerReward = if ((inc == (blocksProcessingBatchSize - 1)))
714749                         then (blockProcessingRewardByGenerator + blockProcessingRewardByGeneratorRemainder)
715750                         else blockProcessingRewardByGenerator
716-                    let powerShareRatio = max([0, min([valueOrElse(getInteger(factoryAddressOrFail, keyPowerShareRatio()), 0), SCALE8])])
717-                    let shareAmountToPower = fraction((treasuryRewardOrFail - callerReward), powerShareRatio, SCALE8)
751+                    let $t02756627674 = getRewardSplit(treasuryRewardOrFail)
752+                    let shareAmountToPower = $t02756627674._1
753+                    let businessTreasuryAmountPart = $t02756627674._2
754+                    let rewardRemainder = $t02756627674._3
718755                     let lpAssetAmount = if ((currentPriceOrFail > 0))
719-                        then fraction(((treasuryRewardOrFail - callerReward) - shareAmountToPower), SCALE8, currentPriceOrFail)
756+                        then fraction((rewardRemainder - callerReward), SCALE8, currentPriceOrFail)
720757                         else 0
721758                     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)]
722759                     if ((factoryActionsSingle == factoryActionsSingle))
723760                         then {
724-                            let $t02670426758 = acc
725-                            let lpAssetAcc = $t02670426758._1
726-                            let rewardAcc = $t02670426758._2
727-                            let powerShareDataTuple = $t02670426758._3
728-                            let $t02676526831 = powerShareDataTuple
729-                            let powerShareAcc = $t02676526831._1
730-                            let generatorPowerShareList = $t02676526831._2
761+                            let $t02852228597 = acc
762+                            let lpAssetAcc = $t02852228597._1
763+                            let rewardAcc = $t02852228597._2
764+                            let businessTreasuryAcc = $t02852228597._3
765+                            let powerShareDataTuple = $t02852228597._4
766+                            let $t02860428670 = powerShareDataTuple
767+                            let powerShareAcc = $t02860428670._1
768+                            let generatorPowerShareList = $t02860428670._2
731769                             let newGeneratorPowerShareList = (generatorPowerShareList :+ $Tuple2(toString(generator), shareAmountToPower))
732-                            $Tuple3((lpAssetAcc + lpAssetAmount), (rewardAcc + treasuryRewardOrFail), $Tuple2((powerShareAcc + shareAmountToPower), newGeneratorPowerShareList))
770+                            $Tuple4((lpAssetAcc + lpAssetAmount), (rewardAcc + treasuryRewardOrFail), (businessTreasuryAcc + businessTreasuryAmountPart), $Tuple2((powerShareAcc + shareAmountToPower), newGeneratorPowerShareList))
733771                             }
734772                         else throw("Strict value is not equal to itself.")
735773                     }
736774 
737775             let list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
738-            let $t02718627292 = {
776+            let $t02911829280 = {
739777                 let $l = list
740778                 let $s = size($l)
741-                let $acc0 = $Tuple3(0, 0, $Tuple2(0, nil))
779+                let $acc0 = $Tuple4(0, 0, 0, $Tuple2(0, nil))
742780                 func $f0_1 ($a,$i) =                 if (($i >= $s))
743781                     then $a
744782                     else map($a, $l[$i])
745783 
746784                 func $f0_2 ($a,$i) =                 if (($i >= $s))
747785                     then $a
748786                     else throw("List size exceeds 20")
749787 
750788                 $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)
751789                 }
752-            if (($t02718627292 == $t02718627292))
790+            if (($t02911829280 == $t02911829280))
753791                 then {
754-                    let powerShareDataTuple = $t02718627292._3
755-                    let rewardAmountTotal = $t02718627292._2
756-                    let lpAssetAmountTotal = $t02718627292._1
757-                    let $t02729627365 = powerShareDataTuple
758-                    let amountToPowerTotal = $t02729627365._1
759-                    let powerShareAmountsList = $t02729627365._2
760-                    let businessTreasuryPart = valueOrElse(getInteger(factoryAddressOrFail, keyBusinessTreasuryPart()), 0)
761-                    let rewardToBusinessTreasuryAmount = fraction(rewardAmountTotal, businessTreasuryPart, SCALE8)
792+                    let powerShareDataTuple = $t02911829280._4
793+                    let rewardToBusinessTreasuryAmount = $t02911829280._3
794+                    let rewardAmountTotal = $t02911829280._2
795+                    let lpAssetAmountTotal = $t02911829280._1
796+                    let $t02928429353 = powerShareDataTuple
797+                    let amountToPowerTotal = $t02928429353._1
798+                    let powerShareAmountsList = $t02928429353._2
762799                     let rewardToMainTreasuryAmount = (((rewardAmountTotal - rewardToBusinessTreasuryAmount) - blockProcessingReward) - amountToPowerTotal)
763800                     let invested = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
764801                     let powerShareActions = if ((amountToPowerTotal > 0))
765802                         then {
766803                             let transferAction = [invoke(factoryAddressOrFail, "transferFromProxyTreasury", [factoryAddressOrFail.bytes, amountToPowerTotal], nil)]
767804                             if ((transferAction == transferAction))
768805                                 then {
769806                                     let totalPowerAmount = invoke(factoryAddressOrFail, "swap", [powerAssetIdStringOrFail, WAVES, amountToPowerTotal], nil)
770807                                     if ((totalPowerAmount == totalPowerAmount))
771808                                         then {
772809                                             let totalPowerAmountInt =                                             match totalPowerAmount {
773810                                                 case pAmount: Int => 
774811                                                     pAmount
775812                                                 case _ => 
776813                                                     0
777814                                             }
778815                                             func stakePowerInvoke (acc,next) =                                             {
779-                                                let $t02844128476 = next
780-                                                let generator = $t02844128476._1
781-                                                let shareAmount = $t02844128476._2
816+                                                let $t03022730262 = next
817+                                                let generator = $t03022730262._1
818+                                                let shareAmount = $t03022730262._2
782819                                                 if ((amountToPowerTotal > 0))
783820                                                     then {
784821                                                         let powerAmount = fraction(shareAmount, totalPowerAmountInt, amountToPowerTotal)
785822                                                         let inv = invoke(factoryAddressOrFail, "powerStake", [fromBase58String(generator), fromBase58String(powerAssetIdStringOrFail), powerAmount], nil)
786823                                                         if ((inv == inv))
787824                                                             then nil
788825                                                             else throw("Strict value is not equal to itself.")
789826                                                         }
790827                                                     else nil
791828                                                 }
792829 
793830                                             let powerStakesActions = {
794831                                                 let $l = powerShareAmountsList
795832                                                 let $s = size($l)
796833                                                 let $acc0 = 0
797834                                                 func $f1_1 ($a,$i) =                                                 if (($i >= $s))
798835                                                     then $a
799836                                                     else stakePowerInvoke($a, $l[$i])
800837 
801838                                                 func $f1_2 ($a,$i) =                                                 if (($i >= $s))
802839                                                     then $a
803840                                                     else throw("List size exceeds 20")
804841 
805842                                                 $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)
806843                                                 }
807844                                             if ((powerStakesActions == powerStakesActions))
808845                                                 then nil
809846                                                 else throw("Strict value is not equal to itself.")
810847                                             }
811848                                         else throw("Strict value is not equal to itself.")
812849                                     }
813850                                 else throw("Strict value is not equal to itself.")
814851                             }
815852                         else nil
816853                     if ((powerShareActions == powerShareActions))
817854                         then {
818855                             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)]
819856                             if ((actions == actions))
820857                                 then $Tuple2(nil, unit)
821858                                 else throw("Strict value is not equal to itself.")
822859                             }
823860                         else throw("Strict value is not equal to itself.")
824861                     }
825862                 else throw("Strict value is not equal to itself.")
826863             }
827864         else throw("Strict value is not equal to itself.")
828865     }
829866 
830867 
831868 @Verifier(tx)
832869 func verify () = {
833870     let publicKey =     match getManagerPublicKeyOrUnit() {
834871         case pub: ByteVector => 
835872             pub
836873         case _ => 
837874             tx.senderPublicKey
838875     }
839876     sigVerify(tx.bodyBytes, tx.proofs[0], publicKey)
840877     }
841878 
github/deemru/w8io/169f3d6 
103.80 ms ◑