@bananapus/omnichain-deployers-v6 0.0.29 → 0.0.31

package/RISKS.md

@@ -86,6 +86,11 @@ Extra data hooks provided by the project owner in `_setup721` configuration can
 **Missing hook721 alias check enables double invocation.** *(Minor)*
 If the project owner configures the 721 hook as both the primary hook and as an extra data hook, it could be invoked twice. Accepted because this is self-inflicted misconfiguration — the deployer correctly processes each hook independently.
 
+### Hook Selection
+
+**ApprovalExpected rulesets excluded from hook carry-forward.**
+When no new tiers are provided, the deployer carries forward the 721 hook from the most recent approved ruleset. Rulesets with `ApprovalExpected` status are intentionally excluded even though they may become active. Hook selection is irreversible — if the pending ruleset is later rejected by the approval hook, we'd have locked in a hook from a ruleset that never became active. The deployer falls back to the current (already-approved) ruleset in this case.
+
 ### Cross-Chain Deployment
 
 **`_msgSender()` in deployment salt breaks cross-chain determinism.** *(Minor)*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/omnichain-deployers-v6",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
     "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-omnichain-deployers-v6'"
   },
   "dependencies": {
-    "@bananapus/721-hook-v6": "^0.0.38",
+    "@bananapus/721-hook-v6": "^0.0.41",
     "@bananapus/buyback-hook-v6": "^0.0.30",
     "@bananapus/core-v6": "^0.0.36",
     "@bananapus/ownable-v6": "^0.0.20",
@@ -27,7 +27,7 @@
     "@uniswap/v4-core": "^1.0.2"
   },
   "devDependencies": {
-    "@bananapus/address-registry-v6": "^0.0.17",
+    "@bananapus/address-registry-v6": "^0.0.20",
     "@sphinx-labs/plugins": "^0.33.2"
   }
 }

package/src/JBOmnichainDeployer.sol

@@ -30,6 +30,7 @@ import {JBDeployerHookConfig} from "./structs/JBDeployerHookConfig.sol";
 import {JBOmnichain721Config} from "./structs/JBOmnichain721Config.sol";
 import {JBSuckerDeploymentConfig} from "./structs/JBSuckerDeploymentConfig.sol";
 import {JBTiered721HookConfig} from "./structs/JBTiered721HookConfig.sol";
+import {mulDiv} from "@prb/math/src/Common.sol";
 
 /// @notice Deploys, manages, and operates Juicebox projects with suckers.
 // Project NFTs sent to this contract are not recoverable. The deployer does not
@@ -434,10 +435,10 @@ contract JBOmnichainDeployer is
         // If a 721 hook is set and opted into cash out handling, let it adjust the cash out parameters.
         if (address(tiered721Config.hook) != address(0) && tiered721Config.useDataHookForCashOut) {
             // Forward to the 721 hook. It may change the tax rate, count, and return hook specs.
-            // We discard the inner hook's effectiveSurplusValue — this contract computes the cross-chain values.
-            // We also discard its totalSupply since this contract computes the cross-chain supply.
+            // Capture the 721 hook's totalSupply and effectiveSurplusValue — NFT cash-outs should use
+            // local-only denominators so holders reclaim against local surplus, not omnichain surplus.
             // slither-disable-next-line unused-return
-            (cashOutTaxRate, cashOutCount,,, tiered721HookSpecifications) =
+            (cashOutTaxRate, cashOutCount, totalSupply, effectiveSurplusValue, tiered721HookSpecifications) =
                 IJBRulesetDataHook(address(tiered721Config.hook)).beforeCashOutRecordedWith(context);
         }
 
@@ -456,12 +457,20 @@ contract JBOmnichainDeployer is
             hookContext.totalSupply = totalSupply;
             hookContext.surplus.value = effectiveSurplusValue;
 
