@bananapus/ownable-v6 0.0.1

package/docs/src/src/interfaces/IJBOwnable.sol/interface.IJBOwnable.md

@@ -0,0 +1,67 @@
+# IJBOwnable
+[Git Source](https://github.com/Bananapus/nana-ownable/blob/a74b3181e75adaf0ee0c93cb00bcc5709ca8f314/src/interfaces/IJBOwnable.sol)
+
+
+## Functions
+### PROJECTS
+
+
+```solidity
+function PROJECTS() external view returns (IJBProjects);
+```
+
+### jbOwner
+
+
+```solidity
+function jbOwner() external view returns (address owner, uint88 projectOwner, uint8 permissionId);
+```
+
+### owner
+
+
+```solidity
+function owner() external view returns (address);
+```
+
+### renounceOwnership
+
+
+```solidity
+function renounceOwnership() external;
+```
+
+### setPermissionId
+
+
+```solidity
+function setPermissionId(uint8 permissionId) external;
+```
+
+### transferOwnership
+
+
+```solidity
+function transferOwnership(address newOwner) external;
+```
+
+### transferOwnershipToProject
+
+
+```solidity
+function transferOwnershipToProject(uint256 projectId) external;
+```
+
+## Events
+### PermissionIdChanged
+
+```solidity
+event PermissionIdChanged(uint8 newId, address caller);
+```
+
+### OwnershipTransferred
+
+```solidity
+event OwnershipTransferred(address indexed previousOwner, address indexed newOwner, address caller);
+```
+

package/docs/src/src/interfaces/README.md

@@ -0,0 +1,4 @@
+
+
+# Contents
+- [IJBOwnable](IJBOwnable.sol/interface.IJBOwnable.md)

package/docs/src/src/structs/JBOwner.sol/struct.JBOwner.md

@@ -0,0 +1,23 @@
+# JBOwner
+[Git Source](https://github.com/Bananapus/nana-ownable/blob/a74b3181e75adaf0ee0c93cb00bcc5709ca8f314/src/struct/JBOwner.sol)
+
+Owner information for a given instance of `JBOwnableOverrides`.
+
+**Notes:**
+- member: owner If `projectId` is 0, this address has owner access.
+
+- member: projectId The owner of the `JBProjects` ERC-721 with this ID has owner access. If this is 0, the
+`owner` address has owner access.
+
+- member: permissionId The permission ID which corresponds to owner access. See `JBPermissions` in `nana-core`
+and `nana-permission-ids`.
+
+
+```solidity
+struct JBOwner {
+    address owner;
+    uint88 projectId;
+    uint8 permissionId;
+}
+```
+

package/docs/src/src/structs/README.md

@@ -0,0 +1,4 @@
+
+
+# Contents
+- [JBOwner](JBOwner.sol/struct.JBOwner.md)

package/foundry.toml

@@ -0,0 +1,12 @@
+[profile.default]
+solc = '0.8.23'
+evm_version = 'paris'                   # Required for L2s (Optimism, Arbitrum, etc.)
+optimizer_runs = 1000000000
+
+[fuzz]
+runs = 4096
+
+[fmt]
+number_underscore = "thousands"
+multiline_func_header = "all"
+wrap_comments = true

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@bananapus/ownable-v6",
+  "version": "0.0.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bananapus/nana-ownable-v6"
+  },
+  "dependencies": {
+    "@bananapus/core-v6": "^0.0.1",
+    "@openzeppelin/contracts": "^5.0.2"
+  },
+  "scripts": {
+    "test": "forge test",
+    "coverage:integration": "forge coverage --match-path \"./src/*.sol\" --report lcov --report summary"
+  }
+}

package/slither-ci.config.json

@@ -0,0 +1,10 @@
+{
+    "detectors_to_exclude": "timestamp,uninitialized-local,naming-convention,solc-version,shadowing-local",
+    "exclude_informational": true,
+    "exclude_low": false,
+    "exclude_medium": false,
+    "exclude_high": false,
+    "disable_color": false,
+    "filter_paths": "(mocks/|test/|node_modules/)",
+    "legacy_ast": false
+}

