@bananapus/core-v6 0.0.1

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

@@ -0,0 +1,21 @@
+# JBPermissionsData
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBPermissionsData.sol)
+
+**Notes:**
+- member: operator The address that permissions are being given to.
+
+- member: projectId The ID of the project the operator is being given permissions for. Operators only have
+permissions under this project's scope. An ID of 0 is a wildcard, which gives an operator permissions across all
+projects.
+
+- member: permissionIds The IDs of the permissions being given. See the `JBPermissionIds` library.
+
+
+```solidity
+struct JBPermissionsData {
+    address operator;
+    uint64 projectId;
+    uint8[] permissionIds;
+}
+```
+

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

@@ -0,0 +1,55 @@
+# JBRuleset
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBRuleset.sol)
+
+*`JBRuleset` timestamps are unix timestamps (seconds since 00:00 January 1st, 1970 UTC).*
+
+**Notes:**
+- member: cycleNumber The ruleset's cycle number. Each ruleset's `cycleNumber` is the previous ruleset's
+`cycleNumber` plus one. Each project's first ruleset has a `cycleNumber` of 1.
+
+- member: id The ruleset's ID, which is a timestamp of when this ruleset's rules were initialized. The
+`rulesetId` stays the same for rulesets that automatically cycle over from a manually queued ruleset.
+
+- member: basedOnId The `rulesetId` of the ruleset which was active when this ruleset was created.
+
+- member: start The timestamp from which this ruleset is considered active.
+
+- member: duration The number of seconds the ruleset lasts for. After this duration, a new ruleset will start.
+The project owner can queue new rulesets at any time, which will take effect once the current ruleset's duration is
+over. If the `duration` is 0, newly queued rulesets will take effect immediately. If a ruleset ends and there are no
+new rulesets queued, the current ruleset cycles over to another one with the same properties but a new `start`
+timestamp and a `weight` reduced by the ruleset's `weightCutPercent`.
+
+- member: weight A fixed point number with 18 decimals which is typically used by payment terminals to
+determine how many tokens should be minted when a payment is received. This can be used by other contracts for
+arbitrary calculations.
+
+- member: weightCutPercent The percentage by which to reduce the `weight` each time a new ruleset starts.
+`weight`
+is
+a percentage out of `JBConstants.MAX_WEIGHT_CUT_PERCENT`. If it's 0, the next ruleset will have the same `weight` by
+default. If it's 90%, the next ruleset's `weight` will be 10% smaller. If a ruleset explicitly sets a new `weight`,
+the `weightCutPercent` doesn't apply.
+
+- member: approvalHook An address of a contract that says whether a queued ruleset should be approved or
+rejected. If a
+ruleset is rejected, it won't go into effect. An approval hook can be used to create rules which dictate how a
+project owner can change their ruleset over time.
+
+- member: metadata Extra data associated with a ruleset which can be used by other contracts.
+
+
+```solidity
+struct JBRuleset {
+    uint48 cycleNumber;
+    uint48 id;
+    uint48 basedOnId;
+    uint48 start;
+    uint32 duration;
+    uint112 weight;
+    uint32 weightCutPercent;
+    IJBRulesetApprovalHook approvalHook;
+    uint256 metadata;
+}
+```
+

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