-            // Forward to the extra hook. It may further change the tax rate, count, and return hook specs.
-            // We discard the inner hook's effectiveSurplusValue — this contract computes the cross-chain values.
-            // We also discard its totalSupply since this contract computes the cross-chain supply.
-            // slither-disable-next-line unused-return
-            (cashOutTaxRate, cashOutCount,,, extraHookSpecifications) =
-                extraHook.dataHook.beforeCashOutRecordedWith(hookContext);
+            // Forward to the extra hook. It may further change the tax rate and return hook specs.
+            // We always discard totalSupply and effectiveSurplusValue — this contract computes
+            // cross-chain values for both. When the 721 hook is active, we also discard cashOutCount
+            // because the 721 hook redefines both cashOutCount and totalSupply as NFT cash-out weights
+            // (sum of tier prices), not fungible token counts. Letting the extra hook override
+            // cashOutCount would corrupt NFT pricing in the bonding curve.
+            if (address(tiered721Config.hook) != address(0) && tiered721Config.useDataHookForCashOut) {
+                // slither-disable-next-line unused-return
+                (cashOutTaxRate,,,, extraHookSpecifications) = extraHook.dataHook.beforeCashOutRecordedWith(hookContext);
+            } else {
+                // slither-disable-next-line unused-return
+                (cashOutTaxRate, cashOutCount,,, extraHookSpecifications) =
+                    extraHook.dataHook.beforeCashOutRecordedWith(hookContext);
+            }
         }
 
         // If neither hook returned any specifications, return the adjusted values with no hook specs.
@@ -510,6 +519,8 @@ contract JBOmnichainDeployer is
         bool hasTiered721Spec;
         // The weight returned by the 721 hook (already scaled for splits).
         uint256 tiered721Weight;
+        // The weight attributable to tier splits when issueTokensForSplits is true.
+        uint256 splitCreditWeight;
         // Whether a 721 hook is configured for this project's ruleset.
         bool has721Hook;
         if (address(tiered721Config.hook) != address(0)) {
@@ -526,6 +537,14 @@ contract JBOmnichainDeployer is
                 hasTiered721Spec = true;
                 tiered721HookSpec = tiered721HookSpecs[0];
                 totalSplitAmount = tiered721HookSpec.amount;
+
+                // Decode splitCreditWeight from the 721 hook's metadata (4th field).
+                // When issueTokensForSplits is true and splits exist, this holds the weight portion
+                // attributable to tier splits — used to prevent split credit erasure if the extra
+                // hook (e.g. buyback) returns weight=0.
+                if (tiered721HookSpec.metadata.length >= 128) {
+                    (,,, splitCreditWeight) = abi.decode(tiered721HookSpec.metadata, (address, address, bytes, uint256));
+                }
             }
         }
 
@@ -541,11 +560,27 @@ contract JBOmnichainDeployer is
             if (address(extraHook.dataHook) != address(0) && extraHook.useDataHookForPay) {
                 JBBeforePayRecordedContext memory hookContext = context;
                 hookContext.amount.value = projectAmount;
-                // Pass the 721 hook's weight (which accounts for split deductions) so the data hook
-                // makes its decisions (e.g. mint-vs-swap) based on the correct post-split weight.
-                if (has721Hook) hookContext.weight = tiered721Weight;
+                // Pass the original context.weight — NOT the 721 hook's split-adjusted weight.
+                // The extra hook (e.g. buyback) applies its own weight logic; using the 721 hook's
+                // already-split-adjusted weight would double-discount the split ratio.
                 (weight, dataHookSpecs) = extraHook.dataHook.beforePayRecordedWith(hookContext);
                 customHookCalled = true;
+
+                // The custom hook (e.g. buyback) returned a weight based on the original context.weight.
+                // If the 721 hook scaled weight down for tier splits, apply the same ratio so the terminal
+                // doesn't over-mint tokens relative to the funds actually entering the project.
+                // When issueTokensForSplits is true, tiered721Weight == context.weight and the ratio is 1x.
+                if (has721Hook && context.weight > 0 && tiered721Weight != context.weight) {
+                    weight = mulDiv(weight, tiered721Weight, context.weight);
+                }
+
+                // When the extra hook returns weight=0 (e.g. buyback found no profitable swap) but tier
+                // splits exist with issueTokensForSplits=true, the split credit must still mint fungible tokens.
+                // The split credit weight is independent of buyback routing — it represents the token issuance
+                // for funds forwarded to tier split beneficiaries.
+                if (weight == 0 && splitCreditWeight > 0) {
+                    weight = splitCreditWeight;
+                }
             }
         }
 