package/src/JBOwnable.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+// Juicebox variation on OpenZeppelin Ownable
+pragma solidity ^0.8.23;
+
+import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
+
+import {JBOwnableOverrides} from "./JBOwnableOverrides.sol";
+
+/// @notice A function restricted by `JBOwnable` can only be called by a Juicebox project's owner, a specified owner
+/// address (if set), or addresses with permission from the owner.
+/// @dev A function with the `onlyOwner` modifier from `JBOwnable` can only be called by addresses with owner access
+/// based on a `JBOwner` struct:
+/// 1. If `JBOwner.projectId` isn't zero, the address holding the `JBProjects` NFT with the `JBOwner.projectId` ID is
+/// the owner.
+/// 2. If `JBOwner.projectId` is set to `0`, the `JBOwner.owner` address is the owner.
+/// 3. The owner can give other addresses access with `JBPermissions.setPermissionsFor(...)`, using the
+/// `JBOwner.permissionId` permission.
+/// @dev To use `onlyOwner`, inherit this contract and apply the modifier to a function.
+contract JBOwnable is JBOwnableOverrides {
+    //*********************************************************************//
+    // -------------------------- constructor ---------------------------- //
+    //*********************************************************************//
+
+    /// @dev To make a Juicebox project's owner this contract's owner, pass that project's ID as the
+    /// `initialProjectIdOwner`.
+    /// @dev To make a specific address the owner, pass that address as the `initialOwner` and `0` as the
+    /// `initialProjectIdOwner`.
+    /// @dev The owner can give other addresses owner access through the `permissions` contract.
+    /// @param permissions A contract storing permissions.
+    /// @param projects Mints ERC-721s that represent project ownership and transfers.
+    /// @param initialOwner An address with owner access (until ownership is transferred).
+    /// @param initialProjectIdOwner The ID of the Juicebox project whose owner has owner access (until ownership is
+    /// transferred).
+    constructor(
+        IJBPermissions permissions,
+        IJBProjects projects,
+        address initialOwner,
+        uint88 initialProjectIdOwner
+    )
+        JBOwnableOverrides(permissions, projects, initialOwner, initialProjectIdOwner)
+    {}
+
+    //*********************************************************************//
+    // --------------------------- modifiers ----------------------------- //
+    //*********************************************************************//
+
+    /// @notice Reverts if called by an address without owner access.
+    modifier onlyOwner() virtual {
+        _checkOwner();
+        _;
+    }
+
+    //*********************************************************************//
+    // ------------------------ internal functions ----------------------- //
+    //*********************************************************************//
+
+    /// @notice Either `newOwner` or `newProjectId` is non-zero or both are zero. But they can never both be non-zero.
+    /// @dev This function exists because some contracts need to deploy contracts for a project before the project's NFT
+    /// has been minted, so the transfer event resolves the project's current owner at emission time.
+    function _emitTransferEvent(
+        address previousOwner,
+        address newOwner,
+        uint88 newProjectId
+    )
+        internal
+        virtual
+        override
+    {
+        emit OwnershipTransferred({
+            previousOwner: previousOwner,
+            newOwner: newProjectId == 0 ? newOwner : PROJECTS.ownerOf(newProjectId),
+            caller: msg.sender
+        });
+    }
+}

package/src/JBOwnableOverrides.sol