@@ -0,0 +1,51 @@
+# JBRulesetConfig
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBRulesetConfig.sol)
+
+**Notes:**
+- member: mustStartAtOrAfter The earliest time the ruleset can start.
+
+- member: duration The number of seconds the ruleset lasts for, after which a new ruleset will start. A
+duration of 0 means that the ruleset will stay active until the project owner explicitly issues a reconfiguration,
+at which point a new ruleset will immediately start with the updated properties. If the duration is greater than 0,
+a project owner cannot make changes to a ruleset's parameters while it is active – any proposed changes will apply
+to the subsequent ruleset. If no changes are proposed, a ruleset rolls over to another one with the same properties
+but new `start` timestamp and a cut `weight`.
+
+- member: weight A fixed point number with 18 decimals that contracts can use to base arbitrary calculations
+on. For example, payment terminals can use this to determine how many tokens should be minted when a payment is
+received.
+
+- member: weightCutPercent A percent by how much the `weight` of the subsequent ruleset should be reduced, if
+the
+project owner hasn't queued the subsequent ruleset with an explicit `weight`. If it's 0, each ruleset will have
+equal weight. If the number is 90%, the next ruleset will have a 10% smaller weight. This weight is out of
+`JBConstants.MAX_WEIGHT_CUT_PERCENT`.
+
+- member: approvalHook An address of a contract that says whether a proposed ruleset should be accepted or
+rejected. It
+can be used to create rules around how a project owner can change ruleset parameters over time.
+
+- member: metadata Metadata specifying the controller-specific parameters that a ruleset can have. These
+properties cannot change until the next ruleset starts.
+
+- member: splitGroups An array of splits to use for any number of groups while the ruleset is active.
+
+- member: fundAccessLimitGroups An array of structs which dictate the amount of funds a project can access from
+its balance in each payment terminal while the ruleset is active. Amounts are fixed point numbers using the same
+number of decimals as the corresponding terminal. The `_payoutLimit` and `_surplusAllowance` parameters must fit in
+a `uint232`.
+
+
+```solidity
+struct JBRulesetConfig {
+    uint48 mustStartAtOrAfter;
+    uint32 duration;
+    uint112 weight;
+    uint32 weightCutPercent;
+    IJBRulesetApprovalHook approvalHook;
+    JBRulesetMetadata metadata;
+    JBSplitGroup[] splitGroups;
+    JBFundAccessLimitGroup[] fundAccessLimitGroups;
+}
+```
+

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

@@ -0,0 +1,79 @@
+# JBRulesetMetadata
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBRulesetMetadata.sol)
+
+**Notes:**
+- member: reservedPercent The reserved percent of the ruleset. This number is a percentage calculated out of
+`JBConstants.MAX_RESERVED_PERCENT`.
+
+- member: cashOutTaxRate The cash out tax rate of the ruleset. This number is a percentage calculated out of
+`JBConstants.MAX_CASH_OUT_TAX_RATE`.
+
+- member: baseCurrency The currency on which to base the ruleset's weight. By convention, this is
+`uint32(uint160(tokenAddress))` for tokens, or a constant ID from e.g. `JBCurrencyIds` for other currencies.
+
+- member: pausePay A flag indicating if the pay functionality should be paused during the ruleset.
+
+- member: pauseCreditTransfers A flag indicating if the project token transfer functionality should be paused
+during the funding cycle.
+
+- member: allowOwnerMinting A flag indicating if the project owner or an operator with the `MINT_TOKENS`
+permission from the owner should be allowed to mint project tokens on demand during this ruleset.
+
+- member: allowTerminalMigration A flag indicating if migrating terminals should be allowed during this
+ruleset.
+
+- member: allowSetTerminals A flag indicating if a project's terminals can be added or removed.
+
+- member: allowSetController A flag indicating if a project's controller can be changed.
+
+- member: allowAddAccountingContext A flag indicating if a project can add new accounting contexts for its
+terminals to use.
+
+- member: allowAddPriceFeed A flag indicating if a project can add new price feeds to calculate exchange rates
+between its tokens.
+
+- member: ownerMustSendPayouts A flag indicating if privileged payout distribution should be
+enforced, otherwise payouts can be distributed by anyone.
+
+- member: holdFees A flag indicating if fees should be held during this ruleset.
+
+- member: useTotalSurplusForCashOuts A flag indicating if cash outs should use the project's balance held
+in all terminals instead of the project's local terminal balance from which the cash out is being fulfilled.
+
+- member: useDataHookForPay A flag indicating if the data hook should be used for pay transactions during this
+ruleset.
+
+- member: useDataHookForCashOut A flag indicating if the data hook should be used for cash out transactions
+during
+this ruleset.
+
+- member: dataHook The data hook to use during this ruleset.
+
+- member: metadata Metadata of the metadata, only the 14 least significant bits can be used, the 2 most
+significant bits are disregarded.
+
+
+```solidity
+struct JBRulesetMetadata {
+    uint16 reservedPercent;
+    uint16 cashOutTaxRate;
+    uint32 baseCurrency;
+    bool pausePay;
+    bool pauseCreditTransfers;
+    bool allowOwnerMinting;
+    bool allowSetCustomToken;
+    bool allowTerminalMigration;
+    bool allowSetTerminals;
+    bool allowSetController;
+    bool allowAddAccountingContext;
+    bool allowAddPriceFeed;
+    bool ownerMustSendPayouts;
+    bool holdFees;
+    bool useTotalSurplusForCashOuts;
+    bool useDataHookForPay;
+    bool useDataHookForCashOut;
+    address dataHook;
+    uint16 metadata;
+}
+```
+

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

