@bananapus/router-terminal-v6 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Bananapus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,145 @@
+# nana-router-terminal-v6
+
+A Juicebox terminal that accepts payments in any token, dynamically discovers what token each destination project accepts, and routes the payment there — via direct forwarding, Uniswap swap, JB token cashout, or a combination. Supports both Uniswap V3 and V4 pools, choosing whichever offers better liquidity.
+
+_If you're having trouble understanding this contract, take a look at the [core protocol contracts](https://github.com/Bananapus/nana-core-v6) and the [documentation](https://docs.juicebox.money/) first. If you have questions, reach out on [Discord](https://discord.com/invite/ErQYmth4dS)._
+
+## Architecture
+
+| Contract | Description |
+|----------|-------------|
+| `JBRouterTerminal` | Core terminal. Accepts any token via `pay` or `addToBalanceOf`, discovers the destination project's accepted token, and routes there — swapping through Uniswap V3 or V4 pools if needed. Uses TWAP oracle for automatic slippage protection when the caller doesn't provide a quote. |
+| `JBRouterTerminalRegistry` | A proxy terminal that delegates `pay` and `addToBalanceOf` to a per-project or default `JBRouterTerminal` instance. Allows project owners to choose (and lock) which router terminal implementation they use. |
+
+## How It Works
+
+1. A payer calls `pay(projectId, token, amount, ...)` with any token.
+2. The terminal accepts the token (supports ERC-20 approvals and Permit2).
+3. It discovers the destination project's accepted token by querying the directory.
+4. If the input token differs from the accepted token, it converts it — by cashing out JB project tokens, swapping through the best Uniswap V3 or V4 pool across multiple fee tiers, or both.
+5. Slippage protection: the caller can pass a minimum output quote in metadata (`quoteForSwap` key), or the terminal calculates one from the pool's TWAP oracle with dynamic slippage tolerance.
+6. The output tokens are forwarded to the project's primary terminal via `terminal.pay(...)` or `terminal.addToBalanceOf(...)`.
+
+```mermaid
+sequenceDiagram
+    participant Frontend client
+    participant JBDirectory
+    participant JBRouterTerminal
+    participant Uniswap V3/V4
+    participant JBMultiTerminal
+    Note left of Frontend client: User pays project with USDC
+    Frontend client->>JBDirectory: Checks project's primary USDC terminal
+    JBDirectory->>Frontend client: Returns JBRouterTerminal
+    Frontend client->>JBRouterTerminal: Calls pay(...) with USDC (and optional quote)
+    JBRouterTerminal->>JBDirectory: Discovers project's accepted token (ETH)
+    JBRouterTerminal->>Uniswap V3/V4: Finds best pool, swaps USDC for ETH
+    JBRouterTerminal->>JBMultiTerminal: Pays ETH to project's terminal
+    Note right of JBMultiTerminal: Mint tokens for original beneficiary
+```
+
+### Routing Strategies
+
+The terminal can route payments via multiple strategies:
+
+- **Direct forwarding** — If the input token is already accepted by the destination terminal.
+- **Uniswap V3 swap** — Through the highest-liquidity V3 pool across fee tiers (0.01%, 0.05%, 0.3%, 1%).
+- **Uniswap V4 swap** — Through V4 pools, also searching multiple fee/tick-spacing configurations.
+- **JB token cashout** — Redeeming JB project tokens to get the needed output token.
+- **Combination** — Chaining strategies when no single route works.
+
+## Install
+
+For projects using `npm` to manage dependencies (recommended):
+
+```bash
+npm install @bananapus/router-terminal-v6
+```
+
+For projects using `forge` to manage dependencies:
+
+```bash
+forge install Bananapus/nana-router-terminal-v6
+```
+
+If you're using `forge`, add `@bananapus/router-terminal-v6/=lib/nana-router-terminal-v6/` to `remappings.txt`.
+
+## Develop
+
+`nana-router-terminal-v6` uses [npm](https://www.npmjs.com/) (version >=20.0.0) for package management and [Foundry](https://github.com/foundry-rs/foundry) for builds and tests.
+
+```bash
+npm ci && forge install
+```
+
+| Command | Description |
+|---------|-------------|
+| `forge build` | Compile the contracts and write artifacts to `out`. |
+| `forge test` | Run the tests. |
+| `forge fmt` | Lint. |
+| `forge build --sizes` | Get contract sizes. |
+| `forge coverage` | Generate a test coverage report. |
+| `forge clean` | Remove the build artifacts and cache directories. |
+
+### Scripts
+
+| Command | Description |
+|---------|-------------|
+| `npm test` | Run local tests. |
+| `npm run coverage` | Generate an LCOV test coverage report. |
+
+### Configuration
+
+Key `foundry.toml` settings:
+
+- `solc = '0.8.26'`
+- `evm_version = 'cancun'` (required for Uniswap V4's transient storage)
+- `optimizer_runs = 100000000`
+
+## Repository Layout
+
+```
+nana-router-terminal-v6/
+├── src/
+│   ├── JBRouterTerminal.sol              # Core router terminal
+│   ├── JBRouterTerminalRegistry.sol      # Per-project terminal routing
+│   ├── interfaces/
+│   │   ├── IJBRouterTerminal.sol         # Router terminal interface
+│   │   ├── IJBRouterTerminalRegistry.sol # Registry interface
+│   │   └── IWETH9.sol                    # WETH wrapper interface
+│   ├── libraries/
+│   │   └── JBSwapLib.sol                 # Swap math and pool discovery
+│   └── structs/
+│       └── PoolInfo.sol                  # Pool metadata struct
+├── script/
+│   ├── Deploy.s.sol                      # Deployment script
+│   └── helpers/
+│       └── RouterTerminalDeploymentLib.sol # Deployment address loader
+└── test/
+    ├── RouterTerminal.t.sol              # Terminal tests
+    └── RouterTerminalRegistry.t.sol      # Registry tests
+```
+
+## Payment Metadata
+
+The `JBRouterTerminal` accepts encoded `metadata` in its `pay(...)` function. Metadata is decoded using `JBMetadataResolver`:
+
+```solidity
+(bool exists, bytes memory quote) =
+    JBMetadataResolver.getDataFor(JBMetadataResolver.getId("quoteForSwap"), metadata);
+
+if (exists) {
+    (minAmountOut) = abi.decode(quote, (uint256));
+}
+```
+
+If no quote is provided, the terminal calculates one from the pool's TWAP oracle with a dynamic slippage tolerance based on the estimated price impact of the swap.
+
+The terminal also supports Permit2 metadata (key: `"permit2"`) for gasless token approvals.
+
+## Risks
+
+- The terminal never holds a token balance. After every swap, all output tokens are forwarded and leftover input tokens are returned to the payer.
+- Pool discovery is dynamic — the terminal searches V3 and V4 pools at runtime. If pool liquidity changes between discovery and execution, slippage protection prevents losses.
+- TWAP fallback: when no TWAP observations exist, the terminal falls back to the pool's current spot tick rather than reverting.
+- The `receive()` function only accepts ETH from the WETH contract (during unwrap). All other senders revert.
+- Uniswap V4 requires `cancun` EVM version (transient storage opcodes). This terminal will not work on chains without EIP-1153 support.

package/SKILLS.md

@@ -0,0 +1,101 @@
+# nana-router-terminal-v6
+
+## Purpose
+
+Accept payments in any ERC-20 token (or native ETH), dynamically discover what token the destination project accepts, and route there — via Uniswap V3/V4 swap, direct forwarding, JB token cashout, or a combination.
+
+## Contracts
+
+| Contract | Role |
+|----------|------|
+| `JBRouterTerminal` | Core terminal: accepts any token, discovers the best route to the destination project's accepted token, swaps via Uniswap V3 or V4, forwards to primary terminal. Implements `IJBTerminal`, `IJBPermitTerminal`, `IUniswapV3SwapCallback`, `IUnlockCallback`. |
+| `JBRouterTerminalRegistry` | Proxy terminal routing `pay`/`addToBalanceOf` to a per-project or default `JBRouterTerminal`. Implements `IJBTerminal`. |
+
+## Key Functions
+
+| Function | Contract | What it does |
+|----------|----------|--------------|
+| `pay(projectId, token, amount, beneficiary, minReturnedTokens, memo, metadata)` | `JBRouterTerminal` | Accept any token, discover destination's accepted token, swap if needed via best V3/V4 pool, forward to project's primary terminal. Returns project token count. |
+| `addToBalanceOf(projectId, token, amount, shouldReturnHeldFees, memo, metadata)` | `JBRouterTerminal` | Same routing flow but calls `terminal.addToBalanceOf(...)` instead of `terminal.pay(...)`. |
+| `discoverPool(normalizedTokenIn, normalizedTokenOut)` | `JBRouterTerminal` | Search V3 factory for highest liquidity pool across 4 fee tiers (0.01%, 0.05%, 0.3%, 1%). |
+| `discoverBestPool(normalizedTokenIn, normalizedTokenOut)` | `JBRouterTerminal` | Discover best pool across both V3 and V4, comparing liquidity. Returns `PoolInfo` with version, key, and liquidity. |
+| `setTerminalFor(projectId, terminal)` | `JBRouterTerminalRegistry` | Route a project to a specific allowed router terminal. Requires `SET_ROUTER_TERMINAL` permission. |
+| `lockTerminalFor(projectId)` | `JBRouterTerminalRegistry` | Lock the terminal choice for a project (irreversible). |
+| `allowTerminal(terminal)` | `JBRouterTerminalRegistry` | Owner-only: add a terminal to the allowlist. |
+| `setDefaultTerminal(terminal)` | `JBRouterTerminalRegistry` | Owner-only: set the default terminal for projects without a custom choice. |
+
+## Integration Points
+
+| Dependency | Import | Used For |
+|------------|--------|----------|
+| `nana-core-v6` | `IJBDirectory`, `IJBTerminal`, `IJBProjects`, `IJBPermissions`, `IJBTokens` | Directory lookups (`primaryTerminalOf`), project ownership, permission checks, token discovery |
+| `nana-core-v6` | `JBMetadataResolver` | Parsing `quoteForSwap` and `permit2` metadata from calldata |
+| `nana-core-v6` | `JBAccountingContext`, `JBSingleAllowance` | Token accounting and Permit2 allowance structs |
+| `nana-permission-ids-v6` | `JBPermissionIds` | Permission ID constants (`SET_ROUTER_TERMINAL`) |
+| `@uniswap/v3-core` | `IUniswapV3Pool`, `IUniswapV3Factory`, `TickMath` | V3 pool swaps, factory pool discovery, tick math |
+| `@uniswap/v3-periphery` | `OracleLibrary` | TWAP oracle consultation (`consult`, `getQuoteAtTick`, `getOldestObservationSecondsAgo`) |
+| `@uniswap/v4-core` | `IPoolManager`, `PoolKey`, `Currency`, `StateLibrary` | V4 pool swaps and liquidity queries |
+| `@uniswap/permit2` | `IPermit2`, `IAllowanceTransfer` | Gasless token approvals |
+| `@openzeppelin/contracts` | `Ownable`, `ERC2771Context`, `SafeERC20` | Access control, meta-transactions, safe transfers |
+
+## Key Types
+
+| Struct/Enum | Key Fields | Used In |
+|-------------|------------|---------|
+| `PoolInfo` | `isV4`, `v3Pool`, `v4Key`, `liquidity` | Returned by `discoverBestPool`. Indicates whether the best route is V3 or V4 and stores the pool details. |
+| `JBAccountingContext` | `token`, `decimals`, `currency` | Token accounting contexts for accepted tokens. |
+| `JBSingleAllowance` | `sigDeadline`, `amount`, `expiration`, `nonce`, `signature` | Decoded from `permit2` metadata key for gasless approvals. |
+
+## Constants
+
+| Constant | Value | Purpose |
+|----------|-------|---------|
+| `DEFAULT_TWAP_WINDOW` | `10 minutes` | Default TWAP oracle window for auto-discovered pools |
+| `FEE_TIERS` | `[3000, 500, 10000, 100]` | V3 fee tiers to search (0.3%, 0.05%, 1%, 0.01%) |
+| `V4_FEES` | `[3000, 500, 10000, 100]` | V4 fee tiers to search |
+| `V4_TICK_SPACINGS` | `[60, 10, 200, 1]` | V4 tick spacings paired with fee tiers |
+| `SLIPPAGE_DENOMINATOR` | `10,000` | Basis points denominator for slippage |
+
+## Gotchas
+
+- The terminal never holds a token balance. After every swap, all output tokens are forwarded and leftover input tokens are returned to the payer.
+- Unlike the swap terminal which had a fixed `TOKEN_OUT`, the router terminal dynamically discovers what token each project accepts. This makes it a universal entry point.
+- Pool discovery runs at call time — it searches V3 and V4 pools across multiple fee tiers. The best pool (by liquidity) wins. This is gas-intensive but ensures optimal routing.
+- When `tokenIn == NATIVE_TOKEN`, the terminal wraps ETH to WETH before swapping. When the output is `NATIVE_TOKEN`, it unwraps WETH after swapping.
+- The `receive()` function only accepts ETH from the WETH contract (during unwrap). All other senders revert.
+- TWAP fallback: when no observations exist (`oldestObservation == 0`), the terminal falls back to the pool's current spot tick and liquidity rather than reverting.
+- Uniswap V4 requires `cancun` EVM version (transient storage). Chains without EIP-1153 cannot use V4 routing — the terminal falls back to V3.
+- The `JBRouterTerminalRegistry` handles token custody during delegation — it transfers tokens from the payer to itself, then to the underlying terminal.
+- Metadata keys: `"quoteForSwap"` for the minimum output amount, `"permit2"` for gasless approvals.
+- `_msgSender()` (ERC-2771) is used instead of `msg.sender` for meta-transaction compatibility.
+- The `JBSwapLib` library contains the core swap execution logic, extracted for contract size management.
+
+## Example Integration
+
+```solidity
+import {JBRouterTerminal} from "@bananapus/router-terminal-v6/src/JBRouterTerminal.sol";
+import {JBRouterTerminalRegistry} from "@bananapus/router-terminal-v6/src/JBRouterTerminalRegistry.sol";
+
+// The registry is the entry point for payments.
+// It delegates to per-project or default JBRouterTerminal instances.
+
+// Pay project 1 with USDC — the router terminal discovers that
+// project 1 accepts ETH, finds the best USDC/WETH pool across
+// V3 and V4, swaps, and forwards ETH to the project's terminal.
+IERC20(usdc).approve(address(registry), 1000e6);
+registry.pay{value: 0}(
+    1,           // projectId
+    usdc,        // token (USDC)
+    1000e6,      // amount (1000 USDC)
+    beneficiary, // who receives project tokens
+    0,           // minReturnedTokens
+    "Payment via router",
+    ""           // metadata (empty = use TWAP quote)
+);
+
+// Project owners can choose a specific router terminal:
+registry.setTerminalFor(projectId, preferredTerminal);
+
+// And lock it permanently:
+registry.lockTerminalFor(projectId);
+```

package/foundry.toml

@@ -0,0 +1,22 @@
+[profile.default]
+solc = '0.8.26'
+evm_version = 'cancun'
+optimizer_runs = 100000000
+libs = ["node_modules", "lib"]
+fs_permissions = [{ access = "read-write", path = "./"}]
+
+[profile.ci_sizes]
+optimizer_runs = 200
+
+[fuzz]
+runs = 4096
+
+[invariant]
+runs = 1024
+depth = 100
+fail_on_revert = false
+
+[fmt]
+number_underscore = "thousands"
+multiline_func_header = "all"
+wrap_comments = true

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@bananapus/router-terminal-v6",
+  "version": "0.0.1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Bananapus/nana-router-terminal-v6"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "test": "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",
+    "artifacts": "source ./.env && npx sphinx artifacts --org-id 'ea165b21-7cdc-4d7b-be59-ecdd4c26bee4' --project-name 'nana-router-terminal-v6'"
+  },
+  "dependencies": {
+    "@bananapus/core-v6": "^0.0.4",
+    "@openzeppelin/contracts": "^5.2.0",
+    "@uniswap/permit2": "github:Uniswap/permit2",
+    "@uniswap/v3-core": "github:Uniswap/v3-core#0.8",
+    "@uniswap/v3-periphery": "github:Uniswap/v3-periphery#0.8",
+    "@uniswap/v4-core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@sphinx-labs/plugins": "^0.33.2"
+  }
+}

