@bananapus/core-v6 0.0.1

package/src/interfaces/IJBPayoutTerminal.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBSplits} from "./IJBSplits.sol";
+import {IJBTerminal} from "./IJBTerminal.sol";
+import {JBSplit} from "../structs/JBSplit.sol";
+
+/// @notice A terminal that can send payouts.
+interface IJBPayoutTerminal is IJBTerminal {
+    event PayoutReverted(uint256 indexed projectId, JBSplit split, uint256 amount, bytes reason, address caller);
+    event PayoutTransferReverted(
+        uint256 indexed projectId,
+        address addr,
+        address token,
+        uint256 amount,
+        uint256 fee,
+        bytes reason,
+        address caller
+    );
+    event SendPayouts(
+        uint256 indexed rulesetId,
+        uint256 indexed rulesetCycleNumber,
+        uint256 indexed projectId,
+        address projectOwner,
+        uint256 amount,
+        uint256 amountPaidOut,
+        uint256 fee,
+        uint256 netLeftoverPayoutAmount,
+        address caller
+    );
+    event SendPayoutToSplit(
+        uint256 indexed projectId,
+        uint256 indexed rulesetId,
+        uint256 indexed group,
+        JBSplit split,
+        uint256 amount,
+        uint256 netAmount,
+        address caller
+    );
+    event UseAllowance(
+        uint256 indexed rulesetId,
+        uint256 indexed rulesetCycleNumber,
+        uint256 indexed projectId,
+        address beneficiary,
+        address feeBeneficiary,
+        uint256 amount,
+        uint256 amountPaidOut,
+        uint256 netAmountPaidOut,
+        string memo,
+        address caller
+    );
+
+    /// @notice Sends a project's payouts to its payout split group according to its ruleset's payout limits.
+    /// @param projectId The ID of the project to send payouts for.
+    /// @param token The token being paid out.
+    /// @param amount The total amount of tokens to pay out.
+    /// @param currency The currency the amount is denominated in.
+    /// @param minTokensPaidOut The minimum number of terminal tokens expected to be paid out.
+    /// @return amountPaidOut The total amount paid out.
+    function sendPayoutsOf(
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        uint256 currency,
+        uint256 minTokensPaidOut
+    )
+        external
+        returns (uint256 amountPaidOut);
+
+    /// @notice Uses a project's surplus allowance to send funds to a beneficiary.
+    /// @param projectId The ID of the project to use the surplus allowance of.
+    /// @param token The token being paid out.
+    /// @param amount The amount of the surplus allowance to use.
+    /// @param currency The currency the amount is denominated in.
+    /// @param minTokensPaidOut The minimum number of terminal tokens expected to be paid out.
+    /// @param beneficiary The address to send the funds to.
+    /// @param feeBeneficiary The address that will receive any project tokens minted from fees.
+    /// @param memo A memo to pass along to the emitted event.
+    /// @return netAmountPaidOut The net amount paid out to the beneficiary after fees.
+    function useAllowanceOf(
+        uint256 projectId,
+        address token,
+        uint256 amount,
+        uint256 currency,
+        uint256 minTokensPaidOut,
+        address payable beneficiary,
+        address payable feeBeneficiary,
+        string calldata memo
+    )
+        external
+        returns (uint256 netAmountPaidOut);
+}

package/src/interfaces/IJBPermissioned.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBPermissions} from "./IJBPermissions.sol";
+
+/// @notice A contract that uses the permissions contract for access control.
+interface IJBPermissioned {
+    /// @notice The permissions contract used for access control.
+    function PERMISSIONS() external view returns (IJBPermissions);
+}