@@ -0,0 +1,16 @@
+# JBRulesetWeightCache
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBRulesetWeightCache.sol)
+
+**Notes:**
+- member: weight The cached weight value.
+
+- member: weightCutMultiple The weight cut multiple that produces the given weight.
+
+
+```solidity
+struct JBRulesetWeightCache {
+    uint112 weight;
+    uint168 weightCutMultiple;
+}
+```
+

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

@@ -0,0 +1,16 @@
+# JBRulesetWithMetadata
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBRulesetWithMetadata.sol)
+
+**Notes:**
+- member: ruleset The ruleset.
+
+- member: metadata The ruleset's metadata.
+
+
+```solidity
+struct JBRulesetWithMetadata {
+    JBRuleset ruleset;
+    JBRulesetMetadata metadata;
+}
+```
+

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

@@ -0,0 +1,26 @@
+# JBSingleAllowance
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBSingleAllowance.sol)
+
+**Notes:**
+- member: sigDeadline Deadline on the permit signature.
+
+- member: amount The maximum amount allowed to spend.
+
+- member: expiration Timestamp at which a spender's token allowances become invalid.
+
+- member: nonce An incrementing value indexed per owner,token,and spender for each signature.
+
+- member: signature The signature over the permit data. Supports EOA signatures, compact signatures defined by
+EIP-2098, and contract signatures defined by EIP-1271.
+
+
+```solidity
+struct JBSingleAllowance {
+    uint256 sigDeadline;
+    uint160 amount;
+    uint48 expiration;
+    uint48 nonce;
+    bytes signature;
+}
+```
+

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

@@ -0,0 +1,49 @@
+# JBSplit
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBSplit.sol)
+
+Splits are used to send a percentage of a total token amount to a specific contract, project, or address.
+Splits are used to send payouts and reserved tokens.
+
+*1. If a non-zero split hook contract is specified, this split's tokens are sent there along with this split's
+properties.*
+
+*2. Otherwise, if a non-zero project ID is specified, this split's tokens are used to `pay` it through its
+terminal if possible, or sent to the project's owner if not. If this payment yields tokens, those go to the split's
+`beneficiary`.*
+
+*3. Otherwise, this split's tokens are sent directly to the `beneficiary`.*
+
+*To summarize, this split's tokens are sent according to the following priority: `split hook` > `projectId` >
+`beneficiary`.*
+
+**Notes:**
+- member: percent The percent of the total token amount that this split sends. This number is out of
+`JBConstants.SPLITS_TOTAL_PERCENT`.
+
+- member: projectId The ID of a project to `pay`, if applicable. Resulting tokens will be routed to the
+`beneficiary`.
+
+- member: beneficiary Receives this split's tokens if the `hook` and `projectId` are zero. If the `projectId`
+is specified, the `beneficiary` receives any project tokens minted by this split.
+
+- member: preferAddToBalance If this split were to `pay` a project through its terminal, this flag indicates
+whether it should prefer using the terminal's `addToBalance` function instead.
+
+- member: lockedUntil The split cannot be changed until this timestamp. The `lockedUntil` timestamp can be
+increased while a split is locked. If `lockedUntil` is zero, this split can be changed at any time.
+
+- member: hook A contract which will receive this split's tokens and properties, and can define custom
+behavior.
+
+
+```solidity
+struct JBSplit {
+    uint32 percent;
+    uint64 projectId;
+    address payable beneficiary;
+    bool preferAddToBalance;
+    uint48 lockedUntil;
+    IJBSplitHook hook;
+}
+```
+

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