@@ -0,0 +1,203 @@
+// SPDX-License-Identifier: MIT
+// Juicebox variation on OpenZeppelin Ownable
+pragma solidity ^0.8.23;
+
+import {JBPermissioned} from "@bananapus/core-v6/src/abstract/JBPermissioned.sol";
+import {IJBPermissions} from "@bananapus/core-v6/src/interfaces/IJBPermissions.sol";
+import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+import {Context} from "@openzeppelin/contracts/utils/Context.sol";
+
+import {IJBOwnable} from "./interfaces/IJBOwnable.sol";
+import {JBOwner} from "./structs/JBOwner.sol";
+
+/// @notice An abstract base for `JBOwnable`, which restricts functions so they can only be called by a Juicebox
+/// project's owner or a specific owner address. The owner can give access permission to other addresses with
+/// `JBPermissions`.
+abstract contract JBOwnableOverrides is Context, JBPermissioned, IJBOwnable {
+    //*********************************************************************//
+    // --------------------------- custom errors --------------------------//
+    //*********************************************************************//
+
+    error JBOwnableOverrides_InvalidNewOwner();
+    error JBOwnableOverrides_ProjectDoesNotExist();
+
+    //*********************************************************************//
+    // ---------------- public immutable stored properties --------------- //
+    //*********************************************************************//
+
+    /// @notice Mints ERC-721s that represent project ownership and transfers.
+    IJBProjects public immutable override PROJECTS;
+
+    //*********************************************************************//
+    // --------------------- public stored properties -------------------- //
+    //*********************************************************************//
+
+    /// @notice This contract's owner information.
+    JBOwner public override jbOwner;
+
+    //*********************************************************************//
+    // -------------------------- constructor ---------------------------- //
+    //*********************************************************************//
+
+    /// @dev To restrict access to a Juicebox project's owner, pass that project's ID as the `initialProjectIdOwner` and
+    /// the zero address as the `initialOwner`.
+    /// To restrict access to a specific address, pass that address as the `initialOwner` and `0` as the
+    /// `initialProjectIdOwner`.
+    /// @dev The owner can give owner access to other addresses through the `permissions` contract.
+    /// @param permissions A contract storing permissions.
+    /// @param projects Mints ERC-721s that represent project ownership and transfers.
+    /// @param initialOwner The owner if the `initialProjectIdOwner` is 0 (until ownership is transferred).
+    /// @param initialProjectIdOwner The ID of the Juicebox project whose owner is this contract's owner (until
+    /// ownership is transferred).
+    constructor(
+        IJBPermissions permissions,
+        IJBProjects projects,
+        address initialOwner,
+        uint88 initialProjectIdOwner
+    )
+        JBPermissioned(permissions)
+    {
+        PROJECTS = projects;
+
+        // We force the inheriting contract to set an owner, as there is a low chance someone will use `JBOwnable` to
+        // create an unowned contract.
+        // It's more likely both were accidentally set to `0`. If you really want an unowned contract, set the owner to
+        // an address and call `renounceOwnership()` in the constructor body.
+        if (initialProjectIdOwner == 0 && initialOwner == address(0)) {
+            revert JBOwnableOverrides_InvalidNewOwner();
+        }
+
+        _transferOwnership(initialOwner, initialProjectIdOwner);
+    }
+
+    //*********************************************************************//
+    // -------------------------- public views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Returns the owner's address based on this contract's `JBOwner`.
+    function owner() public view virtual returns (address) {
+        JBOwner memory ownerInfo = jbOwner;
+
+        if (ownerInfo.projectId == 0) {
+            return ownerInfo.owner;
+        }
+
+        return PROJECTS.ownerOf(ownerInfo.projectId);
+    }
+
+    //*********************************************************************//
+    // -------------------------- internal views ------------------------- //
+    //*********************************************************************//
+
+    /// @notice Reverts if the sender is not the owner.
+    function _checkOwner() internal view virtual {
+        JBOwner memory ownerInfo = jbOwner;
+
+        _requirePermissionFrom({
+            account: ownerInfo.projectId == 0 ? ownerInfo.owner : PROJECTS.ownerOf(ownerInfo.projectId),
+            projectId: ownerInfo.projectId,
+            permissionId: ownerInfo.permissionId
+        });
+    }
+
+    //*********************************************************************//
+    // ---------------------- public transactions ------------------------ //
+    //*********************************************************************//
+
+    /// @notice Gives up ownership of this contract, making it impossible to call `onlyOwner` and `_checkOwner`
+    /// functions.
+    /// @dev This can only be called by the current owner.
+    function renounceOwnership() public virtual override {
+        _checkOwner();
+        _transferOwnership(address(0), 0);
+    }
+
+    /// @notice Sets the permission ID the owner can use to give other addresses owner access.
+    /// @dev This can only be called by the current owner.
+    /// @param permissionId The permission ID to use for `onlyOwner`.
+    function setPermissionId(uint8 permissionId) public virtual override {
+        _checkOwner();
+        _setPermissionId(permissionId);
+    }
+
+    /// @notice Transfers ownership of this contract to a new address (the `newOwner`). Can only be called by the
+    /// current owner.
+    /// @dev The `permissionId` is reset to 0 on transfer to prevent permission clashes for the new owner.
+    /// The new owner must explicitly call `setPermissionId()` to configure owner-level permission delegation.
+    /// @param newOwner The address to transfer ownership to.
+    function transferOwnership(address newOwner) public virtual override {
+        _checkOwner();
+        if (newOwner == address(0)) {
+            revert JBOwnableOverrides_InvalidNewOwner();
+        }
+
+        _transferOwnership(newOwner, 0);
+    }
+
+    /// @notice Transfer ownership of this contract to a new Juicebox project.
+    /// @dev The `permissionId` is reset to 0 on transfer to prevent permission clashes for the new project owner.
+    /// The new owner must explicitly call `setPermissionId()` to configure owner-level permission delegation.
+    /// @dev The `projectId` must fit within a `uint88`.
+    /// @param projectId The ID of the project to transfer ownership to.
+    function transferOwnershipToProject(uint256 projectId) public virtual override {
+        _checkOwner();
+        if (projectId == 0 || projectId > type(uint88).max) {
+            revert JBOwnableOverrides_InvalidNewOwner();
+        }
+
+        // Make sure the project exists to prevent permanent loss of contract control.
+        if (projectId > PROJECTS.count()) {
+            revert JBOwnableOverrides_ProjectDoesNotExist();
+        }
+
+        _transferOwnership(address(0), uint88(projectId));
+    }
+
+    //*********************************************************************//
+    // ------------------------ internal functions ----------------------- //
+    //*********************************************************************//
+
+    /// @notice Either `newOwner` or `newProjectId` is non-zero or both are zero. But they can never both be non-zero.
+    /// @dev This function exists because some contracts need to deploy contracts for a project before the project's NFT
+    /// has been minted, so the transfer event resolves the project's current owner at emission time.
+    /// @param previousOwner The address of the previous owner.
+    /// @param newOwner The address of the new owner (zero if transferring to a project).
+    /// @param newProjectId The ID of the new owning project (zero if transferring to an address).
+    function _emitTransferEvent(address previousOwner, address newOwner, uint88 newProjectId) internal virtual;
+
+    /// @notice Sets the permission ID the owner can use to give other addresses owner access.
+    /// @dev Internal function without access restriction.
+    /// @param permissionId The permission ID to use for `onlyOwner`.
+    function _setPermissionId(uint8 permissionId) internal virtual {
+        jbOwner.permissionId = permissionId;
+        emit PermissionIdChanged({newId: permissionId, caller: msg.sender});
+    }
+
+    /// @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);
+    }
+
+    /// @notice Transfers this contract's ownership to an address (`newOwner`) OR a Juicebox project (`projectId`).
+    /// @dev Updates this contract's `JBOwner` owner information and resets the `JBOwner.permissionId`.
+    /// @dev If both `newOwner` and `projectId` are set, this will revert.
+    /// @dev Internal function without access restriction.
+    /// @param newOwner The address that should become this contract's owner.
+    /// @param projectId The ID of the project whose owner should become this contract's owner.
+    function _transferOwnership(address newOwner, uint88 projectId) internal virtual {
+        // Can't set both a new owner and a new project ID.
+        if (projectId != 0 && newOwner != address(0)) {
+            revert JBOwnableOverrides_InvalidNewOwner();
+        }
+        // Load the owner information from storage.
+        JBOwner memory ownerInfo = jbOwner;
+        // Get the address of the old owner.
+        address oldOwner = ownerInfo.projectId == 0 ? ownerInfo.owner : PROJECTS.ownerOf(ownerInfo.projectId);
+        // Update the stored owner information to the new owner and reset the `permissionId`.
+        // 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);
+    }
+}

