@rev-net/core-v6 0.0.36 → 0.0.39

package/test/fork/TestAutoIssuanceFork.t.sol

@@ -1,148 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "./ForkTestBase.sol";
-import {REVEmpty721Config} from "../helpers/REVEmpty721Config.sol";
-
-/// @notice Fork tests for revnet auto-issuance (per-stage premint) mechanics.
-///
-/// Verifies that `autoIssueFor()` mints tokens to the beneficiary at the correct time,
-/// bypasses the reserved percent, and properly prevents double claims and early claims.
-///
-/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestAutoIssuanceFork -vvv
-contract TestAutoIssuanceFork is ForkTestBase {
-    // forge-lint: disable-next-line(mixed-case-variable)
-    address AUTO_BENEFICIARY = makeAddr("autoBeneficiary");
-    uint104 constant AUTO_ISSUE_COUNT = 500e18; // 500 tokens
-
-    /// @notice Deploy a revnet with auto-issuance configured for the first stage.
-    /// @param splitPercent The reserved percent (splitPercent) for the stage.
-    /// @param startsInFuture If true, the stage starts 1 day in the future; otherwise starts now.
-    /// @return revnetId The deployed revnet's project ID.
-    /// @return stageId The stage ID (ruleset ID) for the auto-issuance.
-    function _deployRevnetWithAutoIssuance(
-        uint16 splitPercent,
-        bool startsInFuture
-    )
-        internal
-        returns (uint256 revnetId, uint256 stageId)
-    {
-        JBAccountingContext[] memory acc = new JBAccountingContext[](1);
-        acc[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
-        JBTerminalConfig[] memory tc = new JBTerminalConfig[](1);
-        tc[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: acc});
-
-        // Configure auto-issuance for this chain.
-        REVAutoIssuance[] memory autoIssuances = new REVAutoIssuance[](1);
-        autoIssuances[0] =
-            REVAutoIssuance({chainId: uint32(block.chainid), count: AUTO_ISSUE_COUNT, beneficiary: AUTO_BENEFICIARY});
-
-        REVStageConfig[] memory stages = new REVStageConfig[](1);
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0].beneficiary = payable(multisig());
-        splits[0].percent = 10_000;
-
-        uint48 startTime = startsInFuture ? uint48(block.timestamp + 1 days) : uint48(block.timestamp);
-
-        stages[0] = REVStageConfig({
-            startsAtOrAfter: uint40(startTime),
-            autoIssuances: autoIssuances,
-            splitPercent: splitPercent,
-            splits: splits,
-            initialIssuance: INITIAL_ISSUANCE,
-            issuanceCutFrequency: 0,
-            issuanceCutPercent: 0,
-            cashOutTaxRate: 5000,
-            extraMetadata: 0
-        });
-
-        REVConfig memory cfg = REVConfig({
-            description: REVDescription("AutoIssue Test", "AUTO", "ipfs://auto", "AUTO_SALT"),
-            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
-            splitOperator: multisig(),
-            stageConfigurations: stages
-        });
-
-        REVSuckerDeploymentConfig memory sdc = REVSuckerDeploymentConfig({
-            deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256(abi.encodePacked("AUTO_TEST"))
-        });
-
-        // The stageId is block.timestamp + 0 (first stage index is 0).
-        stageId = block.timestamp;
-
-        (revnetId,) = REV_DEPLOYER.deployFor({
-            revnetId: 0,
-            configuration: cfg,
-            terminalConfigurations: tc,
-            suckerDeploymentConfiguration: sdc,
-            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
-            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
-        });
-    }
-
-    function setUp() public override {
-        super.setUp();
-        _deployFeeProject(5000);
-    }
-
-    /// @notice Calling autoIssueFor before the stage starts should revert with REVDeployer_StageNotStarted.
-    function testFork_AutoIssueBeforeStageReverts() public {
-        (uint256 revnetId, uint256 stageId) = _deployRevnetWithAutoIssuance({splitPercent: 0, startsInFuture: true});
-
-        // Stage starts in the future, so autoIssueFor should revert.
-        vm.expectRevert(abi.encodeWithSelector(REVDeployer.REVDeployer_StageNotStarted.selector, stageId));
-        REV_DEPLOYER.autoIssueFor(revnetId, stageId, AUTO_BENEFICIARY);
-    }
-
-    /// @notice After the stage starts, autoIssueFor mints the exact configured count to the beneficiary.
-    function testFork_AutoIssueAfterStageStart() public {
-        (uint256 revnetId, uint256 stageId) = _deployRevnetWithAutoIssuance({splitPercent: 0, startsInFuture: false});
-
-        // Verify beneficiary has no tokens initially.
-        uint256 balanceBefore = jbTokens().totalBalanceOf(AUTO_BENEFICIARY, revnetId);
-        assertEq(balanceBefore, 0, "beneficiary should have no tokens before auto-issue");
-
-        // Auto-issue tokens.
-        REV_DEPLOYER.autoIssueFor(revnetId, stageId, AUTO_BENEFICIARY);
-
-        // Verify beneficiary received exactly AUTO_ISSUE_COUNT tokens.
-        uint256 balanceAfter = jbTokens().totalBalanceOf(AUTO_BENEFICIARY, revnetId);
-        assertEq(balanceAfter, AUTO_ISSUE_COUNT, "beneficiary should receive exactly the configured token count");
-    }
-
-    /// @notice A second call to autoIssueFor for the same beneficiary/stage reverts with NothingToAutoIssue.
-    function testFork_AutoIssueDoubleClaimReverts() public {
-        (uint256 revnetId, uint256 stageId) = _deployRevnetWithAutoIssuance({splitPercent: 0, startsInFuture: false});
-
-        // First claim succeeds.
-        REV_DEPLOYER.autoIssueFor(revnetId, stageId, AUTO_BENEFICIARY);
-
-        // Second claim should revert — amount was reset to 0.
-        vm.expectRevert(REVDeployer.REVDeployer_NothingToAutoIssue.selector);
-        REV_DEPLOYER.autoIssueFor(revnetId, stageId, AUTO_BENEFICIARY);
-    }
-
-    /// @notice Auto-issued tokens bypass the reserved percent — 100% goes to the beneficiary.
-    function testFork_AutoIssueBypassesReservedPercent() public {
-        // Deploy with 50% splitPercent (reserved percent).
-        (uint256 revnetId, uint256 stageId) = _deployRevnetWithAutoIssuance({splitPercent: 5000, startsInFuture: false});
-
-        // Auto-issue tokens.
-        REV_DEPLOYER.autoIssueFor(revnetId, stageId, AUTO_BENEFICIARY);
-
-        // The beneficiary should receive the FULL count, not reduced by reserved percent.
-        uint256 balance = jbTokens().totalBalanceOf(AUTO_BENEFICIARY, revnetId);
-        assertEq(
-            balance, AUTO_ISSUE_COUNT, "auto-issued tokens should bypass reserved percent - full amount to beneficiary"
-        );
-
-        // Verify no pending reserved tokens were accumulated from the auto-issue.
-        // The mintTokensOf call uses useReservedPercent: false, so pendingReservedTokenBalanceOf should be 0.
-        uint256 pending = jbController().pendingReservedTokenBalanceOf(revnetId);
-        assertEq(pending, 0, "no reserved tokens should be pending from auto-issue");
-    }
-}