package/src/interfaces/IJBPermissions.sol

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBPermissionsData} from "./../structs/JBPermissionsData.sol";
+
+/// @notice Stores permissions for all addresses and operators.
+interface IJBPermissions {
+    event OperatorPermissionsSet(
+        address indexed operator,
+        address indexed account,
+        uint256 indexed projectId,
+        uint8[] permissionIds,
+        uint256 packed,
+        address caller
+    );
+
+    /// @notice The project ID considered a wildcard, granting permissions to all projects.
+    function WILDCARD_PROJECT_ID() external view returns (uint256);
+
+    /// @notice Returns the packed permissions that an operator has for an account and project.
+    /// @param operator The address of the operator.
+    /// @param account The address of the account being operated on behalf of.
+    /// @param projectId The project ID the permissions are scoped to. 0 is a wildcard for all projects.
+    /// @return The packed permissions as a uint256 bitmap.
+    function permissionsOf(address operator, address account, uint256 projectId) external view returns (uint256);
+
+    /// @notice Checks if an operator has a specific permission for an account and project.
+    /// @param operator The operator to check.
+    /// @param account The account being operated on behalf of.
+    /// @param projectId The project ID the permission is scoped to. 0 represents all projects.
+    /// @param permissionId The permission ID to check for.
+    /// @param includeRoot Whether to return true if the operator has the ROOT permission.
+    /// @param includeWildcardProjectId Whether to return true if the operator has the permission on project ID 0.
+    /// @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
+    )
+        external
+        view
+        returns (bool);
+
+    /// @notice Checks if an operator has all of the specified permissions for an account and project.
+    /// @param operator The operator to check.
+    /// @param account The account being operated on behalf of.
+    /// @param projectId The project ID the permissions are scoped to. 0 represents all projects.
+    /// @param permissionIds An array of permission IDs to check for.
+    /// @param includeRoot Whether to return true if the operator has the ROOT permission.
+    /// @param includeWildcardProjectId Whether to return true if the operator has the permissions on project ID 0.
+    /// @return A flag indicating whether the operator has all of the specified permissions.
+    function hasPermissions(
+        address operator,
+        address account,
+        uint256 projectId,
+        uint256[] calldata permissionIds,
+        bool includeRoot,
+        bool includeWildcardProjectId
+    )
+        external
+        view
+        returns (bool);
+
+    /// @notice Sets permissions for an operator on behalf of an account.
+    /// @param account The account setting its operator's permissions.
+    /// @param permissionsData The data specifying the permissions the operator is being given.
+    function setPermissionsFor(address account, JBPermissionsData calldata permissionsData) external;
+}

package/src/interfaces/IJBPermitTerminal.sol

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
+
+import {IJBTerminal} from "./IJBTerminal.sol";
+
+/// @notice A terminal that supports Permit2 token approvals.
+interface IJBPermitTerminal is IJBTerminal {
+    event Permit2AllowanceFailed(address indexed token, address indexed owner, bytes reason);
+
+    /// @notice The Permit2 contract used for token approvals.
+    function PERMIT2() external returns (IPermit2);
+}

package/src/interfaces/IJBPriceFeed.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice A price feed that returns a current unit price.
+interface IJBPriceFeed {
+    /// @notice Gets the current price (per 1 unit) from the feed.
+    /// @param decimals The number of decimals the return value should use.
+    /// @return The current unit price from the feed, as a fixed point number with the specified number of decimals.
+    function currentUnitPrice(uint256 decimals) external view returns (uint256);
+}