package/src/interfaces/IJBOwnable.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBProjects} from "@bananapus/core-v6/src/interfaces/IJBProjects.sol";
+
+interface IJBOwnable {
+    event PermissionIdChanged(uint8 newId, address caller);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner, address caller);
+
+    /// @notice The contract that mints ERC-721s representing project ownership.
+    /// @return projects The `IJBProjects` contract.
+    function PROJECTS() external view returns (IJBProjects projects);
+
+    /// @notice This contract's owner information.
+    /// @return owner The owner address (used when `projectId` is 0).
+    /// @return projectId The ID of the Juicebox project whose owner is this contract's owner (0 if not project-owned).
+    /// @return permissionId The permission ID the owner can use to grant other addresses owner access.
+    function jbOwner() external view returns (address owner, uint88 projectId, uint8 permissionId);
+
+    /// @notice Returns the current owner's address.
+    /// @return owner The address of the current owner.
+    function owner() external view returns (address owner);
+
+    /// @notice Gives up ownership, making it impossible to call `onlyOwner` functions.
+    function renounceOwnership() external;
+
+    /// @notice Sets the permission ID the owner can use to give other addresses owner access.
+    /// @param permissionId The permission ID to use for `onlyOwner`.
+    function setPermissionId(uint8 permissionId) external;
+
+    /// @notice Transfers ownership of this contract to a new address.
+    /// @param newOwner The address to transfer ownership to.
+    function transferOwnership(address newOwner) external;
+
+    /// @notice Transfers ownership of this contract to a Juicebox project.
+    /// @param projectId The ID of the project to transfer ownership to.
+    function transferOwnershipToProject(uint256 projectId) external;
+}

package/src/structs/JBOwner.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice Owner information for a given instance of `JBOwnableOverrides`.
+/// @custom:member owner If `projectId` is 0, this address has owner access.
+/// @custom:member projectId The owner of the `JBProjects` ERC-721 with this ID has owner access. If this is 0, the
+/// `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`.
+struct JBOwner {
+    address owner;
+    uint88 projectId;
+    uint8 permissionId;
+}