package/script/Deploy.s.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import "@bananapus/core-v6/script/helpers/CoreDeploymentLib.sol";
+
+import {Sphinx} from "@sphinx-labs/contracts/SphinxPlugin.sol";
+import {Script} from "forge-std/Script.sol";
+
+import {JBRouterTerminal} from "../src/JBRouterTerminal.sol";
+import {JBRouterTerminalRegistry} from "../src/JBRouterTerminalRegistry.sol";
+import {IWETH9} from "../src/interfaces/IWETH9.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {IUniswapV3Factory} from "@uniswap/v3-core/contracts/interfaces/IUniswapV3Factory.sol";
+import {IPermit2} from "@uniswap/permit2/src/interfaces/IPermit2.sol";
+
+contract DeployScript is Script, Sphinx {
+    /// @notice tracks the deployment of the core contracts for the chain we are deploying to.
+    CoreDeployment core;
+
+    /// @notice the salts that are used to deploy the contracts.
+    bytes32 ROUTER_TERMINAL = "JBRouterTerminalV6";
+    bytes32 ROUTER_TERMINAL_REGISTRY = "JBRouterTerminalRegistryV6";
+
+    /// @notice tracks the addresses that are required for the chain we are deploying to.
+    address weth;
+    address factory;
+    address poolManager;
+    address permit2;
+    address trustedForwarder;
+
+    function configureSphinx() public override {
+        sphinxConfig.projectName = "nana-router-terminal-v6";
+        sphinxConfig.mainnets = ["ethereum", "optimism", "base", "arbitrum"];
+        sphinxConfig.testnets = ["ethereum_sepolia", "optimism_sepolia", "base_sepolia", "arbitrum_sepolia"];
+    }
+
+    function run() public {
+        // Get the deployment addresses for the nana CORE for this chain.
+        // We want to do this outside of the `sphinx` modifier.
+        core = CoreDeploymentLib.getDeployment(
+            vm.envOr("NANA_CORE_DEPLOYMENT_PATH", string("node_modules/@bananapus/core-v6/deployments/"))
+        );
+
+        trustedForwarder = core.permissions.trustedForwarder();
+
+        // Permit2 is deployed at the same address on all chains.
+        permit2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
+
+        // Ethereum Mainnet
+        if (block.chainid == 1) {
+            weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
+            factory = 0x1F98431c8aD98523631AE4a59f267346ea31F984;
+            poolManager = 0x000000000004444c5dc75cB358380D2e3dE08A90;
+            // Ethereum Sepolia
+        } else if (block.chainid == 11_155_111) {
+            weth = 0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9;
+            factory = 0x0227628f3F023bb0B980b67D528571c95c6DaC1c;
+            poolManager = 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543;
+            // Optimism Mainnet
+        } else if (block.chainid == 10) {
+            weth = 0x4200000000000000000000000000000000000006;
+            factory = 0x1F98431c8aD98523631AE4a59f267346ea31F984;
+            poolManager = 0x000000000004444c5dc75cB358380D2e3dE08A90;
+            // Base Mainnet
+        } else if (block.chainid == 8453) {
+            weth = 0x4200000000000000000000000000000000000006;
+            factory = 0x33128a8fC17869897dcE68Ed026d694621f6FDfD;
+            poolManager = 0x000000000004444c5dc75cB358380D2e3dE08A90;
+            // Optimism Sepolia
+        } else if (block.chainid == 11_155_420) {
+            weth = 0x4200000000000000000000000000000000000006;
+            factory = 0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24;
+            poolManager = 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543;
+            // BASE Sepolia
+        } else if (block.chainid == 84_532) {
+            weth = 0x4200000000000000000000000000000000000006;
+            factory = 0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24;
+            poolManager = 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543;
+            // Arbitrum Mainnet
+        } else if (block.chainid == 42_161) {
+            weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;
+            factory = 0x1F98431c8aD98523631AE4a59f267346ea31F984;
+            poolManager = 0x000000000004444c5dc75cB358380D2e3dE08A90;
+            // Arbitrum Sepolia
+        } else if (block.chainid == 421_614) {
+            weth = 0x980B62Da83eFf3D4576C647993b0c1D7faf17c73;
+            factory = 0x248AB79Bbb9bC29bB72f7Cd42F17e054Fc40188e;
+            poolManager = 0xE03A1074c86CFeDd5C142C4F04F1a1536e203543;
+        } else {
+            revert("Invalid RPC / no juice contracts deployed on this network");
+        }
+
+        // Perform the deployment transactions.
+        deploy();
+    }
+
+    function deploy() public sphinx {
+        JBRouterTerminalRegistry registry = new JBRouterTerminalRegistry{salt: ROUTER_TERMINAL_REGISTRY}(
+            core.permissions, core.projects, IPermit2(permit2), safeAddress(), trustedForwarder
+        );
+
+        JBRouterTerminal terminal = new JBRouterTerminal{salt: ROUTER_TERMINAL}(
+            core.directory,
+            core.permissions,
+            core.projects,
+            core.tokens,
+            IPermit2(permit2),
+            safeAddress(),
+            IWETH9(weth),
+            IUniswapV3Factory(factory),
+            IPoolManager(poolManager),
+            trustedForwarder
+        );
+
+        // Set the terminal as the default for the registry.
+        registry.setDefaultTerminal(terminal);
+    }
+
+    function _isDeployed(bytes32 salt, bytes memory creationCode, bytes memory arguments) internal view returns (bool) {
+        address _deployedTo = vm.computeCreate2Address({
+            salt: salt,
+            initCodeHash: keccak256(abi.encodePacked(creationCode, arguments)),
+            // Arachnid/deterministic-deployment-proxy address.
+            deployer: address(0x4e59b44847b379578588920cA78FbF26c0B4956C)
+        });
+
+        // Return if code is already present at this address.
+        return address(_deployedTo).code.length != 0;
+    }
+}

