@bananapus/core-v6 0.0.1

package/src/JBDeadline.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {JBRuleset} from "./structs/JBRuleset.sol";
+import {JBApprovalStatus} from "./enums/JBApprovalStatus.sol";
+import {IJBRulesetApprovalHook} from "./interfaces/IJBRulesetApprovalHook.sol";
+
+/// @notice `JBDeadline` is a ruleset approval hook which rejects rulesets if they are not queued at least `duration`
+/// seconds before the current ruleset ends. In other words, rulesets must be queued before the deadline to take effect.
+/// @dev Project rulesets are stored in a queue. Rulesets take effect after the previous ruleset in the queue ends, and
+/// only if they are approved by the previous ruleset's approval hook.
+contract JBDeadline is IJBRulesetApprovalHook {
+    //*********************************************************************//
+    // ---------------- public immutable stored properties --------------- //
+    //*********************************************************************//
+
+    /// @notice The minimum number of seconds between the time a ruleset is queued and the time it starts. If the
+    /// difference is greater than this number, the ruleset is `Approved`.
+    uint256 public immutable override DURATION;
+
+    //*********************************************************************//
+    // -------------------------- constructor ---------------------------- //
+    //*********************************************************************//
+
+    /// @param duration The minimum number of seconds between the time a ruleset is queued and the time it starts for it
+    /// to be `Approved`.
+    constructor(uint256 duration) {
+        DURATION = duration;
+    }
+
+    //*********************************************************************//
+    // -------------------------- public views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice The approval status of a given ruleset.
+    /// @param ruleset ruleset to check the status of.
+    /// @return The ruleset's approval status.
+    function approvalStatusOf(
+        uint256, /* projectId */
+        JBRuleset memory ruleset
+    )
+        public
+        view
+        override
+        returns (JBApprovalStatus)
+    {
+        // The ruleset ID is the timestamp at which the ruleset was queued.
+        // If the provided `rulesetId` timestamp is after the start timestamp, the ruleset has `Failed`.
+        if (ruleset.id > ruleset.start) return JBApprovalStatus.Failed;
+
+        unchecked {
+            // If there aren't enough seconds between the time the ruleset was queued and the time it starts, it has
+            // `Failed`.
+            // Otherwise, if there is still time before the deadline, the ruleset's status is `ApprovalExpected`.
+            // If we've already passed the deadline, the ruleset is `Approved`.
+            return (ruleset.start - ruleset.id < DURATION)
+                ? JBApprovalStatus.Failed
+                : (block.timestamp + DURATION < ruleset.start)
+                    ? JBApprovalStatus.ApprovalExpected
+                    : JBApprovalStatus.Approved;
+        }
+    }
+
+    /// @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 this contract adheres to the specified interface.
+    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+        return interfaceId == type(IJBRulesetApprovalHook).interfaceId || interfaceId == type(IERC165).interfaceId;
+    }
+}

package/src/JBDirectory.sol

