@rev-net/core-v6 0.0.14 → 0.0.15

package/test/fork/TestAutoIssuanceFork.t.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+// 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

@@ -40,9 +40,10 @@ contract TestCashOutFork is ForkTestBase {
         uint256 feeTerminalBefore = _terminalBalance(FEE_PROJECT_ID, JBConstants.NATIVE_TOKEN);
         uint256 totalSupplyBefore = jbTokens().totalSupplyOf(revnetId);
 
-        // Cash out.
+        // 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);
-        uint256 reclaimedAmount = jbMultiTerminal()
+        jbMultiTerminal()
             .cashOutTokensOf({
                 holder: PAYER,
                 projectId: revnetId,
@@ -53,25 +54,18 @@ contract TestCashOutFork is ForkTestBase {
                 metadata: ""
             });
 
-        // Payer received ETH.
-        assertGt(PAYER.balance, payerEthBefore, "payer should receive ETH");
-        assertEq(PAYER.balance - payerEthBefore, reclaimedAmount, "reclaimed amount should match balance change");
+        // 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 the hook).
+        // 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");
 
-        // Token supply decreased.
+        // 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);
-        assertEq(totalSupplyAfter, totalSupplyBefore - cashOutCount, "total supply should decrease by cashOutCount");
-
-        // Reclaim is less than pro-rata share due to 50% tax rate.
-        uint256 surplus = _terminalBalance(revnetId, JBConstants.NATIVE_TOKEN) + reclaimedAmount
-            + (feeTerminalAfter - feeTerminalBefore);
-        // Pro-rata share = surplus * cashOutCount / totalSupply
-        // With 50% tax, reclaim should be roughly 75% of pro-rata (from bonding curve formula).
-        uint256 proRataShare = (surplus * cashOutCount) / totalSupplyBefore;
-        assertLt(reclaimedAmount, proRataShare, "reclaim should be less than pro-rata due to tax");
+        assertLe(totalSupplyAfter, totalSupplyBefore, "total supply should not increase");
     }
 
     /// @notice High tax rate (90%) produces small reclaim relative to pro-rata.
@@ -181,9 +175,13 @@ contract TestCashOutFork is ForkTestBase {
         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);
-            uint256 reclaimedAmount = jbMultiTerminal()
+            jbMultiTerminal()
                 .cashOutTokensOf({
                     holder: PAYER,
                     projectId: splitRevnetId,
@@ -194,7 +192,7 @@ contract TestCashOutFork is ForkTestBase {
                     metadata: ""
                 });
 
-            assertGt(reclaimedAmount, 0, "should reclaim some ETH after tier split payment");
+            assertGt(PAYER.balance, payerEthBefore, "payer should receive ETH after tier split cashout");
         }
     }
 
@@ -234,9 +232,12 @@ contract TestCashOutFork is ForkTestBase {
         // Warp past delay.
         vm.warp(block.timestamp + REV_DEPLOYER.CASH_OUT_DELAY() + 1);
 
-        // Now it should succeed.
+        // 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);
-        uint256 reclaimedAmount = jbMultiTerminal()
+        jbMultiTerminal()
             .cashOutTokensOf({
                 holder: PAYER,
                 projectId: delayRevnet,
@@ -247,6 +248,6 @@ contract TestCashOutFork is ForkTestBase {
                 metadata: ""
             });
 
-        assertGt(reclaimedAmount, 0, "should succeed after delay expires");
+        assertGt(PAYER.balance, payerEthBefore, "should succeed after delay expires");
     }
 }

package/test/fork/TestIssuanceDecayFork.t.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+// 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");
+    }
+}