@@ -813,6 +848,9 @@ contract JBOmnichainDeployer is
             {
                 // First try the latest queued ruleset — if it's been explicitly approved
                 // (or has no approval hook), its hook config should take precedence.
+                // Conservative: only use Approved or Empty status. ApprovalExpected is intentionally
+                // excluded because hook selection is irreversible — if the pending ruleset is later rejected
+                // by the approval hook, we'd have locked in a hook from a ruleset that never became active.
                 (JBRuleset memory latestQueued, JBApprovalStatus approvalStatus) =
                     controller.RULESETS().latestQueuedOf(projectId);
                 if (

package/test/JBOmnichainDeployerGuard.t.sol

@@ -263,11 +263,11 @@ contract JBOmnichainDeployerGuardTest is TestBaseWorkflow {
             .setPermissionsFor(
                 owner,
                 JBPermissionsData({
-                    operator: address(deployer),
-                    // forge-lint: disable-next-line(unsafe-typecast)
-                    projectId: uint64(projectId),
-                    permissionIds: permissionIds
-                })
+                operator: address(deployer),
+                // forge-lint: disable-next-line(unsafe-typecast)
+                projectId: uint64(projectId),
+                permissionIds: permissionIds
+            })
             );
     }
 
@@ -303,9 +303,10 @@ contract JBOmnichainDeployerGuardTest is TestBaseWorkflow {
 
         JBRulesetConfig[] memory rulesets = _makeRulesetConfigs(1);
 
-        // Should succeed without reverting.
         JBOmnichain721Config memory empty721;
-        deployer.queueRulesetsOf(projectId, empty721, rulesets, "queue", IJBController(address(jbController())));
+        (uint256 rulesetId,) =
+            deployer.queueRulesetsOf(projectId, empty721, rulesets, "queue", IJBController(address(jbController())));
+        assertGt(rulesetId, 0, "Queued ruleset ID must be non-zero");
     }
 
     /// @notice Queue rulesets reverts when called in the same block as launch
@@ -363,6 +364,41 @@ contract JBOmnichainDeployerGuardTest is TestBaseWorkflow {
 
         // Now should succeed.
         JBOmnichain721Config memory empty721b;
-        deployer.queueRulesetsOf(projectId, empty721b, rulesets, "ok-now", IJBController(address(jbController())));
+        (uint256 rulesetId,) =
+            deployer.queueRulesetsOf(projectId, empty721b, rulesets, "ok-now", IJBController(address(jbController())));
+        assertGt(rulesetId, 0, "Queued ruleset ID must be non-zero after warping past conflict");
+    }
+
+    /// @notice When no new tiers are provided and no latestQueued exists (single launch ruleset that
+    ///         became the current ruleset), the hook is carried forward from the current ruleset (lines 862-864).
+    function test_queueRulesetsOf_carriesForwardFromCurrent_whenNoLatestQueued() public {
+        // Launch with 1 ruleset — this deploys a 721 hook stored for the launch ruleset.
+        uint256 projectId = _launchProject(1);
+        uint256 launchRulesetId = block.timestamp;
+        _grantDeployerQueuePermission(projectId);
+
+        // Verify the 721 hook was stored for the launch ruleset.
+        (IJB721TiersHook launchHook,) = deployer.tiered721HookOf(projectId, launchRulesetId);
+        assertEq(address(launchHook), mockHookAddr, "Launch ruleset should have 721 hook stored");
+
+        // Warp forward so the launched ruleset is the current active one and the guard passes.
+        vm.warp(block.timestamp + 1 days);
+
+        // Queue a new ruleset with NO new tiers → triggers carry-forward logic.
+        JBRulesetConfig[] memory rulesets = _makeRulesetConfigs(1);
+        JBOmnichain721Config memory empty721;
+        (uint256 queuedRulesetId,) = deployer.queueRulesetsOf(
+            projectId, empty721, rulesets, "carry-forward", IJBController(address(jbController()))
+        );
+
+        assertGt(queuedRulesetId, 0, "Queued ruleset ID must be non-zero");
+
+        // Verify the hook was carried forward to the new queued ruleset.
+        (IJB721TiersHook carriedHook,) = deployer.tiered721HookOf(projectId, queuedRulesetId);
+        assertEq(
+            address(carriedHook),
+            address(launchHook),
+            "Queued ruleset should carry forward the 721 hook from the current ruleset"
+        );
     }
 }

package/test/OmnichainDeployerEdgeCases.t.sol

