@bananapus/core-v6 0.0.1

package/src/JBPermissions.sol

@@ -0,0 +1,252 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
+import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
+
+import {IJBPermissions} from "./interfaces/IJBPermissions.sol";
+import {JBPermissionsData} from "./structs/JBPermissionsData.sol";
+
+/// @notice Stores permissions for all addresses and operators. Addresses can give permissions to any other address
+/// (i.e. an *operator*) to execute specific operations on their behalf.
+contract JBPermissions is ERC2771Context, IJBPermissions {
+    //*********************************************************************//
+    // --------------------------- custom errors ------------------------- //
+    //*********************************************************************//
+
+    error JBPermissions_CantSetRootPermissionForWildcardProject();
+    error JBPermissions_NoZeroPermission();
+    error JBPermissions_PermissionIdOutOfBounds(uint256 permissionId);
+    error JBPermissions_Unauthorized(address account, address operator, uint256 projectId, uint256 permissionId);
+
+    //*********************************************************************//
+    // ------------------------- public constants ------------------------ //
+    //*********************************************************************//
+
+    /// @notice The project ID considered a wildcard, meaning it will grant permissions to all projects.
+    uint256 public constant override WILDCARD_PROJECT_ID = 0;
+
+    //*********************************************************************//
+    // --------------------- public stored properties -------------------- //
+    //*********************************************************************//
+
+    /// @notice The permissions that an operator has been given by an account for a specific project.
+    /// @dev An account can give an operator permissions that only pertain to a specific project ID.
+    /// @dev There is no project with a ID of 0 – this ID is a wildcard which gives an operator permissions pertaining
+    /// to *all* project IDs on an account's behalf. Use this with caution.
+    /// @dev Permissions are stored in a packed `uint256`. Each of the 256 bits represents the on/off state of a
+    /// permission. Applications can specify the significance of each permission ID.
+    /// @custom:param operator The address of the operator.
+    /// @custom:param account The address of the account being operated on behalf of.
+    /// @custom:param projectId The project ID the permissions are scoped to. An ID of 0 grants permissions across all
+    /// projects.
+    mapping(address operator => mapping(address account => mapping(uint256 projectId => uint256)))
+        public
+        override permissionsOf;
+
+    //*********************************************************************//
+    // ---------------------------- constructor -------------------------- //
+    //*********************************************************************//
+
+    /// @param trustedForwarder The trusted forwarder for the ERC2771Context.
+    constructor(address trustedForwarder) ERC2771Context(trustedForwarder) {}
+
+    //*********************************************************************//
+    // -------------------------- public views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Check if an operator has a specific permission for a specific address and project ID.
+    /// @param operator The operator to check.
+    /// @param account The account being operated on behalf of.
+    /// @param projectId The project ID that the operator has permission to operate under. 0 represents all projects.
+    /// @param permissionId The permission ID to check for.
+    /// @param includeRoot A flag indicating if the return value should default to true if the operator has the ROOT
+    /// permission.
+    /// @param includeWildcardProjectId A flag indicating if the return value should return true if the operator has the
+    /// specified permission on the wildcard project ID.
+    /// @return A flag indicating whether the operator has the specified permission.
+    function hasPermission(
+        address operator,
+        address account,
+        uint256 projectId,
+        uint256 permissionId,
+        bool includeRoot,
+        bool includeWildcardProjectId
+    )
+        public
+        view
+        override
+        returns (bool)
+    {
+        // Indexes above 255 don't exist
+        if (permissionId > 255) revert JBPermissions_PermissionIdOutOfBounds(permissionId);
+
+        // If the ROOT permission is set and should be included, return true.
+        if (
+            includeRoot
+                && (_includesPermission({
+                        permissions: permissionsOf[operator][account][projectId], permissionId: JBPermissionIds.ROOT
+                    })
+                    || (includeWildcardProjectId
+                        && _includesPermission({
+                            permissions: permissionsOf[operator][account][WILDCARD_PROJECT_ID],
+                            permissionId: JBPermissionIds.ROOT
+                        })))
+        ) {
+            return true;
+        }
+
+        // Otherwise return the t/f flag of the specified id.
+        return _includesPermission({
+                permissions: permissionsOf[operator][account][projectId], permissionId: permissionId
+            })
+            || (includeWildcardProjectId
+                && _includesPermission({
+                    permissions: permissionsOf[operator][account][WILDCARD_PROJECT_ID], permissionId: permissionId
+                }));
+    }
+
+    /// @notice Check if an operator has all of the specified permissions for a specific address and project ID.
+    /// @param operator The operator to check.
+    /// @param account The account being operated on behalf of.
+    /// @param projectId The project ID that the operator has permission to operate under. 0 represents all projects.
+    /// @param permissionIds An array of permission IDs to check for.
+    /// @param includeRoot A flag indicating if the return value should default to true if the operator has the ROOT
+    /// permission.
+    /// @param includeWildcardProjectId A flag indicating if the return value should return true if the operator has the
+    /// specified permission on the wildcard project ID.
+    /// @return A flag indicating whether the operator has all specified permissions.
+    function hasPermissions(
+        address operator,
+        address account,
+        uint256 projectId,
+        uint256[] calldata permissionIds,
+        bool includeRoot,
+        bool includeWildcardProjectId
+    )
+        external
+        view
+        override
+        returns (bool)
+    {
+        // If the ROOT permission is set and should be included, return true.
+        if (
+            includeRoot
+                && (_includesPermission({
+                        permissions: permissionsOf[operator][account][projectId], permissionId: JBPermissionIds.ROOT
+                    })
+                    || (includeWildcardProjectId
+                        && _includesPermission({
+                            permissions: permissionsOf[operator][account][WILDCARD_PROJECT_ID],
+                            permissionId: JBPermissionIds.ROOT
+                        })))
+        ) {
+            return true;
+        }
+
+        // Keep a reference to the permission item being checked.
+        uint256 operatorAccountProjectPermissions = permissionsOf[operator][account][projectId];
+
+        // Keep a reference to the wildcard project permissions.
+        uint256 operatorAccountWildcardProjectPermissions =
+            includeWildcardProjectId ? permissionsOf[operator][account][WILDCARD_PROJECT_ID] : 0;
+
+        for (uint256 i; i < permissionIds.length; i++) {
+            // Set the permission being iterated on.
+            uint256 permissionId = permissionIds[i];
+
+            // Indexes above 255 don't exist
+            if (permissionId > 255) revert JBPermissions_PermissionIdOutOfBounds(permissionId);
+
+            // Check each permissionId
+            if (
+                !_includesPermission({permissions: operatorAccountProjectPermissions, permissionId: permissionId})
+                    && !_includesPermission({
+                        permissions: operatorAccountWildcardProjectPermissions, permissionId: permissionId
+                    })
+            ) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //*********************************************************************//
+    // -------------------------- internal views ------------------------- //
+    //*********************************************************************//
+
+    /// @notice Checks if a permission is included in a packed permissions data.
+    /// @param permissions The packed permissions to check.
+    /// @param permissionId The ID of the permission to check for.
+    /// @return A flag indicating whether the permission is included.
+    function _includesPermission(uint256 permissions, uint256 permissionId) internal pure returns (bool) {
+        return ((permissions >> permissionId) & 1) == 1;
+    }
+
+    /// @notice Converts an array of permission IDs to a packed `uint256`.
+    /// @param permissionIds The IDs of the permissions to pack.
+    /// @return packed The packed value.
+    function _packedPermissions(uint8[] calldata permissionIds) internal pure returns (uint256 packed) {
+        for (uint256 i; i < permissionIds.length; i++) {
+            // Set the permission being iterated on.
+            uint256 permissionId = permissionIds[i];
+
+            // Turn on the bit at the ID.
+            packed |= 1 << permissionId;
+        }
+    }
+
+    //*********************************************************************//
+    // ---------------------- external transactions ---------------------- //
+    //*********************************************************************//
+
+    /// @notice Sets permissions for an operator.
+    /// @dev Only an address can give permissions to or revoke permissions from its operators.
+    /// @param account The account setting its operators' permissions.
+    /// @param permissionsData The data which specifies the permissions the operator is being given.
+    function setPermissionsFor(address account, JBPermissionsData calldata permissionsData) external override {
+        // Pack the permission IDs into a uint256.
+        uint256 packed = _packedPermissions(permissionsData.permissionIds);
+
+        // Make sure the 0 permission is not set.
+        if (_includesPermission({permissions: packed, permissionId: 0})) revert JBPermissions_NoZeroPermission();
+
+        // Cache the sender.
+        address msgSender = _msgSender();
+
+        // Enforce permissions. ROOT operators are allowed to set permissions so long as they are not setting another
+        // ROOT permission or setting permissions for a wildcard project ID.
+        if (
+            msgSender != account
+                && (_includesPermission({permissions: packed, permissionId: JBPermissionIds.ROOT})
+                    || permissionsData.projectId == WILDCARD_PROJECT_ID
+                    || !hasPermission({
+                        operator: msgSender,
+                        account: account,
+                        projectId: permissionsData.projectId,
+                        permissionId: JBPermissionIds.ROOT,
+                        includeRoot: true,
+                        includeWildcardProjectId: true
+                    }))
+        ) {
+            revert JBPermissions_Unauthorized({
+                account: account,
+                operator: msgSender,
+                projectId: permissionsData.projectId,
+                permissionId: JBPermissionIds.ROOT
+            });
+        }
+
+        // Store the new value.
+        permissionsOf[permissionsData.operator][account][permissionsData.projectId] = packed;
+
+        emit OperatorPermissionsSet({
+            operator: permissionsData.operator,
+            account: account,
+            projectId: permissionsData.projectId,
+            permissionIds: permissionsData.permissionIds,
+            packed: packed,
+            caller: msgSender
+        });
+    }
+}

package/src/JBPrices.sol

@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {ERC2771Context, Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {mulDiv} from "@prb/math/src/Common.sol";
+
+import {JBControlled} from "./abstract/JBControlled.sol";
+import {JBPermissioned} from "./abstract/JBPermissioned.sol";
+import {IJBDirectory} from "./interfaces/IJBDirectory.sol";
+import {IJBPermissions} from "./interfaces/IJBPermissions.sol";
+import {IJBPriceFeed} from "./interfaces/IJBPriceFeed.sol";
+import {IJBPrices} from "./interfaces/IJBPrices.sol";
+import {IJBProjects} from "./interfaces/IJBProjects.sol";
+
+/// @notice Manages and normalizes price feeds. Price feeds are contracts which return the "pricing currency" cost of 1
+/// "unit currency".
+/// @dev Price feeds are immutable once set and cannot be replaced or removed. If a price feed needs to be changed,
+/// a new JBPrices contract must be deployed and projects must migrate to use it.
+contract JBPrices is JBControlled, JBPermissioned, ERC2771Context, Ownable, IJBPrices {
+    //*********************************************************************//
+    // --------------------------- custom errors ------------------------- //
+    //*********************************************************************//
+
+    error JBPrices_PriceFeedAlreadyExists(IJBPriceFeed feed);
+    error JBPrices_PriceFeedNotFound();
+    error JBPrices_ZeroPricingCurrency();
+    error JBPrices_ZeroUnitCurrency();
+
+    //*********************************************************************//
+    // ------------------------- public constants ------------------------ //
+    //*********************************************************************//
+
+    /// @notice The ID to store default values in.
+    uint256 public constant override DEFAULT_PROJECT_ID = 0;
+
+    //*********************************************************************//
+    // ---------------- public immutable stored properties --------------- //
+    //*********************************************************************//
+
+    /// @notice Mints ERC-721s that represent project ownership and transfers.
+    IJBProjects public immutable override PROJECTS;
+
+    //*********************************************************************//
+    // --------------------- public stored properties -------------------- //
+    //*********************************************************************//
+
+    /// @notice The available price feeds.
+    /// @dev The feed returns the `pricingCurrency` cost for one unit of the `unitCurrency`.
+    /// @custom:param projectId The ID of the project the feed applies to. Feeds stored in ID 0 are used by default for
+    /// all projects.
+    /// @custom:param pricingCurrency The currency the feed's resulting price is in terms of.
+    /// @custom:param unitCurrency The currency being priced by the feed.
+    mapping(uint256 projectId => mapping(uint256 pricingCurrency => mapping(uint256 unitCurrency => IJBPriceFeed)))
+        public
+        override priceFeedFor;
+
+    //*********************************************************************//
+    // ---------------------------- constructor -------------------------- //
+    //*********************************************************************//
+
+    /// @param directory A contract storing directories of terminals and controllers for each project.
+    /// @param permissions A contract storing permissions.
+    /// @param projects A contract which mints ERC-721s that represent project ownership and transfers.
+    /// @param owner The address that will own the contract.
+    /// @param trustedForwarder The trusted forwarder for the ERC2771Context.
+    constructor(
+        IJBDirectory directory,
+        IJBPermissions permissions,
+        IJBProjects projects,
+        address owner,
+        address trustedForwarder
+    )
+        JBControlled(directory)
+        JBPermissioned(permissions)
+        Ownable(owner)
+        ERC2771Context(trustedForwarder)
+    {
+        PROJECTS = projects;
+    }
+
+    //*********************************************************************//
+    // -------------------------- public views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Gets the `pricingCurrency` cost for one unit of the `unitCurrency`.
+    /// @param projectId The ID of the project to check the feed for. Feeds stored in ID 0 are used by default for all
+    /// projects.
+    /// @param pricingCurrency The currency the feed's resulting price is in terms of.
+    /// @param unitCurrency The currency being priced by the feed.
+    /// @param decimals The number of decimals the returned fixed point price should include.
+    /// @return The `pricingCurrency` price of 1 `unitCurrency`, as a fixed point number with the specified number of
+    /// decimals.
+    function pricePerUnitOf(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        uint256 decimals
+    )
+        public
+        view
+        override
+        returns (uint256)
+    {
+        // If the `pricingCurrency` is the `unitCurrency`, return 1 since they have the same price. Include the
+        // desired number of decimals.
+        if (pricingCurrency == unitCurrency) return 10 ** decimals;
+
+        // Get a reference to the price feed.
+        IJBPriceFeed feed = priceFeedFor[projectId][pricingCurrency][unitCurrency];
+
+        // If the feed exists, return its price.
+        if (feed != IJBPriceFeed(address(0))) return feed.currentUnitPrice(decimals);
+
+        // Try getting the inverse feed.
+        feed = priceFeedFor[projectId][unitCurrency][pricingCurrency];
+
+        // If it exists, return the inverse of its price.
+        // @dev The inverse calculation `(10^d * 10^d) / price` has acceptable precision when the feed price
+        // is in the range of ~1e9 to ~1e27 (for 18 decimals). Extreme prices outside this range may lose
+        // significant precision due to fixed-point division truncation.
+        if (feed != IJBPriceFeed(address(0))) {
+            return mulDiv(10 ** decimals, 10 ** decimals, feed.currentUnitPrice(decimals));
+        }
+
+        // Check for a default feed (project ID 0) if not found.
+        if (projectId != DEFAULT_PROJECT_ID) {
+            return pricePerUnitOf({
+                projectId: DEFAULT_PROJECT_ID,
+                pricingCurrency: pricingCurrency,
+                unitCurrency: unitCurrency,
+                decimals: decimals
+            });
+        }
+
+        // No price feed available, revert.
+        revert JBPrices_PriceFeedNotFound();
+    }
+
+    //*********************************************************************//
+    // -------------------------- internal views ------------------------- //
+    //*********************************************************************//
+
+    /// @dev `ERC-2771` specifies the context as being a single address (20 bytes).
+    function _contextSuffixLength() internal view override(ERC2771Context, Context) returns (uint256) {
+        return super._contextSuffixLength();
+    }
+
+    /// @notice The calldata. Preferred to use over `msg.data`.
+    /// @return calldata The `msg.data` of this call.
+    function _msgData() internal view override(ERC2771Context, Context) returns (bytes calldata) {
+        return ERC2771Context._msgData();
+    }
+
+    /// @notice The message's sender. Preferred to use over `msg.sender`.
+    /// @return sender The address which sent this call.
+    function _msgSender() internal view override(ERC2771Context, Context) returns (address sender) {
+        return ERC2771Context._msgSender();
+    }
+
+    //*********************************************************************//
+    // ---------------------- external transactions ---------------------- //
+    //*********************************************************************//
+
+    /// @notice Add a price feed for the `unitCurrency`, priced in terms of the `pricingCurrency`.
+    /// @dev Price feeds can only be added, not modified or removed. Once a feed is set for a currency pair (in either
+    /// direction), it is permanent for that project ID. Recovery from a misconfigured feed requires deploying a new
+    /// JBPrices contract.
+    /// @dev This contract's owner can add protocol-wide default price feed by passing a `projectId` of 0.
+    /// @param projectId The ID of the project to add a feed for. If `projectId` is 0, add a protocol-wide default price
+    /// feed.
+    /// @param pricingCurrency The currency the feed's output price is in terms of.
+    /// @param unitCurrency The currency being priced by the feed.
+    /// @param feed The address of the price feed to add.
+    function addPriceFeedFor(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        IJBPriceFeed feed
+    )
+        external
+        override
+    {
+        // Ensure default price feeds can only be set by this contract's owner, and that other `projectId`s can only be
+        // set by the controller
+        projectId == DEFAULT_PROJECT_ID ? _checkOwner() : _onlyControllerOf(projectId);
+
+        // Make sure the pricing currency isn't 0.
+        if (pricingCurrency == 0) revert JBPrices_ZeroPricingCurrency();
+
+        // Make sure the unit currency isn't 0.
+        if (unitCurrency == 0) revert JBPrices_ZeroUnitCurrency();
+
+        // Make sure there isn't already a default price feed for the pair or its inverse.
+        if (
+            priceFeedFor[DEFAULT_PROJECT_ID][pricingCurrency][unitCurrency] != IJBPriceFeed(address(0))
+                || priceFeedFor[DEFAULT_PROJECT_ID][unitCurrency][pricingCurrency] != IJBPriceFeed(address(0))
+        ) {
+            revert JBPrices_PriceFeedAlreadyExists(priceFeedFor[DEFAULT_PROJECT_ID][pricingCurrency][unitCurrency]
+                    != IJBPriceFeed(address(0))
+                    ? priceFeedFor[DEFAULT_PROJECT_ID][pricingCurrency][unitCurrency]
+                    : priceFeedFor[DEFAULT_PROJECT_ID][unitCurrency][pricingCurrency]);
+        }
+
+        // Make sure this project doesn't already have a price feed for the pair or its inverse.
+        if (
+            priceFeedFor[projectId][pricingCurrency][unitCurrency] != IJBPriceFeed(address(0))
+                || priceFeedFor[projectId][unitCurrency][pricingCurrency] != IJBPriceFeed(address(0))
+        ) {
+            revert JBPrices_PriceFeedAlreadyExists(priceFeedFor[projectId][pricingCurrency][unitCurrency]
+                    != IJBPriceFeed(address(0))
+                    ? priceFeedFor[projectId][pricingCurrency][unitCurrency]
+                    : priceFeedFor[projectId][unitCurrency][pricingCurrency]);
+        }
+
+        // Store the feed.
+        priceFeedFor[projectId][pricingCurrency][unitCurrency] = feed;
+
+        emit AddPriceFeed({
+            projectId: projectId,
+            pricingCurrency: pricingCurrency,
+            unitCurrency: unitCurrency,
+            feed: feed,
+            caller: _msgSender()
+        });
+    }
+}

package/src/JBProjects.sol

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ERC2771Context} from "@openzeppelin/contracts/metatx/ERC2771Context.sol";
+import {ERC721, Context} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {IJBProjects} from "./interfaces/IJBProjects.sol";
+import {IJBTokenUriResolver} from "./interfaces/IJBTokenUriResolver.sol";
+
+/// @notice Stores project ownership and metadata.
+/// @dev Projects are represented as ERC-721s.
+contract JBProjects is ERC721, ERC2771Context, Ownable, IJBProjects {
+    //*********************************************************************//
+    // --------------------- public stored properties -------------------- //
+    //*********************************************************************//
+
+    /// @notice The number of projects that have been created using this contract.
+    /// @dev The count is incremented with each new project created.
+    /// @dev The resulting ERC-721 token ID for each project is the newly incremented count value.
+    uint256 public override count;
+
+    /// @notice The contract resolving each project ID to its ERC721 URI.
+    IJBTokenUriResolver public override tokenUriResolver;
+
+    //*********************************************************************//
+    // -------------------------- constructor ---------------------------- //
+    //*********************************************************************//
+
+    /// @param owner The owner of the contract who can set metadata.
+    /// @param feeProjectOwner The address that will receive the fee-project. If `address(0)` the fee-project will not
+    /// be minted.
+    /// @param trustedForwarder The trusted forwarder for the ERC2771Context.
+    constructor(
+        address owner,
+        address feeProjectOwner,
+        address trustedForwarder
+    )
+        ERC721("Juicebox Projects", "JUICEBOX")
+        Ownable(owner)
+        ERC2771Context(trustedForwarder)
+    {
+        if (feeProjectOwner != address(0)) {
+            createFor(feeProjectOwner);
+        }
+    }
+
+    //*********************************************************************//
+    // -------------------------- public views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Indicates whether this contract adheres to the specified interface.
+    /// @dev See {IERC165-supportsInterface}.
+    /// @param interfaceId The ID of the interface to check for adherence to.
+    /// @return A flag indicating if the provided interface ID is supported.
+    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
+        return interfaceId == type(IJBProjects).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    /// @notice Returns the URI where the ERC-721 standard JSON of a project is hosted.
+    /// @param projectId The ID of the project to get a URI of.
+    /// @return The token URI to use for the provided `projectId`.
+    function tokenURI(uint256 projectId) public view override returns (string memory) {
+        // Keep a reference to the resolver.
+        IJBTokenUriResolver resolver = tokenUriResolver;
+
+        // If there's no resolver, there's no URI.
+        if (resolver == IJBTokenUriResolver(address(0))) return "";
+
+        // Return the resolved URI.
+        return resolver.getUri(projectId);
+    }
+
+    //*********************************************************************//
+    // -------------------------- internal views ------------------------- //
+    //*********************************************************************//
+
+    /// @dev `ERC-2771` specifies the context as being a single address (20 bytes).
+    function _contextSuffixLength() internal view override(ERC2771Context, Context) returns (uint256) {
+        return super._contextSuffixLength();
+    }
+
+    /// @notice The calldata. Preferred to use over `msg.data`.
+    /// @return calldata The `msg.data` of this call.
+    function _msgData() internal view override(ERC2771Context, Context) returns (bytes calldata) {
+        return ERC2771Context._msgData();
+    }
+
+    /// @notice The message's sender. Preferred to use over `msg.sender`.
+    /// @return sender The address which sent this call.
+    function _msgSender() internal view override(ERC2771Context, Context) returns (address sender) {
+        return ERC2771Context._msgSender();
+    }
+
+    //*********************************************************************//
+    // ---------------------- external transactions ---------------------- //
+    //*********************************************************************//
+
+    /// @notice Sets the address of the resolver used to retrieve the tokenURI of projects.
+    /// @param resolver The address of the new resolver.
+    function setTokenUriResolver(IJBTokenUriResolver resolver) external override onlyOwner {
+        // Store the new resolver.
+        tokenUriResolver = resolver;
+
+        emit SetTokenUriResolver({resolver: resolver, caller: _msgSender()});
+    }
+
+    //*********************************************************************//
+    // ---------------------- public transactions ---------------------- //
+    //*********************************************************************//
+
+    /// @notice Create a new project for the specified owner, which mints an NFT (ERC-721) into their wallet.
+    /// @dev Anyone can create a project on an owner's behalf.
+    /// @param owner The address that will be the owner of the project.
+    /// @return projectId The token ID of the newly created project.
+    function createFor(address owner) public override returns (uint256 projectId) {
+        // Increment the count, which will be used as the ID.
+        projectId = ++count;
+
+        emit Create({projectId: projectId, owner: owner, caller: _msgSender()});
+
+        // Mint the project.
+        _safeMint(owner, projectId);
+    }
+}