package/test/fork/TestCashOutFork.t.sol

@@ -1,253 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "./ForkTestBase.sol";
-import {REVEmpty721Config} from "../helpers/REVEmpty721Config.sol";
-
-/// @notice Fork tests for revnet cash-out scenarios with real Uniswap V4 buyback hook.
-///
-/// Covers: fee deduction, high tax rate, sucker exemption, surplus after tier splits, and delay enforcement.
-///
-/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestCashOutFork -vvv
-contract TestCashOutFork is ForkTestBase {
-    uint256 revnetId;
-
-    function setUp() public override {
-        super.setUp();
-
-        // Deploy fee project + revnet with 50% cashOutTaxRate.
-        _deployFeeProject(5000);
-        revnetId = _deployRevnet(5000);
-
-        // Set up pool at 1:1 (mint path wins).
-        _setupPool(revnetId, 10_000 ether);
-
-        // Pay 10 ETH to create surplus and tokens.
-        _payRevnet(revnetId, PAYER, 10 ether);
-
-        // Warp past the 30-day cash-out delay.
-        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
-    }
-
-    /// @notice Cash out tokens and verify fee deduction, token burn, and bonding curve reclaim.
-    function test_fork_cashOut_normalWithFee() public {
-        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, revnetId);
-        uint256 cashOutCount = payerTokens / 2; // Cash out half.
-
-        // Record state before.
-        uint256 payerEthBefore = PAYER.balance;
-        uint256 feeTerminalBefore = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
-        uint256 totalSupplyBefore = jbTokens().totalSupplyOf(revnetId);
-
-        // Cash out. When the buyback hook finds a better swap route, it sets cashOutTaxRate = MAX
-        // so reclaimedAmount (direct reclaim) is 0 — beneficiary gets ETH via hook swap instead.
-        vm.prank(PAYER);
-        jbMultiTerminal()
-            .cashOutTokensOf({
-                holder: PAYER,
-                projectId: revnetId,
-                cashOutCount: cashOutCount,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(PAYER),
-                metadata: ""
-            });
-
-        // Payer received ETH (via buyback hook swap).
-        uint256 ethReceived = PAYER.balance - payerEthBefore;
-        assertGt(ethReceived, 0, "payer should receive ETH");
-
-        // Fee project terminal balance increased (2.5% fee on the cashout portion processed by REVDeployer hook).
-        uint256 feeTerminalAfter = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
-        assertGt(feeTerminalAfter, feeTerminalBefore, "fee project should receive fee");
-
-        // When the sell-side buyback route is used, the hook mints tokens to sell into the pool,
-        // so net token supply stays the same (burn + re-mint). Verify supply didn't increase.
-        uint256 totalSupplyAfter = jbTokens().totalSupplyOf(revnetId);
-        assertLe(totalSupplyAfter, totalSupplyBefore, "total supply should not increase");
-    }
-
-    /// @notice High tax rate (90%) produces small reclaim relative to pro-rata.
-    function test_fork_cashOut_highTaxRate() public {
-        // Deploy a separate revnet with 90% tax rate.
-        uint256 highTaxRevnet = _deployRevnet(9000);
-        _setupPool(highTaxRevnet, 10_000 ether);
-        _payRevnet(highTaxRevnet, PAYER, 10 ether);
-        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
-
-        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, highTaxRevnet);
-        uint256 cashOutCount = payerTokens / 2;
-
-        vm.prank(PAYER);
-        uint256 reclaimedAmount = jbMultiTerminal()
-            .cashOutTokensOf({
-                holder: PAYER,
-                projectId: highTaxRevnet,
-                cashOutCount: cashOutCount,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(PAYER),
-                metadata: ""
-            });
-
-        // With 90% tax rate, reclaim should be very small relative to surplus.
-        uint256 terminalBalance = _terminalBalance(highTaxRevnet, JBConstants.NATIVE_TOKEN);
-        uint256 totalSurplus = terminalBalance + reclaimedAmount;
-        uint256 proRataShare = (totalSurplus * cashOutCount) / payerTokens;
-
-        // At 90% tax rate with 50% of supply, reclaim ~= proRata * (10% + 90% * 0.5) = proRata * 55%.
-        // But also minus 2.5% fee. Should be well under 60% of pro-rata.
-        assertLt(reclaimedAmount, (proRataShare * 60) / 100, "high tax: reclaim should be very small");
-    }
-
-    /// @notice Sucker addresses get full pro-rata reclaim with 0% tax and no fee.
-    function test_fork_cashOut_suckerExempt() public {
-        address sucker = makeAddr("sucker");
-        vm.deal(sucker, 100 ether);
-
-        // Pay as sucker to get tokens.
-        _payRevnet(revnetId, sucker, 5 ether);
-
-        uint256 suckerTokens = jbTokens().totalBalanceOf(sucker, revnetId);
-        uint256 totalSupply = jbTokens().totalSupplyOf(revnetId);
-        uint256 surplus = _terminalBalance(revnetId, JBConstants.NATIVE_TOKEN);
-
-        // Mock sucker registry to report this address as a sucker.
-        vm.mockCall(
-            address(SUCKER_REGISTRY),
-            abi.encodeWithSelector(IJBSuckerRegistry.isSuckerOf.selector, revnetId, sucker),
-            abi.encode(true)
-        );
-
-        uint256 feeTerminalBefore = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
-
-        vm.prank(sucker);
-        uint256 reclaimedAmount = jbMultiTerminal()
-            .cashOutTokensOf({
-                holder: sucker,
-                projectId: revnetId,
-                cashOutCount: suckerTokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(sucker),
-                metadata: ""
-            });
-
-        // Full pro-rata reclaim (0% tax).
-        uint256 expectedReclaim = (surplus * suckerTokens) / totalSupply;
-        assertEq(reclaimedAmount, expectedReclaim, "sucker should get full pro-rata reclaim");
-
-        // No fee charged.
-        uint256 feeTerminalAfter = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
-        assertEq(feeTerminalAfter, feeTerminalBefore, "no fee should be charged for sucker");
-    }
-
-    /// @notice After a payment with 30% tier split, surplus accounting reflects actual terminal balance.
-    function test_fork_cashOut_afterTierSplitPayment() public {
-        // Deploy revnet with 721 hook.
-        (uint256 splitRevnetId, IJB721TiersHook hook) = _deployRevnetWith721(5000);
-        _setupPool(splitRevnetId, 10_000 ether);
-
-        // Pay 1 ETH with tier metadata (triggers 30% split).
-        address metadataTarget = hook.METADATA_ID_TARGET();
-        bytes memory metadata = _buildPayMetadataNoQuote(metadataTarget);
-
-        vm.prank(PAYER);
-        jbMultiTerminal().pay{value: 1 ether}({
-            projectId: splitRevnetId,
-            token: JBConstants.NATIVE_TOKEN,
-            amount: 1 ether,
-            beneficiary: PAYER,
-            minReturnedTokens: 0,
-            memo: "",
-            metadata: metadata
-        });
-
-        // Warp past delay.
-        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
-
-        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, splitRevnetId);
-        uint256 terminalBalance = _terminalBalance(splitRevnetId, JBConstants.NATIVE_TOKEN);
-
-        // Terminal balance should be ~1 ETH (0.7 ETH project share + 0.3 ETH returned via addToBalance from 721
-        // hook).
-        assertGt(terminalBalance, 0, "terminal should have balance");
-
-        // Cash out should succeed using actual terminal balance as surplus.
-        // When the buyback hook finds a better swap route it sets cashOutTaxRate = MAX, so the terminal's
-        // direct reclaimAmount is 0 — the beneficiary receives ETH via the hook's swap instead.
-        if (payerTokens > 0) {
-            uint256 payerEthBefore = PAYER.balance;
-
-            vm.prank(PAYER);
-            jbMultiTerminal()
-                .cashOutTokensOf({
-                    holder: PAYER,
-                    projectId: splitRevnetId,
-                    cashOutCount: payerTokens,
-                    tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                    minTokensReclaimed: 0,
-                    beneficiary: payable(PAYER),
-                    metadata: ""
-                });
-
-            assertGt(PAYER.balance, payerEthBefore, "payer should receive ETH after tier split cashout");
-        }
-    }
-
-    /// @notice Cash out before delay expires should revert.
-    function test_fork_cashOut_delayEnforcement() public {
-        // Deploy a revnet whose first stage started in the past → triggers cash-out delay.
-        (REVConfig memory cfg, JBTerminalConfig[] memory tc, REVSuckerDeploymentConfig memory sdc) =
-            _buildMinimalConfig(5000);
-        cfg.stageConfigurations[0].startsAtOrAfter = uint40(block.timestamp - 1);
-        (uint256 delayRevnet,) = REV_DEPLOYER.deployFor({
-            revnetId: 0,
-            configuration: cfg,
-            terminalConfigurations: tc,
-            suckerDeploymentConfiguration: sdc,
-            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
-            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
-        });
-        _setupPool(delayRevnet, 10_000 ether);
-        _payRevnet(delayRevnet, PAYER, 1 ether);
-
-        uint256 payerTokens = jbTokens().totalBalanceOf(PAYER, delayRevnet);
-
-        // Try to cash out immediately (before delay expires) -> should revert.
-        vm.prank(PAYER);
-        vm.expectRevert();
-        jbMultiTerminal()
-            .cashOutTokensOf({
-                holder: PAYER,
-                projectId: delayRevnet,
-                cashOutCount: payerTokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(PAYER),
-                metadata: ""
-            });
-
-        // Warp past delay.
-        vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
-
-        // Now it should succeed. When the buyback hook routes via swap, reclaimAmount is 0 but
-        // the beneficiary receives ETH through the hook.
-        uint256 payerEthBefore = PAYER.balance;
-
-        vm.prank(PAYER);
-        jbMultiTerminal()
-            .cashOutTokensOf({
-                holder: PAYER,
-                projectId: delayRevnet,
-                cashOutCount: payerTokens,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(PAYER),
-                metadata: ""
-            });
-
-        assertGt(PAYER.balance, payerEthBefore, "should succeed after delay expires");
-    }
-}