@@ -0,0 +1,343 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {JBPermissionIds} from "@bananapus/permission-ids-v6/src/JBPermissionIds.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {JBPermissioned} from "./abstract/JBPermissioned.sol";
+import {IJBDirectory} from "./interfaces/IJBDirectory.sol";
+import {IJBDirectoryAccessControl} from "./interfaces/IJBDirectoryAccessControl.sol";
+import {IJBMigratable} from "./interfaces/IJBMigratable.sol";
+import {IJBPermissions} from "./interfaces/IJBPermissions.sol";
+import {IJBProjects} from "./interfaces/IJBProjects.sol";
+import {IJBTerminal} from "./interfaces/IJBTerminal.sol";
+
+/// @notice `JBDirectory` tracks the terminals and the controller used by each project.
+/// @dev Tracks which `IJBTerminal`s each project is currently accepting funds through, and which `IJBController` is
+/// managing each project's tokens and rulesets.
+contract JBDirectory is JBPermissioned, Ownable, IJBDirectory {
+    //*********************************************************************//
+    // --------------------------- custom errors ------------------------- //
+    //*********************************************************************//
+
+    error JBDirectory_DuplicateTerminals(IJBTerminal terminal);
+    error JBDirectory_InvalidProjectIdInDirectory(uint256 projectId, uint256 limit);
+    error JBDirectory_SetControllerNotAllowed(uint256 projectId);
+    error JBDirectory_SetTerminalsNotAllowed(uint256 projectId);
+    error JBDirectory_TokenNotAccepted(uint256 projectId, address token, IJBTerminal terminal);
+
+    //*********************************************************************//
+    // ---------------- public immutable stored properties --------------- //
+    //*********************************************************************//
+
+    /// @notice Mints ERC-721s that represent project ownership and transfers.
+    IJBProjects public immutable override PROJECTS;
+
+    //*********************************************************************//
+    // --------------------- public stored properties -------------------- //
+    //*********************************************************************//
+
+    /// @notice The specified project's controller, which dictates how its terminals interact with its tokens and
+    /// rulesets.
+    /// @custom:param projectId The ID of the project to get the controller of.
+    mapping(uint256 projectId => IERC165) public override controllerOf;
+
+    /// @notice Whether the specified address is allowed to set a project's first controller on their behalf.
+    /// @dev These addresses/contracts have been vetted by this contract's owner.
+    /// @custom:param addr The address to check.
+    mapping(address addr => bool) public override isAllowedToSetFirstController;
+
+    //*********************************************************************//
+    // --------------------- internal stored properties ------------------ //
+    //*********************************************************************//
+
+    /// @notice The primary terminal that a project uses for the specified token.
+    /// @custom:param projectId The ID of the project to get the primary terminal of.
+    /// @custom:param token The token that the terminal accepts.
+    mapping(uint256 projectId => mapping(address token => IJBTerminal)) internal _primaryTerminalOf;
+
+    /// @notice The specified project's terminals.
+    /// @custom:param projectId The ID of the project to get the terminals of.
+    mapping(uint256 projectId => IJBTerminal[]) internal _terminalsOf;
+
+    //*********************************************************************//
+    // -------------------------- constructor ---------------------------- //
+    //*********************************************************************//
+
+    /// @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.
+    constructor(
+        IJBPermissions permissions,
+        IJBProjects projects,
+        address owner
+    )
+        JBPermissioned(permissions)
+        Ownable(owner)
+    {
+        PROJECTS = projects;
+    }
+
+    //*********************************************************************//
+    // ------------------------- external views -------------------------- //
+    //*********************************************************************//
+
+    /// @notice The primary terminal that a project uses for the specified token.
+    /// @dev Returns the first terminal that accepts the token if the project hasn't explicitly set a primary terminal
+    /// for it.
+    /// @dev Returns the zero address if no terminal accepts the token.
+    /// @param projectId The ID of the project to get the primary terminal of.
+    /// @param token The token that the terminal accepts.
+    /// @return The primary terminal's address.
+    function primaryTerminalOf(uint256 projectId, address token) external view override returns (IJBTerminal) {
+        // Keep a reference to the primary terminal for the provided project ID and token.
+        IJBTerminal primaryTerminal = _primaryTerminalOf[projectId][token];
+
+        // If a primary terminal for the token was explicitly set and it's one of the project's terminals, return it.
+        if (
+            primaryTerminal != IJBTerminal(address(0))
+                && isTerminalOf({projectId: projectId, terminal: primaryTerminal})
+        ) {
+            return primaryTerminal;
+        }
+
+        // Keep a reference to the project's terminals.
+        IJBTerminal[] memory terminals = _terminalsOf[projectId];
+
+        // Keep a reference to the number of terminals the project has.
+        uint256 numberOfTerminals = terminals.length;
+
+        // Return the first terminal which accepts the specified token.
+        for (uint256 i; i < numberOfTerminals; i++) {
+            // Keep a reference to the terminal being iterated on.
+            IJBTerminal terminal = terminals[i];
+
+            // If the terminal accepts the specified token, return it.
+            // slither-disable-next-line calls-loop
+            if (terminal.accountingContextForTokenOf({projectId: projectId, token: token}).token != address(0)) {
+                return terminal;
+            }
+        }
+
+        // Not found.
+        return IJBTerminal(address(0));
+    }
+
+    /// @notice The specified project's terminals.
+    /// @param projectId The ID of the project to get the terminals of.
+    /// @return An array of the project's terminal addresses.
+    function terminalsOf(uint256 projectId) external view override returns (IJBTerminal[] memory) {
+        return _terminalsOf[projectId];
+    }
+
+    //*********************************************************************//
+    // -------------------------- public views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice Check if a project uses a specific terminal.
+    /// @param projectId The ID of the project to check.
+    /// @param terminal The terminal to check for.
+    /// @return A flag indicating whether the project uses the terminal.
+    function isTerminalOf(uint256 projectId, IJBTerminal terminal) public view override returns (bool) {
+        // Keep a reference to the project's terminals.
+        IJBTerminal[] memory terminals = _terminalsOf[projectId];
+
+        // Keep a reference to the number of terminals the project has.
+        uint256 numberOfTerminals = terminals.length;
+
+        // Loop through and return true if the terminal is found.
+        for (uint256 i; i < numberOfTerminals; i++) {
+            if (terminals[i] == terminal) return true;
+        }
+
+        // Otherwise, return false.
+        return false;
+    }
+
+    //*********************************************************************//
+    // ---------------------- external transactions ---------------------- //
+    //*********************************************************************//
+
+    /// @notice Add or remove an address/contract from a list of trusted addresses which are allowed to set a first
+    /// controller for projects.
+    /// @dev Only this contract's owner can call this function.
+    /// @dev These addresses are vetted controllers as well as contracts designed to launch new projects.
+    /// @dev A project can set its own controller without being on this list.
+    /// @dev If you would like to add an address/contract to this list, please reach out to this contract's owner.
+    /// @param addr The address to allow or not allow.
+    /// @param flag Whether the address is allowed to set first controllers for projects. Use `true` to allow and
+    /// `false` to not allow.
+    function setIsAllowedToSetFirstController(address addr, bool flag) external override onlyOwner {
+        // Set the flag in the allowlist.
+        isAllowedToSetFirstController[addr] = flag;
+
+        emit SetIsAllowedToSetFirstController({addr: addr, isAllowed: flag, caller: msg.sender});
+    }
+
+    /// @notice Set a project's controller. Controllers manage how terminals interact with tokens and rulesets.
+    /// @dev Can only be called if:
+    /// - The ruleset's metadata has `allowSetController` enabled, and the message's sender is the project's owner or an
+    /// address with the owner's permission to `SET_CONTROLLER`.
+    /// - OR the message's sender is the project's current controller.
+    /// - OR an address which `isAllowedToSetFirstController` is setting a project's first controller.
+    /// @param projectId The ID of the project whose controller is being set.
+    /// @param controller The address of the controller to set.
+    function setControllerOf(uint256 projectId, IERC165 controller) external override {
+        // Keep a reference to the current controller.
+        IERC165 currentController = controllerOf[projectId];
+
+        // Enforce permissions.
+        _requirePermissionAllowingOverrideFrom({
+            account: PROJECTS.ownerOf(projectId),
+            projectId: projectId,
+            permissionId: JBPermissionIds.SET_CONTROLLER,
+            alsoGrantAccessIf: (isAllowedToSetFirstController[msg.sender] && address(currentController) == address(0))
+        });
+
+        // The project must exist.
+        if (projectId > PROJECTS.count()) revert JBDirectory_InvalidProjectIdInDirectory(projectId, PROJECTS.count());
+
+        // Get a reference to a flag indicating whether the project is allowed to set its controller.
+        // Setting the controller is allowed if the project doesn't have a controller,
+        // OR if the caller is the current controller,
+        // OR if the project's ruleset allows setting the controller.
+        bool allowSetController = address(currentController) == address(0)
+            || !currentController.supportsInterface(type(IJBDirectoryAccessControl).interfaceId)
+            ? true
+            : IJBDirectoryAccessControl(address(currentController)).setControllerAllowed(projectId);
+
+        // If setting the controller is not allowed, revert.
+        if (!allowSetController) {
+            revert JBDirectory_SetControllerNotAllowed(projectId);
+        }
+
+        // Prepare the new controller to receive the project.
+        if (address(currentController) != address(0) && controller.supportsInterface(type(IJBMigratable).interfaceId)) {
+            IJBMigratable(address(controller))
+                .beforeReceiveMigrationFrom({from: currentController, projectId: projectId});
+        }
+
+        // Migrate if needed. The old controller's migrate() runs while the directory still points to it,
+        // closing the reentrancy window where the directory would point to the new controller during migration.
+        if (
+            address(currentController) != address(0)
+                && currentController.supportsInterface(type(IJBMigratable).interfaceId)
+        ) {
+            IJBMigratable(address(currentController)).migrate({projectId: projectId, to: controller});
+        }
+
+        // Set the new controller after migration completes.
+        // slither-disable-next-line reentrancy-no-eth
+        controllerOf[projectId] = controller;
+
+        emit SetController({projectId: projectId, controller: controller, caller: msg.sender});
+
+        // Notify the new controller that migration is complete and it is now the active controller.
+        if (address(currentController) != address(0) && controller.supportsInterface(type(IJBMigratable).interfaceId)) {
+            IJBMigratable(address(controller))
+                .afterReceiveMigrationFrom({from: currentController, projectId: projectId});
+        }
+    }
+
+    /// @notice Set a project's primary terminal for a token.
+    /// @dev The primary terminal for a token is where payments in that token are routed to by default.
+    /// @dev This is useful in cases where a project has multiple terminals which accept the same token.
+    /// @dev Can only be called by the project's owner, or an address with the owner's permission to
+    /// `SET_PRIMARY_TERMINAL`.
+    /// @param projectId The ID of the project whose primary terminal is being set.
+    /// @param token The token to set the primary terminal for.
+    /// @param terminal The terminal being set as the primary terminal.
+    function setPrimaryTerminalOf(uint256 projectId, address token, IJBTerminal terminal) external override {
+        // Enforce permissions.
+        _requirePermissionFrom({
+            account: PROJECTS.ownerOf(projectId),
+            projectId: projectId,
+            permissionId: JBPermissionIds.SET_PRIMARY_TERMINAL
+        });
+
+        // If the terminal doesn't accept the token, revert.
+        if (terminal.accountingContextForTokenOf({projectId: projectId, token: token}).token == address(0)) {
+            revert JBDirectory_TokenNotAccepted(projectId, token, terminal);
+        }
+
+        // If the terminal hasn't already been added to the project, add it.
+        _addTerminalIfNeeded({projectId: projectId, terminal: terminal});
+
+        // Store the terminal as the project's primary terminal for the token.
+        _primaryTerminalOf[projectId][token] = terminal;
+
+        emit SetPrimaryTerminal({projectId: projectId, token: token, terminal: terminal, caller: msg.sender});
+    }
+
+    /// @notice Set a project's terminals.
+    /// @dev Can only be called by the project's owner, an address with the owner's permission to `SET_TERMINALS`, or
+    /// the project's controller.
+    /// @dev Unless the caller is the project's controller, the project's ruleset must allow setting terminals.
+    /// @param projectId The ID of the project whose terminals are being set.
+    /// @param terminals An array of terminal addresses to set for the project.
+    function setTerminalsOf(uint256 projectId, IJBTerminal[] calldata terminals) external override {
+        // Enforce permissions.
+        _requirePermissionAllowingOverrideFrom({
+            account: PROJECTS.ownerOf(projectId),
+            projectId: projectId,
+            permissionId: JBPermissionIds.SET_TERMINALS,
+            alsoGrantAccessIf: msg.sender == address(controllerOf[projectId])
+        });
+
+        // Keep a reference to the project's controller.
+        IERC165 controller = controllerOf[projectId];
+
+        // Get a reference to the flag indicating whether the project is allowed to set its terminals.
+        bool allowSetTerminals = !controller.supportsInterface(type(IJBDirectoryAccessControl).interfaceId)
+            || IJBDirectoryAccessControl(address(controller)).setTerminalsAllowed(projectId);
+
+        // If the caller is not the project's controller, the project's ruleset must allow setting terminals.
+        if (msg.sender != address(controllerOf[projectId]) && !allowSetTerminals) {
+            revert JBDirectory_SetTerminalsNotAllowed(projectId);
+        }
+
+        // Set the stored terminals for the project.
+        _terminalsOf[projectId] = terminals;
+
+        // If there are any duplicates, revert.
+        if (terminals.length > 1) {
+            for (uint256 i; i < terminals.length; i++) {
+                for (uint256 j = i + 1; j < terminals.length; j++) {
+                    if (terminals[i] == terminals[j]) revert JBDirectory_DuplicateTerminals(terminals[i]);
+                }
+            }
+        }
+        emit SetTerminals({projectId: projectId, terminals: terminals, caller: msg.sender});
+    }
+
+    //*********************************************************************//
+    // ------------------------ internal functions ----------------------- //
+    //*********************************************************************//
+
+    /// @notice If a terminal hasn't already been added to a project's list of terminals, add it.
+    /// @dev The project's ruleset must have `allowSetTerminals` set to `true`.
+    /// @param projectId The ID of the project to add the terminal to.
+    /// @param terminal The terminal to add.
+    function _addTerminalIfNeeded(uint256 projectId, IJBTerminal terminal) internal {
+        // Ensure that the terminal has not already been added.
+        if (isTerminalOf({projectId: projectId, terminal: terminal})) return;
+
+        // Keep a reference to the current controller.
+        IERC165 controller = controllerOf[projectId];
+
+        // Get a reference to a flag indicating whether the project is allowed to set its terminals.
+        bool allowSetTerminals = !controller.supportsInterface(type(IJBDirectoryAccessControl).interfaceId)
+            || IJBDirectoryAccessControl(address(controller)).setTerminalsAllowed(projectId);
+
+        // The project's ruleset must allow setting terminals.
+        if (!allowSetTerminals) {
+            revert JBDirectory_SetTerminalsNotAllowed(projectId);
+        }
+
+        // Add the new terminal.
+        _terminalsOf[projectId].push(terminal);
+
+        emit AddTerminal({projectId: projectId, terminal: terminal, caller: msg.sender});
+    }
+}