@@ -322,9 +322,10 @@ contract OmnichainDeployerEdgeCases is Test {
         ctx.amount.value = 1 ether;
         ctx.weight = 1000;
 
-        // The custom hook's weight is used directly (no mulDiv scaling).
+        // The custom hook's weight is scaled by the 721 split ratio (500/1000 = 50%).
+        // mulDiv(type(uint256).max, 500, 1000) = type(uint256).max / 2.
         (uint256 weight,) = deployer.beforePayRecordedWith(ctx);
-        assertEq(weight, type(uint256).max, "custom hook's large weight should pass through directly");
+        assertEq(weight, type(uint256).max / 2, "custom hook's weight scaled by 721 split ratio");
     }
 
     // =========================================================================
@@ -471,10 +472,11 @@ contract OmnichainDeployerEdgeCases is Test {
         ) = deployer.beforeCashOutRecordedWith(ctx);
 
         assertEq(cashOutTaxRate, 2000, "Custom hook should receive and override 721-adjusted tax rate");
-        assertEq(cashOutCount, 500, "Custom hook should receive and override 721-adjusted cashOutCount");
-        // The deployer discards the inner hook's totalSupply and computes cross-chain supply instead.
-        // With no suckers, this equals context.totalSupply.
-        assertEq(totalSupply, ctx.totalSupply, "Should return cross-chain totalSupply (context value with no suckers)");
+        // After the security fix, the 721 hook's cashOutCount is preserved — the extra hook cannot override it.
+        assertEq(cashOutCount, 700, "721 hook cashOutCount must be preserved (extra hook cannot override NFT pricing)");
+        // The deployer captures the 721 hook's totalSupply (9000) — NFT cash-outs use local-only
+        // denominators. The extra hook's totalSupply is discarded, preserving the 721 hook's value.
+        assertEq(totalSupply, 9000, "Should return 721 hook totalSupply (local denominator)");
         assertEq(hookSpecifications.length, 2, "721 and custom cash out specs should both be returned");
         assertEq(address(hookSpecifications[0].hook), mock721, "721 hook spec should come first");
         assertEq(hookSpecifications[0].amount, 11, "721 hook spec amount should be preserved");

package/test/OmnichainDeployerReentrancy.t.sol

