@bananapus/omnichain-deployers-v6 0.0.29 → 0.0.30

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.30",
   "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);
         }
 
@@ -452,16 +453,23 @@ contract JBOmnichainDeployer is
             // Build a mutable copy of the context with the latest values (possibly updated by the 721 hook).
             JBBeforeCashOutRecordedContext memory hookContext = context;
             hookContext.cashOutTaxRate = cashOutTaxRate;
-            hookContext.cashOutCount = cashOutCount;
             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 +518,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 +536,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 +559,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 +847,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
+            })
             );
     }
 }