package/src/interfaces/IJBPrices.sol

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IJBPriceFeed} from "./IJBPriceFeed.sol";
+import {IJBProjects} from "./IJBProjects.sol";
+
+/// @notice Manages price feeds and provides unit prices for currency conversions.
+interface IJBPrices {
+    event AddPriceFeed(
+        uint256 indexed projectId,
+        uint256 indexed pricingCurrency,
+        uint256 indexed unitCurrency,
+        IJBPriceFeed feed,
+        address caller
+    );
+
+    /// @notice The project ID used as a fallback when no project-specific price feed is set.
+    function DEFAULT_PROJECT_ID() external view returns (uint256);
+
+    /// @notice Mints ERC-721s that represent project ownership and transfers.
+    function PROJECTS() external view returns (IJBProjects);
+
+    /// @notice Returns the price feed for a project's currency pair.
+    /// @param projectId The ID of the project to get the price feed of.
+    /// @param pricingCurrency The currency the feed's output price is in terms of.
+    /// @param unitCurrency The currency being priced by the feed.
+    /// @return The price feed for the currency pair.
+    function priceFeedFor(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency
+    )
+        external
+        view
+        returns (IJBPriceFeed);
+
+    /// @notice Returns the unit price for a currency pair.
+    /// @param projectId The ID of the project to get the price for.
+    /// @param pricingCurrency The currency the returned price is in terms of.
+    /// @param unitCurrency The currency being priced.
+    /// @param decimals The number of decimals the returned price should use.
+    /// @return The unit price.
+    function pricePerUnitOf(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        uint256 decimals
+    )
+        external
+        view
+        returns (uint256);
+
+    /// @notice Adds a price feed for a project's currency pair.
+    /// @param projectId The ID of the project to add the price feed for.
+    /// @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 price feed to add.
+    function addPriceFeedFor(
+        uint256 projectId,
+        uint256 pricingCurrency,
+        uint256 unitCurrency,
+        IJBPriceFeed feed
+    )
+        external;
+}

package/src/interfaces/IJBProjectUriRegistry.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/// @notice A registry of metadata URIs for projects.
+interface IJBProjectUriRegistry {
+    /// @notice Returns the metadata URI for a project.
+    /// @param projectId The ID of the project to get the metadata URI of.
+    /// @return The project's metadata URI.
+    function uriOf(uint256 projectId) external view returns (string memory);
+
+    /// @notice Sets the metadata URI for a project.
+    /// @param projectId The ID of the project to set the metadata URI of.
+    /// @param uri The metadata URI to set.
+    function setUriOf(uint256 projectId, string calldata uri) external;
+}

package/src/interfaces/IJBProjects.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+import {IJBTokenUriResolver} from "./IJBTokenUriResolver.sol";
+
+/// @notice Mints ERC-721s that represent project ownership and transfers.
+interface IJBProjects is IERC721 {
+    event Create(uint256 indexed projectId, address indexed owner, address caller);
+    event SetTokenUriResolver(IJBTokenUriResolver indexed resolver, address caller);
+
+    /// @notice Returns the total number of projects that have been created.
+    function count() external view returns (uint256);
+
+    /// @notice Returns the token URI resolver.
+    function tokenUriResolver() external view returns (IJBTokenUriResolver);
+
+    /// @notice Creates a new project and mints the project's ERC-721 to the specified owner.
+    /// @param owner The address that will own the new project's ERC-721.
+    /// @return projectId The ID of the newly created project.
+    function createFor(address owner) external returns (uint256 projectId);
+
+    /// @notice Sets the token URI resolver used to retrieve project token URIs.
+    /// @param resolver The new token URI resolver.
+    function setTokenUriResolver(IJBTokenUriResolver resolver) external;
+}

package/src/interfaces/IJBRulesetApprovalHook.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {JBRuleset} from "./../structs/JBRuleset.sol";
+import {JBApprovalStatus} from "./../enums/JBApprovalStatus.sol";
+
+/// @notice Determines whether the next ruleset in a project's queue is approved or rejected.
+/// @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.
+interface IJBRulesetApprovalHook is IERC165 {
+    /// @notice The minimum number of seconds that must pass for a queued ruleset to be considered approved.
+    function DURATION() external view returns (uint256);
+
+    /// @notice Returns the approval status of a given ruleset.
+    /// @param projectId The ID of the project the ruleset belongs to.
+    /// @param ruleset The ruleset to check the approval status of.
+    /// @return The ruleset's approval status.
+    function approvalStatusOf(uint256 projectId, JBRuleset memory ruleset) external view returns (JBApprovalStatus);
+}