@@ -240,14 +240,14 @@ contract OmnichainDeployerReentrancy is OmnichainForkTestBase {
         vm.prank(address(hook));
         try jbMultiTerminal()
             .cashOutTokensOf({
-                holder: address(hook),
-                projectId: projectId,
-                cashOutCount: hookTokens / 2,
-                tokenToReclaim: JBConstants.NATIVE_TOKEN,
-                minTokensReclaimed: 0,
-                beneficiary: payable(address(hook)),
-                metadata: ""
-            }) {
+            holder: address(hook),
+            projectId: projectId,
+            cashOutCount: hookTokens / 2,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(address(hook)),
+            metadata: ""
+        }) {
             // If it succeeds, check conservation.
             uint256 surplusAfter = _terminalBalance(projectId, JBConstants.NATIVE_TOKEN);
             uint256 remainingTokens = jbTokens().totalBalanceOf(address(hook), projectId);

package/test/Tiered721HookComposition.t.sol

@@ -302,7 +302,8 @@ contract Tiered721HookComposition is Test {
         );
         JBBeforePayRecordedContext memory context = _makePayContext(projectId, block.timestamp);
         (uint256 weight, JBPayHookSpecification[] memory specs) = deployer.beforePayRecordedWith(context);
-        assertEq(weight, 555, "weight = buyback hook's returned weight (721 weight passed as context)");
+        // Buyback returned weight=555, 721 split ratio=750/1000: mulDiv(555, 750, 1000) = 416.
+        assertEq(weight, 416, "weight = buyback weight scaled by 721 split ratio");
         assertEq(specs.length, 2, "721 spec + buyback spec");
         assertEq(address(specs[0].hook), hookAddr, "first = 721 hook");
         assertEq(specs[0].amount, splitAmount, "721 split amount preserved");
@@ -622,7 +623,8 @@ contract Tiered721HookComposition is Test {
         );
         JBBeforePayRecordedContext memory context = _makePayContext(projectId, block.timestamp);
         (uint256 weight,) = deployer.beforePayRecordedWith(context);
-        assertEq(weight, 2000, "weight = custom hook's returned weight (721 weight passed as context)");
+        // Custom hook returned 2000, 721 split ratio=600/1000: mulDiv(2000, 600, 1000) = 1200.
+        assertEq(weight, 1200, "weight = custom hook weight scaled by 721 split ratio");
     }
 
     function test_beforePay_fullSplit_weightZero() public {
@@ -690,7 +692,8 @@ contract Tiered721HookComposition is Test {
         );
         JBBeforePayRecordedContext memory context = _makePayContext(projectId, block.timestamp);
         (uint256 weight, JBPayHookSpecification[] memory specs) = deployer.beforePayRecordedWith(context);
-        assertEq(weight, 2000, "weight = buyback hook's returned weight (721 weight passed as context)");
+        // Buyback returned 2000, 721 split ratio=600/1000: mulDiv(2000, 600, 1000) = 1200.
+        assertEq(weight, 1200, "weight = buyback weight scaled by 721 split ratio");
         assertEq(specs.length, 2, "721 spec + buyback spec");
         assertEq(address(specs[0].hook), hookAddr, "first = 721 hook");
         assertEq(specs[0].amount, 0.4 ether, "721 split amount");
@@ -709,8 +712,9 @@ contract Tiered721HookComposition is Test {
             abi.encodeWithSelector(IJBRulesetDataHook.beforePayRecordedWith.selector),
             abi.encode(uint256(800), hookSpecs)
         );
-        // Buyback mint path returns context.weight (which is now the 721 hook's weight = 800).
-        uint256 mintPathWeight = 800;
+        // Buyback mint path returns context.weight unchanged. The deployer passes the original
+        // context.weight (1000) to the buyback hook, so the mint path returns 1000.
+        uint256 mintPathWeight = 1000;
         JBPayHookSpecification[] memory emptyBuybackSpecs = new JBPayHookSpecification[](0);
         vm.mockCall(
             buybackHookAddr,
@@ -719,7 +723,8 @@ contract Tiered721HookComposition is Test {
         );
         JBBeforePayRecordedContext memory context = _makePayContext(projectId, block.timestamp);
         (uint256 weight, JBPayHookSpecification[] memory specs) = deployer.beforePayRecordedWith(context);
-        assertEq(weight, 800, "weight = 721 hook's weight (buyback mint path returns context.weight)");
+        // mulDiv(1000, 800, 1000) = 800: the 721 split ratio is correctly applied.
+        assertEq(weight, 800, "weight = buyback weight scaled by 721 split ratio (matches 721 hook weight)");
         assertEq(specs.length, 1, "only 721 spec (buyback empty)");
         assertEq(address(specs[0].hook), hookAddr, "spec = 721 hook");
         assertEq(specs[0].amount, 0.2 ether, "721 split amount");

package/test/audit/AuditFixesC2H6M14.t.sol

@@ -8,14 +8,11 @@ import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
-import {IJBRulesets} from "@bananapus/core-v6/src/interfaces/IJBRulesets.sol";
 import {JBBeforeCashOutRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforeCashOutRecordedContext.sol";
-import {JBBeforePayRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforePayRecordedContext.sol";
 import {JBCashOutHookSpecification} from "@bananapus/core-v6/src/structs/JBCashOutHookSpecification.sol";
 import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
 import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
 import {JBPayHookSpecification} from "@bananapus/core-v6/src/structs/JBPayHookSpecification.sol";
-import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
 import {JBRulesetConfig} from "@bananapus/core-v6/src/structs/JBRulesetConfig.sol";
 import {JBRulesetMetadata} from "@bananapus/core-v6/src/structs/JBRulesetMetadata.sol";
 import {JBSplitGroup} from "@bananapus/core-v6/src/structs/JBSplitGroup.sol";
@@ -379,19 +376,13 @@ contract AuditFixesC2H6M14 is Test {
         JBRulesetConfig[] memory configs = new JBRulesetConfig[](1);
         configs[0] = _rulesetConfig();
 
-        // 721 hook mock returns empty cash-out specs by default.
-        JBCashOutHookSpecification[] memory emptySpecs = new JBCashOutHookSpecification[](0);
-        vm.mockCall(
-            hookAddr,
-            abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(uint256(5000), uint256(1000), uint256(10_000), uint256(0), emptySpecs)
-        );
-
+        // Disable the 721 hook for cash-out so the deployer computes cross-chain surplus itself.
+        // These tests verify C-2 (surplus aggregation), not NFT cashout behavior.
         deployer.launchProjectFor({
             owner: projectOwner,
             projectUri: "test",
             deploy721Config: JBOmnichain721Config({
-                deployTiersHookConfig: _empty721HookConfig(), useDataHookForCashOut: true, salt: bytes32(0)
+                deployTiersHookConfig: _empty721HookConfig(), useDataHookForCashOut: false, salt: bytes32(0)
             }),
             rulesetConfigurations: configs,
             terminalConfigurations: new JBTerminalConfig[](0),
@@ -420,19 +411,13 @@ contract AuditFixesC2H6M14 is Test {
         configs[0].metadata.dataHook = extraHookAddr;
         configs[0].metadata.useDataHookForCashOut = true;
 
-        // 721 hook mock returns empty cash-out specs.
-        JBCashOutHookSpecification[] memory emptySpecs = new JBCashOutHookSpecification[](0);
-        vm.mockCall(
-            hookAddr,
-            abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
-            abi.encode(uint256(5000), uint256(1000), uint256(10_000), uint256(0), emptySpecs)
-        );
-
+        // Disable the 721 hook for cash-out so the deployer computes cross-chain surplus itself.
+        // These tests verify H-6 (extra hook forwarding), not NFT cashout behavior.
         deployer.launchProjectFor({
             owner: projectOwner,
             projectUri: "test",
             deploy721Config: JBOmnichain721Config({
-                deployTiersHookConfig: _empty721HookConfig(), useDataHookForCashOut: true, salt: bytes32(0)
+                deployTiersHookConfig: _empty721HookConfig(), useDataHookForCashOut: false, salt: bytes32(0)
             }),
             rulesetConfigurations: configs,
             terminalConfigurations: new JBTerminalConfig[](0),

package/test/audit/CarryForwardRejectedHook.t.sol

@@ -318,11 +318,11 @@ contract CarryForwardRejectedHookTest is TestBaseWorkflow {
             .setPermissionsFor(
                 owner,
                 JBPermissionsData({
-                    operator: address(deployer),
-                    // forge-lint: disable-next-line(unsafe-typecast)
-                    projectId: uint64(projectId),
-                    permissionIds: permissionIds
-                })
+                operator: address(deployer),
+                // forge-lint: disable-next-line(unsafe-typecast)
+                projectId: uint64(projectId),
+                permissionIds: permissionIds
+            })
             );
     }
 }

package/test/audit/CashOutCountPropagation.t.sol

@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {Test} from "forge-std/Test.sol";
+
+import {IJBDirectory} from "@bananapus/core-v6/src/interfaces/IJBDirectory.sol";
+import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
+import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBBeforeCashOutRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforeCashOutRecordedContext.sol";
+import {JBBeforePayRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforePayRecordedContext.sol";
+import {JBCashOutHookSpecification} from "@bananapus/core-v6/src/structs/JBCashOutHookSpecification.sol";
+import {JBPayHookSpecification} from "@bananapus/core-v6/src/structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
+import {JBTokenAmount} from "@bananapus/core-v6/src/structs/JBTokenAmount.sol";
+import {IJB721TiersHookDeployer} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHookDeployer.sol";
+import {IJBSuckerRegistry} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerRegistry.sol";
+
+import {JBOmnichainDeployer} from "../../src/JBOmnichainDeployer.sol";
+
+/// @notice Regression test: cashOutCount from the 721 hook must be propagated
+/// to the extra data hook's context. Before fix, the extra hook receives the stale
+/// context.cashOutCount instead of the 721-adjusted value.
+contract CashOutCountPropagationTest is Test {
+    uint256 internal constant PROJECT_ID = 1;
+    uint256 internal constant RULESET_ID = 123;
+
+    // The 721 hook will change cashOutCount from ORIGINAL to ADJUSTED.
+    uint256 internal constant ORIGINAL_CASH_OUT_COUNT = 50 ether;
+    uint256 internal constant ADJUSTED_CASH_OUT_COUNT = 7 ether;
+    uint256 internal constant NFT_TOTAL_SUPPLY = 21 ether;
+    uint256 internal constant LOCAL_SURPLUS = 10 ether;
+
+    address internal holder = makeAddr("holder");
+    address internal permissions = makeAddr("permissions");
+    address internal projects = makeAddr("projects");
+    address internal hookDeployer = makeAddr("hookDeployer");
+    address internal suckerRegistry = makeAddr("suckerRegistry");
+    address internal directory = makeAddr("directory");
+
+    JBOmnichainDeployer internal deployer;
+    Mock721Hook internal nftHook;
+    address internal extraHookAddr;
+
+    function setUp() public {
+        vm.mockCall(permissions, abi.encodeWithSelector(IJBPermissions.setPermissionsFor.selector), abi.encode());
+
+        deployer = new JBOmnichainDeployer(
+            IJBSuckerRegistry(suckerRegistry),
+            IJB721TiersHookDeployer(hookDeployer),
+            IJBPermissions(permissions),
+            IJBProjects(projects),
+            IJBDirectory(directory),
+            address(0)
+        );
+
+        nftHook = new Mock721Hook(ADJUSTED_CASH_OUT_COUNT, NFT_TOTAL_SUPPLY);
+        extraHookAddr = makeAddr("extraHook");
+
+        _storeTiered721Hook(address(nftHook), true);
+        _storeExtraDataHook(extraHookAddr, true);
+        _mockSuckerRegistry();
+        _mockExtraHook();
+    }
+
+    /// @notice The extra data hook should receive the 721-adjusted cashOutCount,
+    /// not the original context.cashOutCount.
+    function test_extraHookReceivesAdjustedCashOutCount() public {
+        // Build the expected context that the extra hook should receive.
+        // The deployer copies the original context and patches cashOutTaxRate, totalSupply, surplus.value.
+        // With the fix, it should also patch cashOutCount.
+        // NOTE: We build expectedContext separately (not via pointer alias) to avoid Solidity memory aliasing.
+        JBBeforeCashOutRecordedContext memory expectedContext = JBBeforeCashOutRecordedContext({
+            terminal: address(0x1234),
+            holder: holder,
+            projectId: PROJECT_ID,
+            rulesetId: RULESET_ID,
+            cashOutCount: ADJUSTED_CASH_OUT_COUNT, // THIS IS THE FIX — must be the 721-adjusted value
+            totalSupply: NFT_TOTAL_SUPPLY, // from 721 hook
+            surplus: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                value: LOCAL_SURPLUS // 721 hook passes through surplus value
+            }),
+            useTotalSurplus: false,
+            cashOutTaxRate: 5000, // 721 hook passes through
+            beneficiaryIsFeeless: false,
+            metadata: ""
+        });
+
+        // Build the input context with the ORIGINAL cashOutCount.
+        JBBeforeCashOutRecordedContext memory context = _cashOutContext();
+
+        // Sanity: the original context has a different cashOutCount than what the 721 hook returns.
+        assertEq(context.cashOutCount, ORIGINAL_CASH_OUT_COUNT);
+        assertTrue(ORIGINAL_CASH_OUT_COUNT != ADJUSTED_CASH_OUT_COUNT);
+
+        // Expect the extra hook to be called with the adjusted context (including adjusted cashOutCount).
+        vm.expectCall(extraHookAddr, abi.encodeCall(IJBRulesetDataHook.beforeCashOutRecordedWith, (expectedContext)));
+
+        deployer.beforeCashOutRecordedWith(context);
+    }
+
+    function _cashOutContext() internal view returns (JBBeforeCashOutRecordedContext memory context) {
+        context = JBBeforeCashOutRecordedContext({
+            terminal: address(0x1234),
+            holder: holder,
+            projectId: PROJECT_ID,
+            rulesetId: RULESET_ID,
+            cashOutCount: ORIGINAL_CASH_OUT_COUNT,
+            totalSupply: 100 ether,
+            surplus: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+                value: LOCAL_SURPLUS
+            }),
+            useTotalSurplus: false,
+            cashOutTaxRate: 5000,
+            beneficiaryIsFeeless: false,
+            metadata: ""
+        });
+    }
+
+    function _mockSuckerRegistry() internal {
+        vm.mockCall(
+            suckerRegistry,
+            abi.encodeWithSelector(IJBSuckerRegistry.isSuckerOf.selector, PROJECT_ID, holder),
+            abi.encode(false)
+        );
+        vm.mockCall(
+            suckerRegistry,
+            abi.encodeWithSelector(IJBSuckerRegistry.remoteTotalSupplyOf.selector, PROJECT_ID),
+            abi.encode(0)
+        );
+        vm.mockCall(
+            suckerRegistry,
+            abi.encodeWithSelector(
+                IJBSuckerRegistry.remoteSurplusOf.selector,
+                PROJECT_ID,
+                uint256(18),
+                uint256(uint32(uint160(JBConstants.NATIVE_TOKEN)))
+            ),
+            abi.encode(0)
+        );
+    }
+
+    /// @dev Mock the extra hook to return passthrough values.
+    function _mockExtraHook() internal {
+        // We use a broad mock: any call to beforeCashOutRecordedWith returns passthrough values.
+        // The vm.expectCall will check the exact arguments.
+        JBCashOutHookSpecification[] memory specs = new JBCashOutHookSpecification[](0);
+        vm.mockCall(
+            extraHookAddr,
+            abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
+            abi.encode(uint256(5000), uint256(0), uint256(0), uint256(0), specs)
+        );
+    }
+
+    /// @dev Store the 721 hook at _tiered721HookOf[PROJECT_ID][RULESET_ID] (slot 1).
+    function _storeTiered721Hook(address hook, bool useDataHookForCashOut) internal {
+        bytes32 outerSlot = keccak256(abi.encode(PROJECT_ID, uint256(1)));
+        bytes32 valueSlot = keccak256(abi.encode(RULESET_ID, outerSlot));
+
+        uint256 packed = uint256(uint160(hook));
+        if (useDataHookForCashOut) packed |= uint256(1) << 160;
+
+        vm.store(address(deployer), valueSlot, bytes32(packed));
+    }
+
+    /// @dev Store the extra data hook at _extraDataHookOf[PROJECT_ID][RULESET_ID] (slot 0).
+    /// JBDeployerHookConfig has: IJBRulesetDataHook dataHook (20 bytes), bool useDataHookForPay (1 byte),
+    /// bool useDataHookForCashOut (1 byte). All pack into a single slot.
+    function _storeExtraDataHook(address hook, bool useDataHookForCashOut) internal {
+        bytes32 outerSlot = keccak256(abi.encode(PROJECT_ID, uint256(0)));
+        bytes32 valueSlot = keccak256(abi.encode(RULESET_ID, outerSlot));
+
+        uint256 packed = uint256(uint160(hook));
+        // useDataHookForPay is at bit 160, useDataHookForCashOut is at bit 168.
+        if (useDataHookForCashOut) packed |= uint256(1) << 168;
+
+        vm.store(address(deployer), valueSlot, bytes32(packed));
+    }
+}
+
+/// @notice Mock 721 hook that returns adjusted cashOutCount and totalSupply values.
+contract Mock721Hook is IJBRulesetDataHook {
+    uint256 internal immutable _cashOutCount;
+    uint256 internal immutable _totalSupply;
+
+    constructor(uint256 cashOutCount_, uint256 totalSupply_) {
+        _cashOutCount = cashOutCount_;
+        _totalSupply = totalSupply_;
+    }
+
+    function beforeCashOutRecordedWith(JBBeforeCashOutRecordedContext calldata context)
+        external
+        view
+        returns (
+            uint256 cashOutTaxRate,
+            uint256 effectiveCashOutCount,
+            uint256 effectiveTotalSupply,
+            uint256 effectiveSurplusValue,
+            JBCashOutHookSpecification[] memory hookSpecifications
+        )
+    {
+        cashOutTaxRate = context.cashOutTaxRate;
+        effectiveCashOutCount = _cashOutCount;
+        effectiveTotalSupply = _totalSupply;
+        effectiveSurplusValue = context.surplus.value;
+        hookSpecifications = new JBCashOutHookSpecification[](0);
+    }
+
+    function beforePayRecordedWith(JBBeforePayRecordedContext calldata context)
+        external
+        pure
+        returns (uint256 weight, JBPayHookSpecification[] memory hookSpecifications)
+    {
+        weight = context.weight;
+        hookSpecifications = new JBPayHookSpecification[](0);
+    }
+
+    function hasMintPermissionFor(uint256, JBRuleset memory, address) external pure returns (bool) {
+        return false;
+    }
+
+    function supportsInterface(bytes4) external pure returns (bool) {
+        return true;
+    }
+}