package/script/helpers/RouterTerminalDeploymentLib.sol

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {stdJson} from "forge-std/Script.sol";
+import {Vm} from "forge-std/Vm.sol";
+
+import {SphinxConstants, NetworkInfo} from "@sphinx-labs/contracts/SphinxConstants.sol";
+
+import {IJBRouterTerminal} from "../../src/interfaces/IJBRouterTerminal.sol";
+import {IJBRouterTerminalRegistry} from "../../src/interfaces/IJBRouterTerminalRegistry.sol";
+
+struct RouterTerminalDeployment {
+    IJBRouterTerminal terminal;
+    IJBRouterTerminalRegistry registry;
+}
+
+library RouterTerminalDeploymentLib {
+    // Cheat code address, 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D.
+    address internal constant VM_ADDRESS = address(uint160(uint256(keccak256("hevm cheat code"))));
+    Vm internal constant vm = Vm(VM_ADDRESS);
+
+    function getDeployment(string memory path) internal returns (RouterTerminalDeployment memory deployment) {
+        // get chainId for which we need to get the deployment.
+        uint256 chainId = block.chainid;
+
+        // Deploy to get the constants.
+        // TODO: get constants without deploy.
+        SphinxConstants sphinxConstants = new SphinxConstants();
+        NetworkInfo[] memory networks = sphinxConstants.getNetworkInfoArray();
+
+        for (uint256 _i; _i < networks.length; _i++) {
+            if (networks[_i].chainId == chainId) {
+                return getDeployment(path, networks[_i].name);
+            }
+        }
+
+        revert("ChainID is not (currently) supported by Sphinx.");
+    }
+
+    function getDeployment(
+        string memory path,
+        string memory network_name
+    )
+        internal
+        view
+        returns (RouterTerminalDeployment memory deployment)
+    {
+        deployment.terminal = IJBRouterTerminal(
+            _getDeploymentAddress(path, "nana-router-terminal-v6", network_name, "JBRouterTerminal")
+        );
+
+        deployment.registry = IJBRouterTerminalRegistry(
+            _getDeploymentAddress(path, "nana-router-terminal-v6", network_name, "JBRouterTerminalRegistry")
+        );
+    }
+
+    /// @notice Get the address of a contract that was deployed by the Deploy script.
+    /// @dev Reverts if the contract was not found.
+    /// @param path The path to the deployment file.
+    /// @param contractName The name of the contract to get the address of.
+    /// @return The address of the contract.
+    function _getDeploymentAddress(
+        string memory path,
+        string memory project_name,
+        string memory network_name,
+        string memory contractName
+    )
+        internal
+        view
+        returns (address)
+    {
+        string memory deploymentJson =
+            vm.readFile(string.concat(path, project_name, "/", network_name, "/", contractName, ".json"));
+        return stdJson.readAddress(deploymentJson, ".address");
+    }
+}

package/slither-ci.config.json

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