package/src/interfaces/IJBRulesetDataHook.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {JBBeforeCashOutRecordedContext} from "./../structs/JBBeforeCashOutRecordedContext.sol";
+import {JBBeforePayRecordedContext} from "./../structs/JBBeforePayRecordedContext.sol";
+import {JBCashOutHookSpecification} from "./../structs/JBCashOutHookSpecification.sol";
+import {JBPayHookSpecification} from "./../structs/JBPayHookSpecification.sol";
+import {JBRuleset} from "./../structs/JBRuleset.sol";
+
+/// @notice Data hooks extend a terminal's pay/cash-out functionality by overriding the weight or memo, specifying
+/// pay/cash-out hooks, or allowing addresses to mint a project's tokens on-demand.
+/// @dev If a project's ruleset has `useDataHookForPay` or `useDataHookForCashOut` enabled, its `dataHook` is called by
+/// the terminal upon payments/cash outs (respectively).
+interface IJBRulesetDataHook is IERC165 {
+    /// @notice Returns whether an address has permission to mint a project's tokens on-demand.
+    /// @param projectId The ID of the project whose token can be minted.
+    /// @param ruleset The ruleset to check the token minting permission of.
+    /// @param addr The address to check the token minting permission of.
+    /// @return flag A flag indicating whether the address has permission.
+    function hasMintPermissionFor(
+        uint256 projectId,
+        JBRuleset memory ruleset,
+        address addr
+    )
+        external
+        view
+        returns (bool flag);
+
+    /// @notice Calculates data before a payment is recorded in the terminal store.
+    /// @param context The context passed to this data hook by the `pay(...)` function.
+    /// @return weight The new weight to use, overriding the ruleset's weight.
+    /// @return hookSpecifications The amount and data to send to pay hooks instead of adding to the terminal's balance.
+    function beforePayRecordedWith(JBBeforePayRecordedContext calldata context)
+        external
+        view
+        returns (uint256 weight, JBPayHookSpecification[] memory hookSpecifications);
+
+    /// @notice Calculates data before a cash out is recorded in the terminal store.
+    /// @param context The context passed to this data hook by the `cashOutTokensOf(...)` function.
+    /// @return cashOutTaxRate The rate determining the reclaimable amount for a given surplus and token supply.
+    /// @return cashOutCount The number of tokens to consider cashed out.
+    /// @return totalSupply The total number of tokens to consider existing.
+    /// @return hookSpecifications The amount and data to send to cash out hooks instead of returning to the
+    /// beneficiary.
+    function beforeCashOutRecordedWith(JBBeforeCashOutRecordedContext calldata context)
+        external
+        view
+        returns (
+            uint256 cashOutTaxRate,
+            uint256 cashOutCount,
+            uint256 totalSupply,
+            JBCashOutHookSpecification[] memory hookSpecifications
+        );
+}

