@bananapus/omnichain-deployers-v6 0.0.20 → 0.0.21

package/ADMINISTRATION.md

@@ -43,7 +43,7 @@ Admin privileges and their scope in nana-omnichain-deployers-v6.
 
 | Function | Required Role | Permission ID | Scope | What It Does |
 |----------|--------------|---------------|-------|--------------|
-| `deploySuckersFor` | Project owner or operator | `DEPLOY_SUCKERS` | Per-project | Deploys new cross-chain suckers for an existing project via the sucker registry. |
+| `deploySuckersFor` | Project owner or operator | `DEPLOY_SUCKERS` | Per-project | Deploys new cross-chain suckers for an existing project via the sucker registry. The same operation also applies token mappings on the new suckers, so existing projects must already have the registry arranged as an authorized `MAP_SUCKER_TOKEN` operator for that project. |
 | `launchRulesetsFor` | Project owner or operator | `LAUNCH_RULESETS` + `SET_TERMINALS` | Per-project | Deploys a 721 tiers hook, launches new rulesets with terminal configuration for an existing project. Has a simplified overload without `deploy721Config`. |
 | `queueRulesetsOf` | Project owner or operator | `QUEUE_RULESETS` | Per-project | Queues new rulesets for an existing project. If tiers provided, deploys a new 721 hook. Otherwise, carries forward the 721 hook from the latest ruleset. Has a simplified overload without `deploy721Config`. |
 
@@ -81,12 +81,14 @@ Admin privileges and their scope in nana-omnichain-deployers-v6.
 
 | Action | Who | Mechanism |
 |--------|-----|-----------|
-| Deploy suckers for existing project | Project owner or DEPLOY_SUCKERS operator | `deploySuckersFor` calls `SUCKER_REGISTRY.deploySuckersFor` |
+| Deploy suckers for existing project | Project owner or DEPLOY_SUCKERS operator | `deploySuckersFor` calls `SUCKER_REGISTRY.deploySuckersFor`; because the registry also applies the initial mappings, existing projects must pair this with a project-level `MAP_SUCKER_TOKEN` arrangement for the registry |
 | Deploy suckers during project launch | Project deployer (anyone) | Included in `launchProjectFor` if `salt != bytes32(0)` |
 | Map sucker tokens | JBSuckerRegistry | Granted MAP_SUCKER_TOKEN at construction with projectId=0 wildcard |
 | Grant 0% cash-out tax to suckers | Automatic | `beforeCashOutRecordedWith` checks `SUCKER_REGISTRY.isSuckerOf` |
 | Grant mint permission to suckers | Automatic | `hasMintPermissionFor` checks `SUCKER_REGISTRY.isSuckerOf` |
 