@@ -0,0 +1,17 @@
+# JBSplitGroup
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBSplitGroup.sol)
+
+**Notes:**
+- member: groupId An identifier for the group. By convention, this ID is `uint256(uint160(tokenAddress))` for
+payouts and `1` for reserved tokens.
+
+- member: splits The splits in the group.
+
+
+```solidity
+struct JBSplitGroup {
+    uint256 groupId;
+    JBSplit[] splits;
+}
+```
+

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

@@ -0,0 +1,29 @@
+# JBSplitHookContext
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBSplitHookContext.sol)
+
+**Notes:**
+- member: token The token being sent to the split hook.
+
+- member: amount The amount being sent to the split hook, as a fixed point number.
+
+- member: decimals The number of decimals in the amount.
+
+- member: projectId The project the split belongs to.
+
+- member: groupId The group the split belongs to. By convention, this ID is `uint256(uint160(tokenAddress))`
+for payouts and `1` for reserved tokens.
+
+- member: split The split which specified the hook.
+
+
+```solidity
+struct JBSplitHookContext {
+    address token;
+    uint256 amount;
+    uint256 decimals;
+    uint256 projectId;
+    uint256 groupId;
+    JBSplit split;
+}
+```
+

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

@@ -0,0 +1,16 @@
+# JBTerminalConfig
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBTerminalConfig.sol)
+
+**Notes:**
+- member: terminal The terminal to configure.
+
+- member: accountingContextsToAccept The accounting contexts to accept from the terminal.
+
+
+```solidity
+struct JBTerminalConfig {
+    IJBTerminal terminal;
+    JBAccountingContext[] accountingContextsToAccept;
+}
+```
+

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