package/src/interfaces/IJBRulesets.sol

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBApprovalStatus} from "./../enums/JBApprovalStatus.sol";
+import {JBRuleset} from "./../structs/JBRuleset.sol";
+import {IJBRulesetApprovalHook} from "./IJBRulesetApprovalHook.sol";
+
+/// @notice Manages rulesets and queuing for projects.
+interface IJBRulesets {
+    event RulesetInitialized(
+        uint256 indexed rulesetId, uint256 indexed projectId, uint256 indexed basedOnId, address caller
+    );
+    event RulesetQueued(
+        uint256 indexed rulesetId,
+        uint256 indexed projectId,
+        uint256 duration,
+        uint256 weight,
+        uint256 weightCutPercent,
+        IJBRulesetApprovalHook approvalHook,
+        uint256 metadata,
+        uint256 mustStartAtOrAfter,
+        address caller
+    );
+
+    event WeightCacheUpdated(uint256 projectId, uint112 weight, uint256 weightCutMultiple, address caller);
+
+    /// @notice Returns the ID of the latest ruleset queued for a project.
+    /// @param projectId The ID of the project to get the latest ruleset ID of.
+    /// @return The latest ruleset ID.
+    function latestRulesetIdOf(uint256 projectId) external view returns (uint256);
+
+    /// @notice Returns the approval status of the latest queued ruleset relative to the current ruleset.
+    /// @param projectId The ID of the project to check.
+    /// @return The approval status of the latest queued ruleset.
+    function currentApprovalStatusForLatestRulesetOf(uint256 projectId) external view returns (JBApprovalStatus);
+
+    /// @notice Returns the current ruleset for a project, deriving its properties from the base ruleset.
+    /// @param projectId The ID of the project to get the current ruleset of.
+    /// @return ruleset The current ruleset.
+    function currentOf(uint256 projectId) external view returns (JBRuleset memory ruleset);
+
+    /// @notice Derives the cycle number from the base ruleset's parameters and a given start time.
+    /// @param baseRulesetCycleNumber The cycle number of the base ruleset.
+    /// @param baseRulesetStart The start time of the base ruleset.
+    /// @param baseRulesetDuration The duration of the base ruleset.
+    /// @param start The start time to derive the cycle number for.
+    /// @return The derived cycle number.
+    function deriveCycleNumberFrom(
+        uint256 baseRulesetCycleNumber,
+        uint256 baseRulesetStart,
+        uint256 baseRulesetDuration,
+        uint256 start
+    )
+        external
+        returns (uint256);
+
+    /// @notice Derives the start time from the base ruleset's parameters.
+    /// @param baseRulesetStart The start time of the base ruleset.
+    /// @param baseRulesetDuration The duration of the base ruleset.
+    /// @param mustStartAtOrAfter The earliest time the derived ruleset can start.
+    /// @return start The derived start time.
+    function deriveStartFrom(
+        uint256 baseRulesetStart,
+        uint256 baseRulesetDuration,
+        uint256 mustStartAtOrAfter
+    )
+        external
+        view
+        returns (uint256 start);
+
+    /// @notice Derives the weight from the base ruleset's parameters, accounting for weight cuts over elapsed cycles.
+    /// @param projectId The ID of the project.
+    /// @param baseRulesetStart The start time of the base ruleset.
+    /// @param baseRulesetDuration The duration of the base ruleset.
+    /// @param baseRulesetWeight The weight of the base ruleset.
+    /// @param baseRulesetWeightCutPercent The weight cut percent of the base ruleset.
+    /// @param baseRulesetCacheId The cache ID of the base ruleset.
+    /// @param start The start time to derive the weight for.
+    /// @return weight The derived weight.
+    function deriveWeightFrom(
+        uint256 projectId,
+        uint256 baseRulesetStart,
+        uint256 baseRulesetDuration,
+        uint256 baseRulesetWeight,
+        uint256 baseRulesetWeightCutPercent,
+        uint256 baseRulesetCacheId,
+        uint256 start
+    )
+        external
+        view
+        returns (uint256 weight);
+
+    /// @notice Returns a specific ruleset for a project by its ID.
+    /// @param projectId The ID of the project the ruleset belongs to.
+    /// @param rulesetId The ID of the ruleset to retrieve.
+    /// @return The ruleset.
+    function getRulesetOf(uint256 projectId, uint256 rulesetId) external view returns (JBRuleset memory);
+
+    /// @notice Returns the latest queued ruleset for a project and its approval status.
+    /// @param projectId The ID of the project to get the latest queued ruleset of.
+    /// @return ruleset The latest queued ruleset.
+    /// @return approvalStatus The ruleset's approval status.
+    function latestQueuedOf(uint256 projectId)
+        external
+        view
+        returns (JBRuleset memory ruleset, JBApprovalStatus approvalStatus);
+
+    /// @notice Returns an array of rulesets for a project, sorted from latest to earliest.
+    /// @param projectId The ID of the project to get rulesets of.
+    /// @param startingId The ID of the ruleset to begin with. If 0, the latest ruleset is used.
+    /// @param size The maximum number of rulesets to return.
+    /// @return rulesets The array of rulesets.
+    function allOf(
+        uint256 projectId,
+        uint256 startingId,
+        uint256 size
+    )
+        external
+        view
+        returns (JBRuleset[] memory rulesets);
+
+    /// @notice Returns the upcoming ruleset for a project.
+    /// @param projectId The ID of the project to get the upcoming ruleset of.
+    /// @return ruleset The upcoming ruleset.
+    function upcomingOf(uint256 projectId) external view returns (JBRuleset memory ruleset);
+
+    /// @notice Queues a new ruleset for a project.
+    /// @param projectId The ID of the project to queue the ruleset for.
+    /// @param duration The duration of the ruleset in seconds.
+    /// @param weight The weight of the ruleset.
+    /// @param weightCutPercent The percent by which the weight decreases each cycle.
+    /// @param approvalHook The approval hook for the ruleset.
+    /// @param metadata The packed ruleset metadata.
+    /// @param mustStartAtOrAfter The earliest time the ruleset can start.
+    /// @return ruleset The queued ruleset.
+    function queueFor(
+        uint256 projectId,
+        uint256 duration,
+        uint256 weight,
+        uint256 weightCutPercent,
+        IJBRulesetApprovalHook approvalHook,
+        uint256 metadata,
+        uint256 mustStartAtOrAfter
+    )
+        external
+        returns (JBRuleset memory ruleset);
+
+    /// @notice Updates the weight cache for a project to allow efficient weight derivation over many cycles.
+    /// @param projectId The ID of the project to update the weight cache for.
+    function updateRulesetWeightCache(uint256 projectId) external;
+}