package/test/fork/TestIssuanceDecayFork.t.sol

@@ -1,158 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-// forge-lint: disable-next-line(unaliased-plain-import)
-import "./ForkTestBase.sol";
-import {REVEmpty721Config} from "../helpers/REVEmpty721Config.sol";
-
-/// @notice Fork tests for revnet issuance decay (weight cut) mechanics.
-///
-/// Verifies that `issuanceCutFrequency` maps to `JBRulesetConfig.duration` and
-/// `issuanceCutPercent` maps to `weightCutPercent`, producing geometric token decay.
-///
-/// Run with: FOUNDRY_PROFILE=fork forge test --match-contract TestIssuanceDecayFork -vvv
-contract TestIssuanceDecayFork is ForkTestBase {
-    /// @notice Deploy a revnet with custom issuance cut parameters.
-    /// @param issuanceCutFrequency The duration in seconds between decay steps (maps to ruleset duration).
-    /// @param issuanceCutPercent The percentage to cut issuance each cycle (out of 1_000_000_000).
-    /// @param cashOutTaxRate The cash out tax rate.
-    /// @return revnetId The deployed revnet's project ID.
-    function _deployRevnetWithDecay(
-        uint32 issuanceCutFrequency,
-        uint32 issuanceCutPercent,
-        uint16 cashOutTaxRate
-    )
-        internal
-        returns (uint256 revnetId)
-    {
-        JBAccountingContext[] memory acc = new JBAccountingContext[](1);
-        acc[0] = JBAccountingContext({
-            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
-        });
-
-        JBTerminalConfig[] memory tc = new JBTerminalConfig[](1);
-        tc[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: acc});
-
-        REVStageConfig[] memory stages = new REVStageConfig[](1);
-        JBSplit[] memory splits = new JBSplit[](1);
-        splits[0].beneficiary = payable(multisig());
-        splits[0].percent = 10_000;
-        stages[0] = REVStageConfig({
-            startsAtOrAfter: uint40(block.timestamp),
-            autoIssuances: new REVAutoIssuance[](0),
-            splitPercent: 0,
-            splits: splits,
-            initialIssuance: INITIAL_ISSUANCE,
-            issuanceCutFrequency: issuanceCutFrequency,
-            issuanceCutPercent: issuanceCutPercent,
-            cashOutTaxRate: cashOutTaxRate,
-            extraMetadata: 0
-        });
-
-        REVConfig memory cfg = REVConfig({
-            description: REVDescription("Decay Test", "DECAY", "ipfs://decay", "DECAY_SALT"),
-            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
-            splitOperator: multisig(),
-            stageConfigurations: stages
-        });
-
-        REVSuckerDeploymentConfig memory sdc = REVSuckerDeploymentConfig({
-            deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256(abi.encodePacked("DECAY_TEST"))
-        });
-
-        (revnetId,) = REV_DEPLOYER.deployFor({
-            revnetId: 0,
-            configuration: cfg,
-            terminalConfigurations: tc,
-            suckerDeploymentConfiguration: sdc,
-            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
-            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
-        });
-    }
-
-    function setUp() public override {
-        super.setUp();
-        _deployFeeProject(5000);
-    }
-
-    /// @notice After one cycle with 10% issuance cut, paying 1 ETH yields ~90% of the day-0 tokens.
-    function testFork_IssuanceDecaysSingleCycle() public {
-        // 10% cut per cycle, 1-day cycles.
-        uint256 revnetId = _deployRevnetWithDecay({
-            issuanceCutFrequency: 86_400, // 1 day
-            issuanceCutPercent: 100_000_000, // 10% of 1e9
-            cashOutTaxRate: 5000
-        });
-
-        // Set up pool so buyback hook doesn't interfere (mint path wins at 1:1).
-        _setupPool(revnetId, 10_000 ether);
-
-        // Day 0: pay 1 ETH.
-        uint256 t0 = _payRevnet(revnetId, PAYER, 1 ether);
-        assertGt(t0, 0, "day 0 tokens should be > 0");
-
-        // Warp 1 day (one full cycle).
-        vm.warp(block.timestamp + 86_400);
-
-        // Day 1: pay 1 ETH again.
-        address payer2 = makeAddr("payer2");
-        vm.deal(payer2, 10 ether);
-        uint256 t1 = _payRevnet(revnetId, payer2, 1 ether);
-
-        // T1 should be approximately T0 * 0.9 (within 1% tolerance for rounding).
-        uint256 expected = (t0 * 9) / 10;
-        uint256 tolerance = expected / 100; // 1%
-        assertGt(t1, expected - tolerance, "T1 should be >= T0*0.9 - 1%");
-        assertLt(t1, expected + tolerance, "T1 should be <= T0*0.9 + 1%");
-    }
-
-    /// @notice After two cycles with 10% issuance cut, paying 1 ETH yields ~81% of the day-0 tokens.
-    function testFork_IssuanceDecaysMultipleCycles() public {
-        // 10% cut per cycle, 1-day cycles.
-        uint256 revnetId = _deployRevnetWithDecay({
-            issuanceCutFrequency: 86_400, issuanceCutPercent: 100_000_000, cashOutTaxRate: 5000
-        });
-
-        _setupPool(revnetId, 10_000 ether);
-
-        // Day 0: pay 1 ETH to establish baseline.
-        uint256 t0 = _payRevnet(revnetId, PAYER, 1 ether);
-
-        // Warp 2 days (two full cycles).
-        vm.warp(block.timestamp + 86_400 * 2);
-
-        // Day 2: pay 1 ETH.
-        address payer2 = makeAddr("payer2");
-        vm.deal(payer2, 10 ether);
-        uint256 t2 = _payRevnet(revnetId, payer2, 1 ether);
-
-        // T2 should be approximately T0 * 0.9 * 0.9 = T0 * 0.81 (within 1% tolerance).
-        uint256 expected = (t0 * 81) / 100;
-        uint256 tolerance = expected / 100; // 1%
-        assertGt(t2, expected - tolerance, "T2 should be >= T0*0.81 - 1%");
-        assertLt(t2, expected + tolerance, "T2 should be <= T0*0.81 + 1%");
-    }
-
-    /// @notice With 0% issuance cut, weight never changes and T0 == T1.
-    function testFork_IssuanceDecayZeroPercent() public {
-        // 0% cut per cycle, 1-day cycles.
-        uint256 revnetId =
-            _deployRevnetWithDecay({issuanceCutFrequency: 86_400, issuanceCutPercent: 0, cashOutTaxRate: 5000});
-
-        _setupPool(revnetId, 10_000 ether);
-
-        // Day 0: pay 1 ETH.
-        uint256 t0 = _payRevnet(revnetId, PAYER, 1 ether);
-
-        // Warp 1 day.
-        vm.warp(block.timestamp + 86_400);
-
-        // Day 1: pay 1 ETH.
-        address payer2 = makeAddr("payer2");
-        vm.deal(payer2, 10 ether);
-        uint256 t1 = _payRevnet(revnetId, payer2, 1 ether);
-
-        // With 0% cut, tokens should be identical.
-        assertEq(t1, t0, "with 0% cut, tokens should be the same across cycles");
-    }
-}