@@ -0,0 +1,23 @@
+# JBTokenAmount
+[Git Source](https://github.com/Bananapus/nana-core/blob/2998dca2fbd2658e2c8791d6dc8348147d69e28e/src/structs/JBTokenAmount.sol)
+
+**Notes:**
+- member: token The token the payment was made in.
+
+- member: decimals The number of decimals included in the value fixed point number.
+
+- member: currency The currency. By convention, this is `uint32(uint160(tokenAddress))` for tokens, or a
+constant ID from e.g. `JBCurrencyIds` for other currencies.
+
+- member: value The amount of tokens that was paid, as a fixed point number.
+
+
+```solidity
+struct JBTokenAmount {
+    address token;
+    uint8 decimals;
+    uint32 currency;
+    uint256 value;
+}
+```
+

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

@@ -0,0 +1,25 @@
+
+
+# Contents
+- [JBAccountingContext](JBAccountingContext.sol/struct.JBAccountingContext.md)
+- [JBAfterCashOutRecordedContext](JBAfterCashOutRecordedContext.sol/struct.JBAfterCashOutRecordedContext.md)
+- [JBAfterPayRecordedContext](JBAfterPayRecordedContext.sol/struct.JBAfterPayRecordedContext.md)
+- [JBBeforeCashOutRecordedContext](JBBeforeCashOutRecordedContext.sol/struct.JBBeforeCashOutRecordedContext.md)
+- [JBBeforePayRecordedContext](JBBeforePayRecordedContext.sol/struct.JBBeforePayRecordedContext.md)
+- [JBCashOutHookSpecification](JBCashOutHookSpecification.sol/struct.JBCashOutHookSpecification.md)
+- [JBCurrencyAmount](JBCurrencyAmount.sol/struct.JBCurrencyAmount.md)
+- [JBFee](JBFee.sol/struct.JBFee.md)
+- [JBFundAccessLimitGroup](JBFundAccessLimitGroup.sol/struct.JBFundAccessLimitGroup.md)
+- [JBPayHookSpecification](JBPayHookSpecification.sol/struct.JBPayHookSpecification.md)
+- [JBPermissionsData](JBPermissionsData.sol/struct.JBPermissionsData.md)
+- [JBRuleset](JBRuleset.sol/struct.JBRuleset.md)
+- [JBRulesetConfig](JBRulesetConfig.sol/struct.JBRulesetConfig.md)
+- [JBRulesetMetadata](JBRulesetMetadata.sol/struct.JBRulesetMetadata.md)
+- [JBRulesetWeightCache](JBRulesetWeightCache.sol/struct.JBRulesetWeightCache.md)
+- [JBRulesetWithMetadata](JBRulesetWithMetadata.sol/struct.JBRulesetWithMetadata.md)
+- [JBSingleAllowance](JBSingleAllowance.sol/struct.JBSingleAllowance.md)
+- [JBSplit](JBSplit.sol/struct.JBSplit.md)
+- [JBSplitGroup](JBSplitGroup.sol/struct.JBSplitGroup.md)
+- [JBSplitHookContext](JBSplitHookContext.sol/struct.JBSplitHookContext.md)
+- [JBTerminalConfig](JBTerminalConfig.sol/struct.JBTerminalConfig.md)
+- [JBTokenAmount](JBTokenAmount.sol/struct.JBTokenAmount.md)

package/foundry.lock

@@ -0,0 +1,11 @@
+{
+  "lib/forge-std": {
+    "rev": "726a6ee5fc8427a0013d6f624e486c9130c0e336"
+  },
+  "lib/sphinx": {
+    "branch": {
+      "name": "v0.23.0",
+      "rev": "5fb24a825f46bd6ae0b5359fe0da1d2346126b09"
+    }
+  }
+}

package/foundry.toml

@@ -0,0 +1,41 @@
+[profile.default]
+solc = '0.8.23'
+evm_version = 'paris'                   # Required for L2s (Optimism, Arbitrum, etc.)
+match_contract = "_Local"               # Do not run fork tests
+sizes = true
+verbosity = 3                           # display errors
+optimizer_runs = 200
+block_number = 14126430
+block_timestamp = 1643802347
+runs = 4096
+libs = ["node_modules", "lib"]
+build_info = false
+extra_output = ['storageLayout']
+fs_permissions = [{ access = "read-write", path = "./"}]
+
+[rpc_endpoints]
+ethereum ="${RPC_ETHEREUM_MAINNET}"
+optimism = "${RPC_OPTIMISM_MAINNET}"
+polygon = "${RPC_POLYGON_MUMBAI}"
+arbitrum = "${RPC_ARBITRUM_MAINNET}"
+base = "${RPC_BASE_MAINNET}"
+arbitrum_sepolia = "${RPC_ARBITRUM_SEPOLIA}"
+ethereum_sepolia ="${RPC_ETHEREUM_SEPOLIA}"
+optimism_sepolia = "${RPC_OPTIMISM_SEPOLIA}"
+polygon_mumbai = "${RPC_POLYGON_MUMBAI}"
+base_sepolia = "${RPC_BASE_SEPOLIA}"
+
+[profile.fork] # run via FOUNDRY_PROFILE=fork foundry test
+fs_permissions = [{ access = "read", path = "./deployments/mainnet" }] # Get the deployment addresses for forking
+match_contract = "_Fork"
+
+[invariant]
+runs = 1024
+depth = 100
+fail_on_revert = false
+dictionary_weight = 40
+
+[fmt]
+number_underscore = "thousands"
+multiline_func_header = "all"
+wrap_comments = true

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@bananapus/core-v6",
+  "version": "0.0.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bananapus/nana-core-v6"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "test": "forge test",
+    "test:fork": "FOUNDRY_PROFILE=CI forge test",
+    "coverage": "forge coverage --match-path \"./src/*.sol\" --report lcov --report summary",
+    "deploy:mainnets": "source ./.env && npx sphinx propose ./script/Deploy.s.sol --networks mainnets",
+    "deploy:testnets": "source ./.env && npx sphinx propose ./script/Deploy.s.sol --networks testnets",
+    "deploy:mainnets:5_1:1": "source ./.env && npx sphinx propose ./script/Deploy5_1.1.s.sol --networks mainnets",
+    "deploy:testnets:5_1:1": "source ./.env && npx sphinx propose ./script/Deploy5_1.1.s.sol --networks testnets",
+    "deploy:mainnets:5_1:2": "source ./.env && npx sphinx propose ./script/Deploy5_1.2.s.sol --networks mainnets",
+    "deploy:testnets:5_1:2": "source ./.env && npx sphinx propose ./script/Deploy5_1.2.s.sol --networks testnets",
+    "deploy:testnets:periphery": "source ./.env && npx sphinx propose ./script/DeployPeriphery.s.sol --networks testnets",
+    "deploy:mainnets:periphery": "source ./.env && npx sphinx propose ./script/DeployPeriphery.s.sol --networks mainnets",
+    "deploy:testnets:usdc": "source ./.env && npx sphinx propose ./script/DeployUSDCFeeds.s.sol --networks testnets",
+    "deploy:mainnets:usdc": "source ./.env && npx sphinx propose ./script/DeployUSDCFeeds.s.sol --networks mainnets",
+    "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-core-v6'"
+  },
+  "dependencies": {
+    "@bananapus/permission-ids-v6": "^0.0.1",
+    "@chainlink/contracts": "^1.3.0",
+    "@openzeppelin/contracts": "^5.2.0",
+    "@prb/math": "^4.1.0",
+    "@uniswap/permit2": "github:Uniswap/permit2"
+  },
+  "devDependencies": {
+    "@sphinx-labs/plugins": "^0.33.2"
+  }
+}

