@bananapus/ownable-v6 0.0.8 → 0.0.9

package/STYLE_GUIDE.md

@@ -197,7 +197,7 @@ interface IJBExample is IJBBase {
 | Public/external function | `camelCase` | `cashOutTokensOf` |
 | Internal/private function | `_camelCase` | `_processFee` |
 | Internal storage | `_camelCase` | `_accountingContextForTokenOf` |
-| Function parameter | `camelCase` | `projectId`, `cashOutCount` |
+| Function parameter | `camelCase` (no underscores) | `projectId`, `cashOutCount` |
 
 ## NatSpec
 
@@ -253,9 +253,12 @@ uint256 public constant MAX_RESERVED_PERCENT = 10_000;
 
 ## Function Calls
 
-Use named parameters for readability when calling functions with 3+ arguments:
+Use named arguments for all function calls with 2 or more arguments — in both `src/` and `script/`:
 
 ```solidity
+// Good — named arguments
+token.mint({account: beneficiary, amount: count});
+_transferOwnership({newOwner: address(0), projectId: 0});
 PERMISSIONS.hasPermission({
     operator: sender,
     account: account,
@@ -264,8 +267,18 @@ PERMISSIONS.hasPermission({
     includeRoot: true,
     includeWildcardProjectId: true
 });
+
+// Bad — positional arguments with 2+ args
+token.mint(beneficiary, count);
+_transferOwnership(address(0), 0);
 ```
 
+Single-argument calls use positional style: `_burn(amount)`.
+
+This also applies to constructor calls, struct literals, and inherited/library calls (e.g., OZ `_mint`, `_safeMint`, `safeTransfer`, `allowance`, `Clones.cloneDeterministic`).
+
+Named argument keys must use **camelCase** — never underscores. If a function's parameter names use underscores, rename them to camelCase first.
+
 ## Multiline Signatures
 
 ```solidity
@@ -553,6 +566,7 @@ CI checks formatting via `forge fmt --check`.
 
 CI runs `forge build --sizes` to catch contracts approaching the 24KB limit. When the repo's default `optimizer_runs` differs from what you want for size checking, use `FOUNDRY_PROFILE=ci_sizes forge build --sizes` with a `[profile.ci_sizes]` section in `foundry.toml`.
 
+
 ## Repo-Specific Deviations
 
 None. This repo follows the standard configuration exactly.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/ownable-v6",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -10,8 +10,8 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@bananapus/core-v6": "^0.0.15",
-    "@bananapus/permission-ids-v6": "^0.0.7",
+    "@bananapus/core-v6": "^0.0.16",
+    "@bananapus/permission-ids-v6": "^0.0.9",
     "@openzeppelin/contracts": "^5.6.1"
   },
   "scripts": {

package/src/JBOwnableOverrides.sol

@@ -75,7 +75,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
             revert JBOwnableOverrides_InvalidNewOwner();
         }
 
-        _transferOwnership(initialOwner, initialProjectIdOwner);
+        _transferOwnership({newOwner: initialOwner, projectId: initialProjectIdOwner});
     }
 
     //*********************************************************************//
@@ -140,7 +140,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
     /// @dev This can only be called by the current owner.
     function renounceOwnership() public virtual override {
         _checkOwner();
-        _transferOwnership(address(0), 0);
+        _transferOwnership({newOwner: address(0), projectId: 0});
     }
 
     /// @notice Sets the permission ID the owner can use to give other addresses owner access.
@@ -162,7 +162,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
             revert JBOwnableOverrides_InvalidNewOwner();
         }
 
-        _transferOwnership(newOwner, 0);
+        _transferOwnership({newOwner: newOwner, projectId: 0});
     }
 
     /// @notice Transfer ownership of this contract to a new Juicebox project.
@@ -181,7 +181,8 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
             revert JBOwnableOverrides_ProjectDoesNotExist();
         }
 
-        _transferOwnership(address(0), uint88(projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        _transferOwnership({newOwner: address(0), projectId: uint88(projectId)});
     }
 
     //*********************************************************************//
@@ -207,7 +208,7 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
     /// @notice Helper to allow for drop-in replacement of OpenZeppelin `Ownable`.
     /// @param newOwner The address that should receive ownership of this contract.
     function _transferOwnership(address newOwner) internal virtual {
-        _transferOwnership(newOwner, 0);
+        _transferOwnership({newOwner: newOwner, projectId: 0});
     }
 
     /// @notice Transfers this contract's ownership to an address (`newOwner`) OR a Juicebox project (`projectId`).
@@ -238,6 +239,6 @@ abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
         // This is to prevent permissions clashes for the new user/owner.
         jbOwner = JBOwner({owner: newOwner, projectId: projectId, permissionId: 0});
         // Emit a transfer event with the new owner's address.
-        _emitTransferEvent(oldOwner, newOwner, projectId);
+        _emitTransferEvent({previousOwner: oldOwner, newOwner: newOwner, newProjectId: projectId});
     }
 }

package/src/structs/JBOwner.sol

@@ -7,6 +7,7 @@ pragma solidity ^0.8.0;
 /// `owner` address has owner access.
 /// @custom:member permissionId The permission ID which corresponds to owner access. See `JBPermissions` in `nana-core`
 /// and `nana-permission-ids`.
+// forge-lint: disable-next-line(pascal-case-struct)
 struct JBOwner {
     address owner;
     uint88 projectId;

package/test/Ownable.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "./mocks/MockOwnable.sol";
 import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
 
@@ -13,8 +13,8 @@ import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsDat
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 
 contract OwnableTest is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     modifier isNotContract(address a) {
         uint256 size;
@@ -27,9 +27,9 @@ contract OwnableTest is Test {
 
     function setUp() public {
         // Deploy the permissions contract.
-        PERMISSIONS = new JBPermissions(address(0));
+        permissions = new JBPermissions(address(0));
         // Deploy the projects contract.
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     function testDeployerDoesNotBecomeOwner(address deployer, address owner) public isNotContract(owner) {
@@ -37,7 +37,7 @@ contract OwnableTest is Test {
         vm.assume(owner != address(0));
 
         vm.prank(deployer);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, uint88(0));
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, uint88(0));
 
         assertEq(owner, ownable.owner(), "Deployer did not become the owner.");
     }
@@ -56,17 +56,18 @@ contract OwnableTest is Test {
         vm.assume(newProjectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 projectId = PROJECTS.createFor(projectOwner);
+        uint256 projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Make sure the deployer owns it.
         assertEq(projectOwner, ownable.owner(), "Deployer is not the owner.");
 
         // Transfer the project's ownership.
         vm.prank(projectOwner);
-        PROJECTS.transferFrom(projectOwner, newProjectOwner, projectId);
+        projects.transferFrom(projectOwner, newProjectOwner, projectId);
 
         // Make sure the `Ownable` contract has also been transferred to the new project owner.
         assertEq(newProjectOwner, ownable.owner(), "Ownable did not follow the Project owner.");
@@ -86,10 +87,11 @@ contract OwnableTest is Test {
         vm.assume(projectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Make sure the project owner owns it.
         assertEq(projectOwner, ownable.owner(), "Deployer is not the owner.");
@@ -100,7 +102,7 @@ contract OwnableTest is Test {
         // Make sure it was transferred to the new owner.
         assertEq(newOwnableOwner, ownable.owner());
         // Sanity check to make sure it only the `Ownable` changed, and that the project did not.
-        assertEq(PROJECTS.ownerOf(_projectId), projectOwner);
+        assertEq(projects.ownerOf(_projectId), projectOwner);
     }
 
     function testCantTransferToProjectZero(address owner) public {
@@ -108,7 +110,7 @@ contract OwnableTest is Test {
         vm.startPrank(owner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, 0);
 
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
 
@@ -122,7 +124,7 @@ contract OwnableTest is Test {
         vm.startPrank(owner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, uint88(0));
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, uint88(0));
 
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
 
@@ -145,18 +147,19 @@ contract OwnableTest is Test {
         vm.assume(newProjectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Make sure the project owner owns it.
         assertEq(projectOwner, ownable.owner(), "Deployer is not the owner.");
 
         // Transfer the project ownership.
         vm.prank(projectOwner);
-        PROJECTS.transferFrom(projectOwner, newProjectOwner, _projectId);
-        assertEq(PROJECTS.ownerOf(_projectId), newProjectOwner);
+        projects.transferFrom(projectOwner, newProjectOwner, _projectId);
+        assertEq(projects.ownerOf(_projectId), newProjectOwner);
 
         // Make sure the `Ownable` contract has also been transferred to the new project owner.
         assertEq(newProjectOwner, ownable.owner());
@@ -167,7 +170,7 @@ contract OwnableTest is Test {
         vm.assume(deployer != owner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, owner, uint88(0));
+        MockOwnable ownable = new MockOwnable(projects, permissions, owner, uint88(0));
 
         // Transfer ownership to the project owner.
         vm.prank(owner);
@@ -185,11 +188,12 @@ contract OwnableTest is Test {
         vm.assume(projectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
         vm.prank(deployer);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Renounce the ownership.
         vm.prank(projectOwner);
@@ -218,10 +222,11 @@ contract OwnableTest is Test {
         }
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Set the required permission.
         vm.prank(projectOwner);
@@ -254,8 +259,9 @@ contract OwnableTest is Test {
 
         // The owner gives permission to the caller.
         vm.prank(projectOwner);
-        PERMISSIONS.setPermissionsFor(
+        permissions.setPermissionsFor(
             projectOwner,
+            // forge-lint: disable-next-line(unsafe-typecast)
             JBPermissionsData({operator: callerAddress, projectId: uint56(_projectId), permissionIds: _permissionIds})
         );
 
@@ -296,10 +302,11 @@ contract OwnableTest is Test {
         }
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Create the `Ownable` contract.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(_projectId));
 
         // Set the permission that is required.
         ownable.setPermission(requiredPermissionId);
@@ -331,8 +338,9 @@ contract OwnableTest is Test {
 
         // The owner gives permission to the caller.
         vm.prank(projectOwner);
-        PERMISSIONS.setPermissionsFor(
+        permissions.setPermissionsFor(
             projectOwner,
+            // forge-lint: disable-next-line(unsafe-typecast)
             JBPermissionsData({operator: callerAddress, projectId: uint56(_projectId), permissionIds: _permissionIds})
         );
 
@@ -356,19 +364,20 @@ contract OwnableTest is Test {
         vm.assume(owner != address(0) && projectOwner != address(0));
 
         // Create a project for the owner.
-        uint256 _projectId = PROJECTS.createFor(projectOwner);
+        uint256 _projectId = projects.createFor(projectOwner);
 
         // Should revert because we set both a owner and a projectOwner
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
 
         // Create the `Ownable` contract.
-        new MockOwnable(PROJECTS, PERMISSIONS, address(owner), uint88(_projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        new MockOwnable(projects, permissions, address(owner), uint88(_projectId));
     }
 
     function testCantInitializeAsRenounced() public {
         // Should revert because we set both a owner and a projectOwner
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
         // Create the `Ownable` contract.
-        new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(0));
+        new MockOwnable(projects, permissions, address(0), uint88(0));
     }
 }

package/test/OwnableAttacks.t.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "./mocks/MockOwnable.sol";
 import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
 
@@ -16,8 +16,8 @@ import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsDat
 /// @notice Adversarial security tests for JBOwnable covering edge cases
 ///         around dual ownership, permission semantics, and renounced contracts.
 contract OwnableAttacks is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
     address bob = makeAddr("bob");
@@ -33,25 +33,26 @@ contract OwnableAttacks is Test {
     }
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     // =========================================================================
     // Test 1: Constructor rejects both owner AND projectId set
     // =========================================================================
     function test_bothOwnerAndProjectId_constructorReverts() public {
-        uint256 projectId = PROJECTS.createFor(alice);
+        uint256 projectId = projects.createFor(alice);
 
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
-        new MockOwnable(PROJECTS, PERMISSIONS, bob, uint88(projectId));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        new MockOwnable(projects, permissions, bob, uint88(projectId));
     }
 
     // =========================================================================
     // Test 2: Renounced contract — protectedMethod always reverts
     // =========================================================================
     function test_renounced_protectedMethodAlwaysReverts() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Owner can call.
         vm.prank(alice);
@@ -82,8 +83,9 @@ contract OwnableAttacks is Test {
     /// @notice After any ownership transfer, permissionId should reset to 0.
     ///         This prevents stale permission delegation.
     function test_permissionIdResetOnTransfer() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Set permission ID.
         vm.prank(alice);
@@ -105,8 +107,9 @@ contract OwnableAttacks is Test {
     // =========================================================================
     /// @notice After transferring project NFT, old owner should lose access.
     function test_staleOwner_afterNFTTransfer() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Alice is current owner.
         assertEq(ownable.owner(), alice);
@@ -115,7 +118,7 @@ contract OwnableAttacks is Test {
 
         // Transfer project NFT to bob.
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
 
         // Alice should no longer be owner.
         assertEq(ownable.owner(), bob, "Bob should be new owner");
@@ -135,7 +138,7 @@ contract OwnableAttacks is Test {
     // =========================================================================
     /// @notice transferOwnershipToProject with projectId > type(uint88).max should revert.
     function test_transferOwnershipToProject_overflowReverts() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // type(uint88).max + 1 = 309485009821345068724781056
         uint256 overflowId = uint256(type(uint88).max) + 1;
@@ -152,11 +155,12 @@ contract OwnableAttacks is Test {
     ///         doesn't grant access to a different project's JBOwnable.
     function test_rootOnWrongProject_noAccess() public {
         // Create two projects.
-        uint256 aliceProject = PROJECTS.createFor(alice);
-        uint256 attackerProject = PROJECTS.createFor(attacker);
+        uint256 aliceProject = projects.createFor(alice);
+        uint256 attackerProject = projects.createFor(attacker);
 
         // Ownable is owned by alice's project.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(aliceProject));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(aliceProject));
 
         // Set permission ID so delegated access is possible.
         vm.prank(alice);
@@ -167,8 +171,9 @@ contract OwnableAttacks is Test {
         rootPerms[0] = 1; // ROOT
 
         vm.prank(attacker);
-        PERMISSIONS.setPermissionsFor(
+        permissions.setPermissionsFor(
             attacker,
+            // forge-lint: disable-next-line(unsafe-typecast)
             JBPermissionsData({operator: attacker, projectId: uint56(attackerProject), permissionIds: rootPerms})
         );
 

package/test/OwnableEdgeCases.t.sol

@@ -1,14 +1,12 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import "forge-std/Test.sol";
+import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "./mocks/MockOwnable.sol";
 import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
-import {JBOwner} from "../src/structs/JBOwner.sol";
 import {IJBOwnable} from "../src/interfaces/IJBOwnable.sol";
 
 import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
-import {JBPermissioned} from "@bananapus/core-v6/src/abstract/JBPermissioned.sol";
 import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
@@ -18,8 +16,8 @@ import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsDat
 /// @notice Edge case and gap tests for JBOwnable: multi-hop NFT transfers,
 ///         project-to-project ownership, permissionId lifecycle, and nonexistent projects.
 contract OwnableEdgeCases is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
     address bob = makeAddr("bob");
@@ -36,32 +34,33 @@ contract OwnableEdgeCases is Test {
     }
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     // =========================================================================
     // Test 1: Multi-hop NFT transfer — ownership follows through A→B→C→D
     // =========================================================================
     function test_multiHopNFTTransfer_ownerFollows() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         assertEq(ownable.owner(), alice);
 
         // Transfer NFT: alice → bob
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
         assertEq(ownable.owner(), bob, "Should follow to bob");
 
         // Transfer NFT: bob → charlie
         vm.prank(bob);
-        PROJECTS.transferFrom(bob, charlie, projectId);
+        projects.transferFrom(bob, charlie, projectId);
         assertEq(ownable.owner(), charlie, "Should follow to charlie");
 
         // Transfer NFT: charlie → dave
         vm.prank(charlie);
-        PROJECTS.transferFrom(charlie, dave, projectId);
+        projects.transferFrom(charlie, dave, projectId);
         assertEq(ownable.owner(), dave, "Should follow to dave");
 
         // dave can call protectedMethod, alice/bob/charlie cannot
@@ -85,10 +84,11 @@ contract OwnableEdgeCases is Test {
     // Test 2: Transfer project → different project
     // =========================================================================
     function test_transferProjectToProject() public {
-        uint256 projectA = PROJECTS.createFor(alice);
-        uint256 projectB = PROJECTS.createFor(bob);
+        uint256 projectA = projects.createFor(alice);
+        uint256 projectB = projects.createFor(bob);
 
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectA));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectA));
         assertEq(ownable.owner(), alice);
 
         // Transfer ownership from project A to project B.
@@ -112,11 +112,11 @@ contract OwnableEdgeCases is Test {
     // Test 3: Full ownership cycle: address → project → address → project
     // =========================================================================
     function test_fullOwnershipCycle() public {
-        uint256 projectA = PROJECTS.createFor(alice);
-        uint256 projectB = PROJECTS.createFor(bob);
+        uint256 projectA = projects.createFor(alice);
+        uint256 projectB = projects.createFor(bob);
 
         // Start with address ownership.
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, charlie, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, charlie, 0);
         assertEq(ownable.owner(), charlie);
 
         // charlie → project A (alice)
@@ -137,6 +137,7 @@ contract OwnableEdgeCases is Test {
         // Verify jbOwner struct is correct (projectId set, owner zeroed).
         (address storedOwner, uint88 storedProjectId, uint8 storedPermId) = ownable.jbOwner();
         assertEq(storedOwner, address(0), "owner field should be zero in project mode");
+        // forge-lint: disable-next-line(unsafe-typecast)
         assertEq(storedProjectId, uint88(projectB), "projectId should be projectB");
         assertEq(storedPermId, 0, "permissionId should be 0");
     }
@@ -145,9 +146,10 @@ contract OwnableEdgeCases is Test {
     // Test 4: permissionId lifecycle through multiple transfers
     // =========================================================================
     function test_permissionIdLifecycle() public {
-        uint256 projectA = PROJECTS.createFor(alice);
+        uint256 projectA = projects.createFor(alice);
 
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectA));
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectA));
 
         // Set permissionId to 42.
         vm.prank(alice);
@@ -192,7 +194,7 @@ contract OwnableEdgeCases is Test {
     function test_nonOwnerCannotSetPermissionId(address nonOwner) public {
         vm.assume(nonOwner != alice && nonOwner != address(0));
 
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.prank(nonOwner);
         vm.expectRevert();
@@ -204,8 +206,8 @@ contract OwnableEdgeCases is Test {
     // =========================================================================
     function test_transferToNonexistentProject_reverts() public {
         // Create one project so count == 1.
-        PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        projects.createFor(alice);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Project 2 doesn't exist.
         vm.prank(alice);
@@ -223,8 +225,9 @@ contract OwnableEdgeCases is Test {
     //         transferred, old delegate loses access
     // =========================================================================
     function test_delegatedAccess_lostAfterNFTTransfer() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Set permissionId so delegation is possible.
         vm.prank(alice);
@@ -234,8 +237,10 @@ contract OwnableEdgeCases is Test {
         uint8[] memory permIds = new uint8[](1);
         permIds[0] = 42;
         vm.prank(alice);
-        PERMISSIONS.setPermissionsFor(
-            alice, JBPermissionsData({operator: charlie, projectId: uint56(projectId), permissionIds: permIds})
+        permissions.setPermissionsFor(
+            // forge-lint: disable-next-line(unsafe-typecast)
+            alice,
+            JBPermissionsData({operator: charlie, projectId: uint56(projectId), permissionIds: permIds})
         );
 
         // Charlie can call protectedMethod (delegated via permissions).
@@ -244,7 +249,7 @@ contract OwnableEdgeCases is Test {
 
         // Transfer NFT to bob.
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
 
         // Charlie's delegation was from alice. Now owner is bob.
         // Charlie should lose access because _checkOwner resolves to bob,
@@ -262,7 +267,7 @@ contract OwnableEdgeCases is Test {
     // Test 8: OwnershipTransferred event emitted correctly
     // =========================================================================
     function test_ownershipTransferredEvent() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Transfer to bob — expect event.
         vm.expectEmit(true, true, false, true);
@@ -276,7 +281,7 @@ contract OwnableEdgeCases is Test {
     // Test 9: PermissionIdChanged event emitted correctly
     // =========================================================================
     function test_permissionIdChangedEvent() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.expectEmit(true, true, false, true);
         emit IJBOwnable.PermissionIdChanged(42, alice);
@@ -291,8 +296,8 @@ contract OwnableEdgeCases is Test {
     function testFuzz_transferToProject(address projectOwner) public isNotContract(projectOwner) {
         vm.assume(projectOwner != address(0));
 
-        uint256 projectId = PROJECTS.createFor(projectOwner);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        uint256 projectId = projects.createFor(projectOwner);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.prank(alice);
         ownable.transferOwnershipToProject(projectId);
@@ -302,6 +307,7 @@ contract OwnableEdgeCases is Test {
         // Verify jbOwner struct.
         (address storedOwner, uint88 storedProjectId,) = ownable.jbOwner();
         assertEq(storedOwner, address(0), "stored owner should be zero");
+        // forge-lint: disable-next-line(unsafe-typecast)
         assertEq(storedProjectId, uint88(projectId), "stored projectId should match");
     }
 
@@ -311,8 +317,8 @@ contract OwnableEdgeCases is Test {
     /// @notice After renouncing, no one can call transferOwnership, transferOwnershipToProject,
     ///         setPermissionId, or renounceOwnership again.
     function test_renouncedContract_cannotReclaim() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        uint256 projectId = projects.createFor(alice);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         vm.prank(alice);
         ownable.renounceOwnership();
@@ -349,7 +355,7 @@ contract OwnableEdgeCases is Test {
     ///         NOT ERC2771Context. This test documents that a trusted forwarder
     ///         appending a sender address to calldata does NOT affect _checkOwner.
     function test_noERC2771_trustedForwarderHasNoEffect() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         // Simulate what a trusted forwarder would do: call with alice's address
         // appended to calldata. Since JBOwnable uses plain Context, this has no effect.

package/test/OwnableInvariantTests.sol

@@ -4,15 +4,6 @@ pragma solidity ^0.8.26;
 import {Test} from "forge-std/Test.sol";
 import {OwnableHandler} from "./handlers/OwnableHandler.sol";
 
-import {MockOwnable} from "./mocks/MockOwnable.sol";
-import {JBOwnableOverrides} from "../src/JBOwnableOverrides.sol";
-import {JBOwner} from "../src/structs/JBOwner.sol";
-import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
-import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
-import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsData.sol";
-import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
-import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
-
 contract OwnableInvariantTests is Test {
     OwnableHandler handler;
 

package/test/handlers/OwnableHandler.sol

@@ -5,12 +5,9 @@ pragma solidity ^0.8.26;
 import {CommonBase} from "forge-std/Base.sol";
 import {StdCheats} from "forge-std/StdCheats.sol";
 import {StdUtils} from "forge-std/StdUtils.sol";
-import {console} from "forge-std/console.sol";
-
-import {MockOwnable, JBOwnableOverrides} from "../mocks/MockOwnable.sol";
+import {MockOwnable} from "../mocks/MockOwnable.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
-import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsData.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
 

package/test/mocks/MockOwnable.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity ^0.8.26;
 
-import {JBOwnable, JBOwnableOverrides} from "../../src/JBOwnable.sol";
+import {JBOwnable} from "../../src/JBOwnable.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 

package/test/regression/{L65_BurnLockProtection.t.sol → BurnLockProtection.t.sol}

@@ -3,7 +3,6 @@ pragma solidity ^0.8.26;
 
 import {Test} from "forge-std/Test.sol";
 import {MockOwnable} from "../mocks/MockOwnable.sol";
-import {JBOwnableOverrides} from "../../src/JBOwnableOverrides.sol";
 
 import {JBPermissions} from "@bananapus/core-v6/src/JBPermissions.sol";
 import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
@@ -11,34 +10,35 @@ import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.s
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 
-/// @title L65_BurnLockProtection
+/// @title BurnLockProtection
 /// @notice Verifies that if a project NFT is burned/invalidated,
 ///         owner() returns address(0) and _checkOwner() reverts gracefully instead of
 ///         permanently locking the contract with an unrecoverable revert.
-contract L65_BurnLockProtection is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+contract BurnLockProtection is Test {
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
     address bob = makeAddr("bob");
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     /// @notice When a project NFT is burned (simulated via mockCallRevert), owner() should
     ///         return address(0) instead of reverting — contract degrades to "renounced" state.
     function test_burnedProjectNFT_ownerReturnsZero() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Verify normal operation first.
         assertEq(ownable.owner(), alice, "Owner should be alice before burn");
 
         // Simulate project NFT burn by making ownerOf revert for this projectId.
         vm.mockCallRevert(
-            address(PROJECTS), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
+            address(projects), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
         );
 
         // After burn, owner() should return address(0) — NOT revert.
@@ -50,8 +50,9 @@ contract L65_BurnLockProtection is Test {
     ///         Unauthorized error (not an unrecoverable ownerOf revert), making the contract
     ///         behave as if ownership was renounced.
     function test_burnedProjectNFT_checkOwnerRevertsGracefully() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         // Alice can call the protected method before burn.
         vm.prank(alice);
@@ -59,7 +60,7 @@ contract L65_BurnLockProtection is Test {
 
         // Simulate project NFT burn.
         vm.mockCallRevert(
-            address(PROJECTS), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
+            address(projects), abi.encodeWithSelector(IERC721.ownerOf.selector, projectId), "ERC721: invalid token ID"
         );
 
         // After burn, nobody can call protected methods — but the revert is graceful
@@ -75,7 +76,7 @@ contract L65_BurnLockProtection is Test {
 
     /// @notice Address-based ownership is unaffected by the try-catch change.
     function test_addressBasedOwnership_unaffectedByTryCatch() public {
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, alice, 0);
+        MockOwnable ownable = new MockOwnable(projects, permissions, alice, 0);
 
         assertEq(ownable.owner(), alice, "Owner should be alice");
 
@@ -93,14 +94,15 @@ contract L65_BurnLockProtection is Test {
 
     /// @notice Normal project-based ownership still works correctly after the fix.
     function test_normalProjectOwnership_stillWorks() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
 
         assertEq(ownable.owner(), alice);
 
         // Transfer project NFT.
         vm.prank(alice);
-        PROJECTS.transferFrom(alice, bob, projectId);
+        projects.transferFrom(alice, bob, projectId);
 
         assertEq(ownable.owner(), bob, "Owner should follow project NFT transfer");
 

package/test/regression/{L66_ZeroAddressValidation.t.sol → ZeroAddressValidation.t.sol}

@@ -10,19 +10,19 @@ import {JBProjects} from "@bananapus/core-v6/src/JBProjects.sol";
 import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
 import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
 
-/// @title L66_ZeroAddressValidation
-/// @notice Verifies that deploying with a zero-address PROJECTS
+/// @title ZeroAddressValidation
+/// @notice Verifies that deploying with a zero-address projects
 ///         contract and a non-zero projectId reverts at construction time, preventing
 ///         permanently broken project-based ownership.
-contract L66_ZeroAddressValidation is Test {
-    IJBProjects PROJECTS;
-    IJBPermissions PERMISSIONS;
+contract ZeroAddressValidation is Test {
+    IJBProjects projects;
+    IJBPermissions permissions;
 
     address alice = makeAddr("alice");
 
     function setUp() public {
-        PERMISSIONS = new JBPermissions(address(0));
-        PROJECTS = new JBProjects(address(123), address(0), address(0));
+        permissions = new JBPermissions(address(0));
+        projects = new JBProjects(address(123), address(0), address(0));
     }
 
     /// @notice Deploying with projects=address(0) and non-zero projectId must revert.
@@ -30,7 +30,7 @@ contract L66_ZeroAddressValidation is Test {
         vm.expectRevert(
             abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_ZeroAddressProjectsWithProjectOwner.selector)
         );
-        new MockOwnable(IJBProjects(address(0)), PERMISSIONS, address(0), uint88(1));
+        new MockOwnable(IJBProjects(address(0)), permissions, address(0), uint88(1));
     }
 
     /// @notice Fuzz: any non-zero projectId with projects=address(0) must revert.
@@ -40,27 +40,28 @@ contract L66_ZeroAddressValidation is Test {
         vm.expectRevert(
             abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_ZeroAddressProjectsWithProjectOwner.selector)
         );
-        new MockOwnable(IJBProjects(address(0)), PERMISSIONS, address(0), projectId);
+        new MockOwnable(IJBProjects(address(0)), permissions, address(0), projectId);
     }
 
     /// @notice Deploying with projects=address(0) and projectId=0 (address-based ownership)
     ///         should NOT revert for this error — it's valid as long as initialOwner != address(0).
     function test_zeroProjectsWithAddressOwnership_succeeds() public {
         // This is valid: address-based ownership with projects=address(0).
-        MockOwnable ownable = new MockOwnable(IJBProjects(address(0)), PERMISSIONS, alice, uint88(0));
+        MockOwnable ownable = new MockOwnable(IJBProjects(address(0)), permissions, alice, uint88(0));
         assertEq(ownable.owner(), alice, "Owner should be alice with address-based ownership");
     }
 
-    /// @notice Normal deployment with valid PROJECTS contract and projectId succeeds.
+    /// @notice Normal deployment with valid projects contract and projectId succeeds.
     function test_validProjectsWithProjectId_succeeds() public {
-        uint256 projectId = PROJECTS.createFor(alice);
-        MockOwnable ownable = new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(projectId));
+        uint256 projectId = projects.createFor(alice);
+        // forge-lint: disable-next-line(unsafe-typecast)
+        MockOwnable ownable = new MockOwnable(projects, permissions, address(0), uint88(projectId));
         assertEq(ownable.owner(), alice, "Owner should be alice via project NFT");
     }
 
     /// @notice The existing check for both zero owner and zero projectId is still enforced.
     function test_bothZero_stillReverts() public {
         vm.expectRevert(abi.encodeWithSelector(JBOwnableOverrides.JBOwnableOverrides_InvalidNewOwner.selector));
-        new MockOwnable(PROJECTS, PERMISSIONS, address(0), uint88(0));
+        new MockOwnable(projects, permissions, address(0), uint88(0));
     }
 }