+**Existing-project operator note:** `deploySuckersFor` looks like a deployment-only action at the top level, but it is intentionally a deploy-and-map flow. If an existing project delegates `DEPLOY_SUCKERS` without also arranging `MAP_SUCKER_TOKEN` for the registry, the transaction will fail once the registry reaches the mapping step.
+
 **Cross-chain determinism:** The salt for sucker deployment is combined with `_msgSender()` (`keccak256(abi.encode(salt, _msgSender()))`). Deploying from the same sender address with the same salt on each chain produces matching sucker addresses.
 
 ## Data Hook Proxy Pattern

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bananapus/omnichain-deployers-v6",
-    "version": "0.0.20",
+  "version": "0.0.21",
     "license": "MIT",
     "repository": {
         "type": "git",
@@ -18,9 +18,8 @@
     },
     "dependencies": {
         "@bananapus/721-hook-v6": "^0.0.30",
-        "@bananapus/address-registry-v6": "^0.0.16",
-        "@bananapus/buyback-hook-v6": "^0.0.24",
-        "@bananapus/core-v6": "^0.0.30",
+        "@bananapus/buyback-hook-v6": "^0.0.25",
+        "@bananapus/core-v6": "^0.0.31",
         "@bananapus/ownable-v6": "^0.0.16",
         "@bananapus/permission-ids-v6": "^0.0.15",
         "@bananapus/suckers-v6": "^0.0.20",

package/references/operations.md

@@ -19,6 +19,7 @@
 - A same-block queue assumption breaks predicted ruleset IDs and silently strands stored config.
 - A project expects custom-hook behavior on cash-out, but the wrapper flags disable it or the sucker exemption bypasses it.
 - Deterministic deployment assumptions fail because sender or salt composition changed.
+- Existing-project sucker deployment is treated as a pure `DEPLOY_SUCKERS` flow even though the registry also performs token mapping, so missing `MAP_SUCKER_TOKEN` authority for the registry shows up only when the deploy path reaches `mapTokens`.
 
 ## Useful Proof Points
 

package/src/JBOmnichainDeployer.sol

@@ -378,7 +378,9 @@ contract JBOmnichainDeployer is
     //*********************************************************************//
 
     /// @notice Deploy new suckers for an existing project.
-    /// @dev Only the juicebox's owner can deploy new suckers.
+    /// @dev Only the juicebox's owner or an operator with `JBPermissionIds.DEPLOY_SUCKERS` can call this entrypoint.
+    /// The downstream registry call also maps the configured tokens on each newly created sucker, so the same
+    /// end-to-end operation depends on the project's token-mapping authority being arranged for the registry.
     /// @param projectId The ID of the project to deploy suckers for.
     /// @param suckerDeploymentConfiguration The suckers to set up for the project.
     function deploySuckersFor(
@@ -806,7 +808,10 @@ contract JBOmnichainDeployer is
             // Use the caller-provided flag when deploying a new hook.
             use721ForCashOut = deploy721Config.useDataHookForCashOut;
         } else {
-            JBTiered721HookConfig memory previousConfig = _tiered721HookOf[projectId][latestRulesetId];
+            // Read the *current* (approved) ruleset — not `latestRulesetId` — because a queued-but-unapproved
+            // ruleset may have been rejected by the approval hook, so its hook config should not be carried forward.
+            uint256 currentRulesetId = controller.RULESETS().currentOf(projectId).id;
+            JBTiered721HookConfig memory previousConfig = _tiered721HookOf[projectId][currentRulesetId];
             hook = previousConfig.hook;
             // Revert if no hook exists to carry forward — this means no tiers were provided and
             // no previous ruleset had a 721 hook deployed through this contract.

package/src/interfaces/IJBOmnichainDeployer.sol

@@ -37,6 +37,9 @@ interface IJBOmnichainDeployer {
         returns (IJB721TiersHook hook, bool useDataHookForCashOut);
 
     /// @notice Deploy new suckers for an existing project.
+    /// @dev This flow forwards to `JBSuckerRegistry.deploySuckersFor`, which also applies the supplied token mappings
+    /// on each newly deployed sucker. Existing projects therefore need both deployment authority and a project-level
+    /// arrangement that lets the registry perform `MAP_SUCKER_TOKEN` for the same operation.
     /// @param projectId The ID of the project to deploy suckers for.
     /// @param suckerDeploymentConfiguration The suckers to set up for the project.
     /// @return suckers The addresses of the deployed suckers.

package/test/JBOmnichainDeployer.t.sol

@@ -392,6 +392,19 @@ contract TestJBOmnichainDeployer is Test {
             abi.encodeWithSelector(IJBRulesets.latestRulesetIdOf.selector, projectId),
             abi.encode(launchTimestamp)
         );
+
+        // Mock currentOf to return a ruleset whose id matches the launch so carry-forward can look up the stored 721
+        // hook.
+        {
+            JBRuleset memory currentRuleset;
+            currentRuleset.id = uint48(launchTimestamp);
+            vm.mockCall(
+                address(rulesets),
+                abi.encodeWithSelector(IJBRulesets.currentOf.selector, projectId),
+                abi.encode(currentRuleset)
+            );
+        }
+
         // Warp forward so latestRulesetId < block.timestamp.
         vm.warp(block.timestamp + 1);
 
@@ -472,6 +485,16 @@ contract TestJBOmnichainDeployer is Test {
             abi.encode(launchTimestamp)
         );
 
+        // Mock currentOf to return a ruleset whose id matches the launch so carry-forward can look up the stored 721
+        // hook.
+        JBRuleset memory currentRuleset;
+        currentRuleset.id = uint48(launchTimestamp);
+        vm.mockCall(
+            address(rulesets),
+            abi.encodeWithSelector(IJBRulesets.currentOf.selector, projectId),
+            abi.encode(currentRuleset)
+        );
+
         // Warp forward so latestRulesetId < block.timestamp.
         vm.warp(block.timestamp + 1);
 

package/test/OmnichainDeployerEdgeCases.t.sol

@@ -614,11 +614,20 @@ contract OmnichainDeployerEdgeCases is Test {
             abi.encode(uint256(50)) // A past ruleset ID — no hook stored at this ID
         );
 
+        // Mock currentOf to return a ruleset with id=50 (no hook stored for this id via the deployer).
+        JBRuleset memory currentRuleset;
+        currentRuleset.id = uint48(50);
+        vm.mockCall(
+            address(rulesets),
+            abi.encodeWithSelector(IJBRulesets.currentOf.selector, projectId),
+            abi.encode(currentRuleset)
+        );
+
         JBRulesetConfig[] memory configs = new JBRulesetConfig[](1);
         configs[0] = _makeRulesetConfig(address(0), true, false);
 
         // Empty 721 config — no tiers, so it tries to carry forward an existing hook.
-        // But no hook was stored for rulesetId=1 via this deployer.
+        // But no hook was stored for rulesetId=50 via this deployer.
         JBOmnichain721Config memory empty721Config;
         vm.prank(projectOwner);
         vm.expectRevert(JBOmnichainDeployer.JBOmnichainDeployer_InvalidHook.selector);

package/test/TestAuditGaps.sol

@@ -539,6 +539,7 @@ contract TestAuditGaps is Test {
         // latestRulesetIdOf still = BASE_TIME (from launch).
         // Guard: BASE_TIME >= BASE_TIME + 1 -> false -> passes.
         _mockLatestRulesetId(BASE_TIME);
+        _mockCurrentRulesetId(BASE_TIME);
 
         uint256 expectedQueuedId = BASE_TIME + 1;
         vm.mockCall(
@@ -565,6 +566,7 @@ contract TestAuditGaps is Test {
         // Warp forward 1 second for first queue.
         vm.warp(BASE_TIME + 1);
         _mockLatestRulesetId(BASE_TIME);
+        _mockCurrentRulesetId(BASE_TIME);
 
         uint256 firstQueueTime = BASE_TIME + 1;
         vm.mockCall(
@@ -672,6 +674,7 @@ contract TestAuditGaps is Test {
         // Warp past the latestRulesetId: block.timestamp = BASE_TIME + 3.
         vm.warp(BASE_TIME + 3);
         _mockLatestRulesetId(latestRulesetId);
+        _mockCurrentRulesetId(BASE_TIME);
 
         uint256 expectedQueuedId = BASE_TIME + 3;
         vm.mockCall(
@@ -699,6 +702,7 @@ contract TestAuditGaps is Test {
         // Warp forward.
         vm.warp(BASE_TIME + 100);
         _mockLatestRulesetId(BASE_TIME);
+        _mockCurrentRulesetId(BASE_TIME);
 
         uint256 expectedQueuedId = BASE_TIME + 100;
         vm.mockCall(
@@ -739,6 +743,16 @@ contract TestAuditGaps is Test {
         vm.warp(BASE_TIME + 50);
         _mockLatestRulesetId(BASE_TIME);
 
+        // Mock currentOf to return a ruleset whose id matches the launch ruleset so carry-forward can look up the
+        // stored 721 hook.
+        JBRuleset memory currentRuleset;
+        currentRuleset.id = uint48(BASE_TIME);
+        vm.mockCall(
+            address(rulesetsContract),
+            abi.encodeWithSelector(IJBRulesets.currentOf.selector, projectId),
+            abi.encode(currentRuleset)
+        );
+
         uint256 expectedQueuedId = BASE_TIME + 50;
         vm.mockCall(
             address(controller),
@@ -820,6 +834,7 @@ contract TestAuditGaps is Test {
 
         vm.warp(BASE_TIME + 10);
         _mockLatestRulesetId(BASE_TIME);
+        _mockCurrentRulesetId(BASE_TIME);
 
         uint256 expectedQueuedId = BASE_TIME + 10;
         vm.mockCall(
@@ -866,6 +881,14 @@ contract TestAuditGaps is Test {
         );
     }
 
+    function _mockCurrentRulesetId(uint256 currentRulesetId) internal {
+        JBRuleset memory r;
+        r.id = uint48(currentRulesetId);
+        vm.mockCall(
+            address(rulesetsContract), abi.encodeWithSelector(IJBRulesets.currentOf.selector, projectId), abi.encode(r)
+        );
+    }
+
     function _makePayContext(uint256 pid, uint256 rid) internal returns (JBBeforePayRecordedContext memory) {
         return JBBeforePayRecordedContext({
             terminal: makeAddr("terminal"),

package/test/audit/CarryForwardRejectedHook.t.sol

@@ -0,0 +1,305 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import {TestBaseWorkflow} from "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+import {JBApprovalStatus} from "@bananapus/core-v6/src/enums/JBApprovalStatus.sol";
+import {IJBController} from "@bananapus/core-v6/src/interfaces/IJBController.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 {IJBRulesetApprovalHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetApprovalHook.sol";
+import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
+import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsData.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";
+import {JBTerminalConfig} from "@bananapus/core-v6/src/structs/JBTerminalConfig.sol";
+import {IJB721TiersHook} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHook.sol";
+import {IJB721TiersHookDeployer} from "@bananapus/721-hook-v6/src/interfaces/IJB721TiersHookDeployer.sol";
+import {JBDeploy721TiersHookConfig} from "@bananapus/721-hook-v6/src/structs/JBDeploy721TiersHookConfig.sol";
+import {JB721TierConfig} from "@bananapus/721-hook-v6/src/structs/JB721TierConfig.sol";
+import {IJBSuckerRegistry} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerRegistry.sol";
+import {JBSuckerDeployerConfig} from "@bananapus/suckers-v6/src/structs/JBSuckerDeployerConfig.sol";
+import {JBSuckersPair} from "@bananapus/suckers-v6/src/structs/JBSuckersPair.sol";
+import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
+import {ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {JBOmnichainDeployer} from "../../src/JBOmnichainDeployer.sol";
+import {JBOmnichain721Config} from "../../src/structs/JBOmnichain721Config.sol";
+import {JBSuckerDeploymentConfig} from "../../src/structs/JBSuckerDeploymentConfig.sol";
+
+contract RejectingApprovalHook is ERC165, IJBRulesetApprovalHook {
+    function DURATION() external pure override returns (uint256) {
+        return 0;
+    }
+
+    function approvalStatusOf(uint256, JBRuleset calldata) external pure override returns (JBApprovalStatus) {
+        return JBApprovalStatus.Failed;
+    }
+
+    function supportsInterface(bytes4 interfaceId) public view override(ERC165, IERC165) returns (bool) {
+        return interfaceId == type(IJBRulesetApprovalHook).interfaceId || super.supportsInterface(interfaceId);
+    }
+}
+
+contract HookStub {
+    uint256 public lastProjectId;
+
+    function transferOwnershipToProject(uint256 projectId) external {
+        lastProjectId = projectId;
+    }
+}
+
+contract SequentialHookDeployer is IJB721TiersHookDeployer {
+    HookStub[] internal _hooks;
+    uint256 internal _index;
+
+    constructor(HookStub[] memory hooks) {
+        _hooks = hooks;
+    }
+
+    function deployHookFor(
+        uint256,
+        JBDeploy721TiersHookConfig calldata,
+        bytes32
+    )
+        external
+        override
+        returns (IJB721TiersHook)
+    {
+        return IJB721TiersHook(address(_hooks[_index++]));
+    }
+}
+
+contract MockSuckerRegistryCarryForward is IJBSuckerRegistry {
+    function DIRECTORY() external pure override returns (IJBDirectory) {
+        return IJBDirectory(address(0));
+    }
+
+    function PROJECTS() external pure override returns (IJBProjects) {
+        return IJBProjects(address(0));
+    }
+
+    function isSuckerOf(uint256, address) external pure override returns (bool) {
+        return false;
+    }
+
+    function suckerDeployerIsAllowed(address) external pure override returns (bool) {
+        return false;
+    }
+
+    function suckerPairsOf(uint256) external pure override returns (JBSuckersPair[] memory) {
+        return new JBSuckersPair[](0);
+    }
+
+    function suckersOf(uint256) external pure override returns (address[] memory) {
+        return new address[](0);
+    }
+
+    function MAX_TO_REMOTE_FEE() external pure override returns (uint256) {
+        return 0;
+    }
+
+    function toRemoteFee() external pure override returns (uint256) {
+        return 0;
+    }
+
+    function setToRemoteFee(uint256) external override {}
+    function allowSuckerDeployer(address) external override {}
+    function allowSuckerDeployers(address[] calldata) external override {}
+
+    function deploySuckersFor(
+        uint256,
+        bytes32,
+        JBSuckerDeployerConfig[] memory
+    )
+        external
+        pure
+        override
+        returns (address[] memory)
+    {
+        return new address[](0);
+    }
+
+    function removeDeprecatedSucker(uint256, address) external override {}
+    function removeSuckerDeployer(address) external override {}
+}
+
+contract CarryForwardRejectedHookTest is TestBaseWorkflow {
+    JBOmnichainDeployer internal deployer;
+    RejectingApprovalHook internal rejectHook;
+    SequentialHookDeployer internal hookDeployer;
+    HookStub internal initialHook;
+    HookStub internal rejectedHook;
+    MockSuckerRegistryCarryForward internal suckerRegistry;
+
+    address internal owner;
+
+    function setUp() public override {
+        super.setUp();
+
+        owner = multisig();
+        rejectHook = new RejectingApprovalHook();
+        initialHook = new HookStub();
+        rejectedHook = new HookStub();
+        HookStub[] memory hooks = new HookStub[](2);
+        hooks[0] = initialHook;
+        hooks[1] = rejectedHook;
+        hookDeployer = new SequentialHookDeployer(hooks);
+        suckerRegistry = new MockSuckerRegistryCarryForward();
+
+        deployer = new JBOmnichainDeployer(
+            IJBSuckerRegistry(address(suckerRegistry)),
+            IJB721TiersHookDeployer(address(hookDeployer)),
+            IJBPermissions(address(jbPermissions())),
+            IJBProjects(address(jbProjects())),
+            trustedForwarder()
+        );
+
+        vm.prank(multisig());
+        jbDirectory().setIsAllowedToSetFirstController(address(deployer), true);
+    }
+
+    function test_queueCarryForward_usesRejectedRulesetHook_notCurrentRulesetHook() public {
+        JBRulesetConfig[] memory initialRulesets = _makeRulesets(rejectHook);
+        JBTerminalConfig[] memory terminals = new JBTerminalConfig[](0);
+        JBOmnichain721Config memory configWithTiers = _configWithTiers(false);
+
+        (uint256 projectId, IJB721TiersHook launchedHook,) = deployer.launchProjectFor(
+            owner,
+            "ipfs://project",
+            configWithTiers,
+            initialRulesets,
+            terminals,
+            "launch",
+            _emptySuckerConfig(),
+            IJBController(address(jbController()))
+        );
+        uint256 initialRulesetId = jbRulesets().latestRulesetIdOf(projectId);
+
+        assertEq(address(launchedHook), address(initialHook), "launch should use the first hook");
+
+        _grantQueuePermissions(projectId);
+
+        vm.warp(block.timestamp + 1);
+
+        JBOmnichain721Config memory rejectedConfig = _configWithTiers(true);
+        (uint256 rejectedRulesetId,) = deployer.queueRulesetsOf(
+            projectId,
+            rejectedConfig,
+            _makeRulesets(IJBRulesetApprovalHook(address(0))),
+            "rejected",
+            IJBController(address(jbController()))
+        );
+
+        JBRuleset memory currentRuleset = jbRulesets().currentOf(projectId);
+        assertEq(currentRuleset.id, initialRulesetId, "core should still use the last approved ruleset");
+
+        vm.warp(block.timestamp + 2);
+
+        (uint256 carriedRulesetId,) = deployer.queueRulesetsOf(
+            projectId,
+            _default721Config(),
+            _makeRulesets(IJBRulesetApprovalHook(address(0))),
+            "carry",
+            IJBController(address(jbController()))
+        );
+
+        (IJB721TiersHook carriedHook, bool carriedCashOutFlag) = deployer.tiered721HookOf(projectId, carriedRulesetId);
+        (IJB721TiersHook currentHook, bool currentCashOutFlag) = deployer.tiered721HookOf(projectId, initialRulesetId);
+        (IJB721TiersHook rejectedStoredHook, bool rejectedCashOutFlag) =
+            deployer.tiered721HookOf(projectId, rejectedRulesetId);
+
+        assertEq(address(currentHook), address(initialHook), "approved ruleset should point to the initial hook");
+        assertFalse(currentCashOutFlag, "approved ruleset should preserve its original cash-out flag");
+
+        assertEq(address(rejectedStoredHook), address(rejectedHook), "rejected ruleset should store the second hook");
+        assertTrue(rejectedCashOutFlag, "rejected ruleset should store the second cash-out flag");
+
+        // The carry-forward uses currentOf (the approved ruleset), not the rejected queued one.
+        assertEq(
+            address(carriedHook),
+            address(initialHook),
+            "carry-forward should inherit the current (approved) hook, not the rejected one"
+        );
+        assertFalse(carriedCashOutFlag, "carry-forward should inherit the current (approved) cash-out flag");
+    }
+
+    function _configWithTiers(bool useDataHookForCashOut) internal pure returns (JBOmnichain721Config memory config) {
+        config = _default721Config();
+        config.useDataHookForCashOut = useDataHookForCashOut;
+        config.deployTiersHookConfig.tiersConfig.tiers = new JB721TierConfig[](1);
+        config.deployTiersHookConfig.tiersConfig.tiers[0].price = 1 ether;
+        config.deployTiersHookConfig.tiersConfig.tiers[0].initialSupply = 10;
+    }
+
+    function _default721Config() internal pure returns (JBOmnichain721Config memory config) {
+        config.deployTiersHookConfig.tiersConfig.currency =
+            uint32(uint160(address(0x000000000000000000000000000000000000EEEe)));
+        config.deployTiersHookConfig.tiersConfig.decimals = 18;
+    }
+
+    function _makeRulesets(IJBRulesetApprovalHook approvalHook)
+        internal
+        pure
+        returns (JBRulesetConfig[] memory configs)
+    {
+        configs = new JBRulesetConfig[](1);
+        configs[0] = JBRulesetConfig({
+            mustStartAtOrAfter: uint48(0),
+            duration: uint32(0),
+            weight: uint112(1e18),
+            weightCutPercent: uint32(0),
+            approvalHook: approvalHook,
+            metadata: JBRulesetMetadata({
+                reservedPercent: 0,
+                cashOutTaxRate: 0,
+                baseCurrency: uint32(uint160(address(0x000000000000000000000000000000000000EEEe))),
+                pausePay: false,
+                pauseCreditTransfers: false,
+                allowOwnerMinting: false,
+                allowSetCustomToken: false,
+                allowTerminalMigration: false,
+                allowSetController: false,
+                allowSetTerminals: false,
+                allowAddAccountingContext: false,
+                allowAddPriceFeed: false,
+                ownerMustSendPayouts: false,
+                holdFees: false,
+                useTotalSurplusForCashOuts: false,
+                useDataHookForPay: false,
+                useDataHookForCashOut: false,
+                dataHook: address(0),
+                metadata: 0
+            }),
+            splitGroups: new JBSplitGroup[](0),
+            fundAccessLimitGroups: new JBFundAccessLimitGroup[](0)
+        });
+    }
+
+    function _emptySuckerConfig() internal pure returns (JBSuckerDeploymentConfig memory) {
+        return JBSuckerDeploymentConfig({deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: bytes32(0)});
+    }
+
+    function _grantQueuePermissions(uint256 projectId) internal {
+        uint8[] memory permissionIds = new uint8[](1);
+        permissionIds[0] = JBPermissionIds.QUEUE_RULESETS;
+
+        vm.prank(owner);
+        jbPermissions()
+            .setPermissionsFor(
+                owner,
+                JBPermissionsData({operator: address(this), projectId: uint64(projectId), permissionIds: permissionIds})
+            );
+
+        vm.prank(owner);
+        jbPermissions()
+            .setPermissionsFor(
+                owner,
+                JBPermissionsData({
+                    operator: address(deployer), projectId: uint64(projectId), permissionIds: permissionIds
+                })
+            );
+    }
+}

package/test/audit/JBOmnichainDeployer.t.sol

@@ -11,6 +11,7 @@ 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 {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
 import {JBBeforeCashOutRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforeCashOutRecordedContext.sol";
 import {JBCashOutHookSpecification} from "@bananapus/core-v6/src/structs/JBCashOutHookSpecification.sol";
 import {JBFundAccessLimitGroup} from "@bananapus/core-v6/src/structs/JBFundAccessLimitGroup.sol";
@@ -196,6 +197,15 @@ contract JBOmnichainDeployerTest is Test {
             abi.encode(initialRulesetId)
         );
 
+        // Mock currentOf to return a JBRuleset with id = initialRulesetId so the carry-forward lookup succeeds.
+        JBRuleset memory currentRuleset;
+        currentRuleset.id = uint48(initialRulesetId);
+        vm.mockCall(
+            address(rulesets),
+            abi.encodeWithSelector(IJBRulesets.currentOf.selector, PROJECT_ID),
+            abi.encode(currentRuleset)
+        );
+
         vm.warp(block.timestamp + 1);
         uint256 queuedRulesetId = block.timestamp;
         vm.mockCall(

package/assets/findings/nana-omnichain-deployers-v6-pashov-ai-audit-report-20260330-103536.md

@@ -1,39 +0,0 @@
-# 🔐 Security Review — nana-omnichain-deployers-v6
-
----
-
-## Scope
-
-|                                  |                                                                                                                                                                                                             |
-| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Mode**                         | ALL / default                                                                                                                                                                                               |
-| **Files reviewed**               | `script/Deploy.s.sol` · `script/helpers/DeployersDeploymentLib.sol` · `src/JBOmnichainDeployer.sol`<br>`src/structs/JBDeployerHookConfig.sol` · `src/structs/JBOmnichain721Config.sol` · `src/structs/JBSuckerDeploymentConfig.sol`<br>`src/structs/JBTiered721HookConfig.sol` |
-| **Confidence threshold (1-100)** | 75                                                                                                                                                                                                          |
-
----
-
-## Findings
-
-None.
-
----
-
-Findings List
-
-| # | Confidence | Title |
-|---|---|---|
-| - | - | None |
-
----
-
-## Leads
-
-_Vulnerability trails with concrete code smells where the full exploit path could not be completed in one analysis pass. These are not false positives — they are high-signal leads for manual review. Not scored._
-
-- **Reflexive controller validation overstates what it proves** — `JBOmnichainDeployer._validateController` — Code smells: validation is anchored to `controller.DIRECTORY()` supplied by the same controller being checked, rather than to an immutable trusted directory — This did not survive to a finding because the path does not update the canonical project rulesets or directory, so I could not complete a live exploit that changes real terminal execution. It is still worth tightening or clarifying because the current comment implies stronger authenticity guarantees than the code actually enforces.
-- **`launchRulesetsFor` semantics depend on upstream “first launch only” behavior** — `JBOmnichainDeployer._launchRulesetsFor` — Code smells: the wrapper presents a generic launch entrypoint, but upstream `JBController.launchRulesetsFor` reverts once a project already has rulesets — I did not confirm a security impact, but the API/documentation boundary is easy to misuse and should remain regression-tested so integrations do not assume it can relaunch arbitrary existing projects.
-- **Pay-hook composition assumes the 721 hook preserves its current return-shape invariants** — `JBOmnichainDeployer.beforePayRecordedWith` — Code smells: only `tiered721HookSpecs[0]` is consumed and `projectAmount` is clamped to zero if the returned split amount exceeds the payment amount — I could not prove an exploitable path in the current dependency set because the bundled 721 hook maintains the expected single-spec invariant. This remains a dependency-sensitive integration trail if the upstream hook contract or interface expectations ever change.
-
----
-
-> ⚠️ This review was performed by an AI assistant. AI analysis can never verify the complete absence of vulnerabilities and no guarantee of security is given. Team security reviews, bug bounty programs, and on-chain monitoring are strongly recommended. For a consultation regarding your projects' security, visit [https://www.pashov.com](https://www.pashov.com)