package/src/interfaces/IJBSplitHook.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+import {JBSplitHookContext} from "../structs/JBSplitHookContext.sol";
+
+/// @notice Allows processing a single split with custom logic.
+/// @dev The split hook's address should be set as the `hook` in the relevant split.
+interface IJBSplitHook is IERC165 {
+    /// @notice Called by terminals and controllers while processing a split.
+    /// @dev Critical business logic should be protected by appropriate access control. The tokens and/or native tokens
+    /// are optimistically transferred to the split hook when this function is called.
+    /// @param context The context passed by the terminal/controller to the split hook.
+    function processSplitWith(JBSplitHookContext calldata context) external payable;
+}

package/src/interfaces/IJBSplits.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {JBSplit} from "./../structs/JBSplit.sol";
+import {JBSplitGroup} from "./../structs/JBSplitGroup.sol";
+
+/// @notice Stores and manages splits for each project.
+interface IJBSplits {
+    event SetSplit(
+        uint256 indexed projectId, uint256 indexed rulesetId, uint256 indexed groupId, JBSplit split, address caller
+    );
+
+    /// @notice The ruleset ID used as a fallback when no splits are set for a specific ruleset.
+    function FALLBACK_RULESET_ID() external view returns (uint256);
+
+    /// @notice Returns the splits for a project, ruleset, and group.
+    /// @param projectId The ID of the project to get the splits of.
+    /// @param rulesetId The ID of the ruleset the splits should be active in.
+    /// @param groupId The ID of the group to get the splits of.
+    /// @return The splits.
+    function splitsOf(uint256 projectId, uint256 rulesetId, uint256 groupId) external view returns (JBSplit[] memory);
+
+    /// @notice Sets a project's split groups.
+    /// @param projectId The ID of the project to set the split groups of.
+    /// @param rulesetId The ID of the ruleset the split groups should be active in.
+    /// @param splitGroups An array of split groups to set.
+    function setSplitGroupsOf(uint256 projectId, uint256 rulesetId, JBSplitGroup[] calldata splitGroups) external;
+}