package/remappings.txt

@@ -0,0 +1 @@
+@sphinx-labs/contracts/=lib/sphinx/packages/contracts/contracts/foundry

package/script/Deploy.s.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.23;
+
+import "@sphinx-labs/contracts/SphinxPlugin.sol";
+import {Script, stdJson, VmSafe} from "forge-std/Script.sol";
+import {CoreDeploymentLib} from "./helpers/CoreDeploymentLib.sol";
+
+import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
+import {JBPermissions} from "src/JBPermissions.sol";
+import {JBProjects} from "src/JBProjects.sol";
+import {JBPrices} from "src/JBPrices.sol";
+import {JBRulesets} from "src/JBRulesets.sol";
+import {JBDirectory} from "src/JBDirectory.sol";
+import {JBERC20} from "src/JBERC20.sol";
+import {JBTokens} from "src/JBTokens.sol";
+import {JBSplits} from "src/JBSplits.sol";
+import {JBFeelessAddresses} from "src/JBFeelessAddresses.sol";
+import {JBFundAccessLimits} from "src/JBFundAccessLimits.sol";
+import {JBController} from "src/JBController.sol";
+import {JBTerminalStore} from "src/JBTerminalStore.sol";
+import {JBMultiTerminal} from "src/JBMultiTerminal.sol";
+
+import {ERC2771Forwarder} from "@openzeppelin/contracts/metatx/ERC2771Forwarder.sol";
+
+contract Deploy is Script, Sphinx {
+    /// @notice The universal PERMIT2 address.
+    IPermit2 private constant _PERMIT2 = IPermit2(0x000000000022D473030F116dDEE9F6B43aC78BA3);
+
+    /// @notice The address that is allowed to forward calls to the terminal and controller on a users behalf.
+    string private constant TRUSTED_FORWARDER_NAME = "Juicebox";
+    address private TRUSTED_FORWARDER;
+
+    /// @notice The address that will manage the few privileged functions of the protocol.
+    address private MANAGER;
+
+    /// @notice The address that will own the fee-project.
+    address private FEE_PROJECT_OWNER;
+
+    /// @notice The nonce that gets used across all chains to sync deployment addresses and allow for new deployments of
+    /// the same bytecode.
+    uint256 private CORE_DEPLOYMENT_NONCE = 6;
+
+    function configureSphinx() public override {
+        sphinxConfig.projectName = "nana-core-v5";
+        sphinxConfig.mainnets = ["ethereum", "optimism", "base", "arbitrum"];
+        sphinxConfig.testnets = ["ethereum_sepolia", "optimism_sepolia", "base_sepolia", "arbitrum_sepolia"];
+    }
+
+    /// @notice Deploys the protocol.
+    function run() public sphinx {
+        // Set the manager, this can be changed and won't affect deployment addresses.
+        MANAGER = safeAddress();
+        // Set the owner of the fee project to be the project multisig.
+        FEE_PROJECT_OWNER = safeAddress();
+
+        // Deploy the protocol.
+        deploy();
+    }
+
+    function deploy() public sphinx {
+        TRUSTED_FORWARDER =
+            address(new ERC2771Forwarder{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(TRUSTED_FORWARDER_NAME));
+
+        JBPermissions permissions =
+            new JBPermissions{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(TRUSTED_FORWARDER);
+        JBProjects projects = new JBProjects{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(
+            safeAddress(), safeAddress(), TRUSTED_FORWARDER
+        );
+        JBDirectory directory =
+            new JBDirectory{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(permissions, projects, safeAddress());
+        JBSplits splits = new JBSplits{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(directory);
+        JBRulesets rulesets = new JBRulesets{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(directory);
+        JBPrices prices = new JBPrices{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(
+            directory, permissions, projects, safeAddress(), TRUSTED_FORWARDER
+        );
+        JBTokens tokens = new JBTokens{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(
+            directory, new JBERC20{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}()
+        );
+
+        new JBFundAccessLimits{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(directory);
+
+        JBFeelessAddresses feeless =
+            new JBFeelessAddresses{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}(safeAddress());
+
+        new JBMultiTerminal{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}({
+            permissions: permissions,
+            projects: projects,
+            splits: splits,
+            store: new JBTerminalStore{salt: keccak256(abi.encode(CORE_DEPLOYMENT_NONCE))}({
+                directory: directory, rulesets: rulesets, prices: prices
+            }),
+            tokens: tokens,
+            feelessAddresses: feeless,
+            permit2: _PERMIT2,
+            trustedForwarder: TRUSTED_FORWARDER
+        });
+
+        // If the manager is not the deployer we transfer all ownership to it.
+        if (MANAGER != safeAddress() && MANAGER != address(0)) {
+            directory.transferOwnership(MANAGER);
+            feeless.transferOwnership(MANAGER);
+            prices.transferOwnership(MANAGER);
+            projects.transferOwnership(MANAGER);
+        }
+
+        // Transfer ownership to the fee project owner.
+        if (FEE_PROJECT_OWNER != safeAddress() && FEE_PROJECT_OWNER != address(0)) {
+            projects.safeTransferFrom(safeAddress(), FEE_PROJECT_OWNER, 1);
+        }
+    }
+}