package/src/JBERC20.sol

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC20Permit, Nonces} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";
+import {ERC20Votes} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol";
+import {Nonces} from "@openzeppelin/contracts/utils/Nonces.sol";
+
+import {IJBToken} from "./interfaces/IJBToken.sol";
+
+/// @notice An ERC-20 token that can be used by a project in `JBTokens` and `JBController`.
+/// @dev By default, a project uses "credits" to track balances. Once a project sets their `IJBToken` using
+/// `JBController.deployERC20For(...)` or `JBController.setTokenFor(...)`, credits can be redeemed to claim tokens.
+/// @dev `JBController.deployERC20For(...)` deploys a `JBERC20` contract and sets it as the project's token.
+contract JBERC20 is ERC20Votes, ERC20Permit, Ownable, IJBToken {
+    //*********************************************************************//
+    // --------------------------- custom errors ------------------------- //
+    //*********************************************************************//
+
+    error JBERC20_AlreadyInitialized();
+
+    //*********************************************************************//
+    // --------------------- internal stored properties ------------------ //
+    //*********************************************************************//
+
+    /// @notice The token's name.
+    // slither-disable-next-line shadowing-state
+    string private _name;
+
+    /// @notice The token's symbol.
+    // slither-disable-next-line shadowing-state
+    string private _symbol;
+
+    //*********************************************************************//
+    // -------------------------- constructor ---------------------------- //
+    //*********************************************************************//
+
+    constructor() Ownable(address(this)) ERC20("invalid", "invalid") ERC20Permit("JBToken") {}
+
+    //*********************************************************************//
+    // -------------------------- public views --------------------------- //
+    //*********************************************************************//
+
+    /// @notice The balance of the given address.
+    /// @param account The account to get the balance of.
+    /// @return The number of tokens owned by the `account`, as a fixed point number with 18 decimals.
+    function balanceOf(address account) public view override(ERC20, IJBToken) returns (uint256) {
+        return super.balanceOf(account);
+    }
+
+    /// @notice This token can only be added to a project when its created by the `JBTokens` contract.
+    function canBeAddedTo(uint256) external pure override returns (bool) {
+        return false;
+    }
+
+    /// @notice The number of decimals used for this token's fixed point accounting.
+    /// @return The number of decimals.
+    function decimals() public view override(ERC20, IJBToken) returns (uint8) {
+        return super.decimals();
+    }
+
+    /// @notice The token's name.
+    function name() public view virtual override returns (string memory) {
+        return _name;
+    }
+
+    /// @notice The token's symbol.
+    function symbol() public view virtual override returns (string memory) {
+        return _symbol;
+    }
+
+    /// @notice The total supply of this ERC20 i.e. the total number of tokens in existence.
+    /// @return The total supply of this ERC20, as a fixed point number.
+    function totalSupply() public view override(ERC20, IJBToken) returns (uint256) {
+        return super.totalSupply();
+    }
+
+    //*********************************************************************//
+    // ---------------------- external transactions ---------------------- //
+    //*********************************************************************//
+
+    /// @notice Burn some outstanding tokens.
+    /// @dev Can only be called by this contract's owner.
+    /// @param account The address to burn tokens from.
+    /// @param amount The amount of tokens to burn, as a fixed point number with 18 decimals.
+    function burn(address account, uint256 amount) external override onlyOwner {
+        return _burn(account, amount);
+    }
+
+    /// @notice Mints more of this token.
+    /// @dev Can only be called by this contract's owner.
+    /// @param account The address to mint the new tokens to.
+    /// @param amount The amount of tokens to mint, as a fixed point number with 18 decimals.
+    function mint(address account, uint256 amount) external override onlyOwner {
+        return _mint(account, amount);
+    }
+
+    //*********************************************************************//
+    // ----------------------- public transactions ----------------------- //
+    //*********************************************************************//
+
+    /// @notice Initializes the token.
+    /// @param name_ The token's name.
+    /// @param symbol_ The token's symbol.
+    /// @param owner The token contract's owner.
+    function initialize(string memory name_, string memory symbol_, address owner) public override {
+        // Prevent re-initialization by reverting if a name is already set or if the provided name is empty.
+        if (bytes(_name).length != 0 || bytes(name_).length == 0) revert JBERC20_AlreadyInitialized();
+
+        _name = name_;
+        _symbol = symbol_;
+
+        // Transfer ownership to the owner.
+        _transferOwnership(owner);
+    }
+
+    /// @notice Required override.
+    function nonces(address owner) public view virtual override(ERC20Permit, Nonces) returns (uint256) {
+        return super.nonces(owner);
+    }
+
+    //*********************************************************************//
+    // ------------------------ internal functions ----------------------- //
+    //*********************************************************************//
+
+    /// @notice Required override.
+    function _update(address from, address to, uint256 value) internal virtual override(ERC20, ERC20Votes) {
+        super._update(from, to, value);
+    }
+}

package/src/JBFeelessAddresses.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {IJBFeelessAddresses} from "./interfaces/IJBFeelessAddresses.sol";
+
+/// @notice Stores a list of addresses that shouldn't incur fees when sending or receiving payments.
+contract JBFeelessAddresses is Ownable, IJBFeelessAddresses, IERC165 {
+    //*********************************************************************//
+    // --------------------- public stored properties -------------------- //
+    //*********************************************************************//
+
+    /// @notice Check if the specified address is feeless.
+    /// @dev Feeless addresses can receive payouts without incurring a fee.
+    /// @dev Feeless addresses can use the surplus allowance without incurring a fee.
+    /// @dev Feeless addresses can be the beneficiary of cash outs without incurring a fee.
+    /// @custom:param addr The address to check.
+    mapping(address addr => bool) public override isFeeless;
+
+    //*********************************************************************//
+    // -------------------------- constructor ---------------------------- //
+    //*********************************************************************//
+
+    /// @param owner This contract's owner.
+    constructor(address owner) Ownable(owner) {}
+
+    //*********************************************************************//
+    // -------------------------- 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 returns (bool) {
+        return interfaceId == type(IJBFeelessAddresses).interfaceId || interfaceId == type(IERC165).interfaceId;
+    }
+
+    //*********************************************************************//
+    // ---------------------- external transactions ---------------------- //
+    //*********************************************************************//
+
+    /// @notice Sets whether an address is feeless.
+    /// @dev Can only be called by this contract's owner.
+    /// @param addr The address to set as feeless or not feeless.
+    /// @param flag Whether the address should be feeless (`true`) or not feeless (`false`).
+    function setFeelessAddress(address addr, bool flag) external virtual override onlyOwner {
+        isFeeless[addr] = flag;
+
+        emit SetFeelessAddress({addr: addr, isFeeless: flag, caller: _msgSender()});
+    }
+}