@bananapus/router-terminal-v6 0.0.13 → 0.0.15

package/ARCHITECTURE.md

@@ -12,6 +12,7 @@ src/
 ├── JBRouterTerminalRegistry.sol — Registry mapping projects to router terminal configs
 ├── interfaces/
 │   ├── IJBRouterTerminal.sol
+│   ├── IJBRouterTerminalRegistry.sol
 │   └── IWETH9.sol
 ├── libraries/
 │   └── JBSwapLib.sol            — Uniswap V3/V4 swap helpers, pool discovery
@@ -29,10 +30,18 @@ Payer → JBRouterTerminal.pay(projectId, token, amount)
   → If different token:
     → Compare V3 and V4 pool quotes
     → Swap via better pool
-    → Forward swapped tokens to project's terminal
+  → Forward swapped tokens to project's terminal
   → Return token count from destination payment
 ```
 
+### Preview Routing
+```
+Caller → JBRouterTerminal.previewPayFor(projectId, token, amount)
+  → Mirror source-of-funds and routing logic in view context
+  → If direct, wrap-unwrap, or exact cashout route: forward preview to destination terminal
+  → If swap route: estimate output using the same quote-selection logic used for execution bounds
+```
+
 ## Extension Points
 
 | Point | Interface | Purpose |
@@ -41,6 +50,13 @@ Payer → JBRouterTerminal.pay(projectId, token, amount)
 | Registry | `IJBRouterTerminalRegistry` | Maps projects to routing configs |
 | Permit | `IJBPermitTerminal` | Permit2 token approval support |
 
+## Composition Boundary
+
+The router terminal exposes the `IJBTerminal` surface because it needs to participate in Juicebox routing, but its
+accounting context is intentionally synthetic. `accountingContextForTokenOf()` returns `decimals = 18` for any token,
+and the registry forwards that value unchanged. Treat the router layer as a payment router only, not as an
+accounting-sensitive terminal source for loan sizing, debt normalization, or any other decimals-dependent logic.
+
 ## Dependencies
 - `@bananapus/core-v6` — Terminal, directory, permissions
 - `@uniswap/v3-core` + `v3-periphery` — V3 swap routing

package/CHANGE_LOG.md

@@ -21,7 +21,7 @@ The main contract was renamed from `JBSwapTerminal` (and `JBSwapTerminal5_1`) to
 
 ### 1.4 `IJBSwapTerminal` Interface Removed, Replaced by `IJBRouterTerminal`
 - **v5 `IJBSwapTerminal`** exposed: `DEFAULT_PROJECT_ID()`, `MAX_TWAP_WINDOW()`, `MIN_TWAP_WINDOW()`, `MIN_DEFAULT_POOL_CARDINALITY()`, `UNCERTAIN_SLIPPAGE_TOLERANCE()`, `SLIPPAGE_DENOMINATOR()`, `twapWindowOf()`, `addDefaultPool()`, `addTwapParamsFor()`.
-- **v6 `IJBRouterTerminal`** exposes only: `discoverBestPool()`, `discoverPool()`.
+- **v6 `IJBRouterTerminal`** exposes: `discoverBestPool()`, `discoverPool()`, and `previewPayFor()`.
 - All pool/TWAP configuration functions are removed (see section 1.5).
 
 ### 1.5 Removed: Per-Project Pool Configuration and TWAP Management
@@ -44,7 +44,7 @@ The `SLIPPAGE_DENOMINATOR` constant was kept but changed from `uint160` to `uint
 
 ### 1.7 `supportsInterface` Changed
 - **v5:** Reported support for `IJBTerminal`, `IJBPermitTerminal`, `IERC165`, `IUniswapV3SwapCallback`, `IJBPermissioned`, `IJBSwapTerminal`.
-- **v6:** Reports support for `IJBTerminal`, `IJBPermitTerminal`, `IERC165`, `IJBPermissioned` only. No longer advertises `IUniswapV3SwapCallback` or the custom interface.
+- **v6:** Reports support for `IJBTerminal`, `IJBPermitTerminal`, `IJBRouterTerminal`, `IERC165`, and `IJBPermissioned`. It no longer advertises `IUniswapV3SwapCallback`.
 
 ### 1.8 Permission ID Changed (Registry)
 - **v5:** `lockTerminalFor()` and `setTerminalFor()` used `JBPermissionIds.ADD_SWAP_TERMINAL_POOL`.
@@ -121,18 +121,25 @@ New external view functions on `IJBRouterTerminal` for off-chain queries:
 - `discoverBestPool(tokenIn, tokenOut)` — returns a `PoolInfo` (V3 or V4).
 - `discoverPool(tokenIn, tokenOut)` — returns only the V3 pool (backwards-compatible helper).
 
-### 2.10 `Permit2AllowanceFailed` Event
+### 2.10 `previewPayFor()` Added
+New external view functions on the router surfaces:
+- `JBRouterTerminal.previewPayFor(projectId, token, amount, beneficiary, metadata)` mirrors the router's payment routing logic and forwards the preview to the terminal that would ultimately receive the payment.
+- `JBRouterTerminalRegistry.previewPayFor(projectId, token, amount, beneficiary, metadata)` resolves the router terminal for a project and forwards the preview.
+- Direct routes and wrap-unwrap routes are previewable exactly.
+- Swap routes return best-effort estimates using the same pool discovery and quote-selection logic used for execution bounds.
+
+### 2.11 `Permit2AllowanceFailed` Event
 In v6, when a Permit2 allowance call fails during `_acceptFundsFor()`, an event `Permit2AllowanceFailed(token, owner, reason)` is emitted (inherited from `IJBPermitTerminal`), and the payment continues using fallback transfer. In v5, the failure was silently swallowed with an empty `catch`.
 
-### 2.11 Fee-on-Transfer Token Handling
+### 2.12 Fee-on-Transfer Token Handling
 - **v5 `_acceptFundsFor`:** Returned `IERC20(token).balanceOf(address(this))` after transfer — would include any pre-existing balance.
 - **v6 `_acceptFundsFor`:** Uses balance-delta pattern (`balanceAfter - balanceBefore`) to accurately measure tokens received.
 
-### 2.12 Partial-Fill Leftover Handling via Balance Delta
+### 2.13 Partial-Fill Leftover Handling via Balance Delta
 - **v5 `_handleTokenTransfersAndSwap`:** Measured leftovers as the full `balanceOf(normalizedTokenIn)` — could include pre-existing balances.
 - **v6 `_handleSwap`:** Snapshots `balanceBefore` and uses `balanceAfter - balanceBefore` for accurate leftover calculation.
 
-### 2.13 `PERMIT2` Exposed on `IJBRouterTerminalRegistry` Interface
+### 2.14 `PERMIT2` Exposed on `IJBRouterTerminalRegistry` Interface
 - **v5:** `PERMIT2` was an immutable on the registry contract but not exposed on the `IJBSwapTerminalRegistry` interface.
 - **v6:** `PERMIT2()` is declared on the `IJBRouterTerminalRegistry` interface.
 

package/README.md

@@ -2,25 +2,40 @@
 
 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.
 
+This contract family is a routing surface, not an accounting-truth surface. `JBRouterTerminal` synthesizes
+best-effort `JBAccountingContext` values for routing discovery: native tokens use `18` decimals, ERC-20s probe
+`IERC20Metadata.decimals()` when available, and broken or non-standard tokens fall back to `18`. The registry simply
+forwards that context. Do not reuse the router terminal or router terminal registry as an accounting-sensitive terminal
+source for lending or other logic that relies on real token decimals.
+
 _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, cashing out JB project tokens if the input is a project token, or forwarding directly if the token is already accepted. Uses TWAP oracle (V3) or spot price (V4) for automatic slippage protection when the caller does not provide a quote. Implements `IJBTerminal`, `IJBPermitTerminal`, `IUniswapV3SwapCallback`, and `IUnlockCallback`. |
-| `JBRouterTerminalRegistry` | A proxy terminal that delegates `pay` and `addToBalanceOf` to a per-project or default `JBRouterTerminal` instance. Project owners can choose which router terminal they use, and optionally lock that choice permanently. Implements `IJBTerminal` via `IJBRouterTerminalRegistry`. |
+| `JBRouterTerminal` | Core terminal. Accepts any token via `pay` or `addToBalanceOf`, previews payment routes via `previewPayFor`, discovers the destination project's accepted token, and routes there -- swapping through Uniswap V3 or V4 pools if needed, cashing out JB project tokens if the input is a project token, or forwarding directly if the token is already accepted. Uses TWAP oracle (V3) or spot price (V4) for automatic slippage protection when the caller does not provide a quote. Implements `IJBTerminal`, `IJBPermitTerminal`, `IUniswapV3SwapCallback`, `IUnlockCallback`, and `IJBRouterTerminal`. |
+| `JBRouterTerminalRegistry` | A proxy terminal that delegates `pay`, `previewPayFor`, and `addToBalanceOf` to a per-project or default `JBRouterTerminal` instance. Project owners can choose which router terminal they use, and optionally lock that choice permanently. Implements `IJBTerminal` and the extra registry management surface via `IJBRouterTerminalRegistry`. |
 
 ## How It Works
 
 1. A payer calls `pay(projectId, token, amount, ...)` with any token.
 2. The terminal accepts the token (supports ERC-20 approvals, Permit2, and credit transfers).
 3. If the input is a JB project token (ERC-20 or credits), it recursively cashes out through the source project's terminals until reaching a base token.
-4. It resolves which token the destination project accepts, checking: metadata override (`routeTokenOut`), direct acceptance, NATIVE/WETH equivalence, then dynamic pool discovery across all terminals.
+4. It resolves which token the destination project accepts, checking: metadata override (`routeTokenOut`), direct acceptance only if the chosen terminal exposes non-empty accounting contexts for the project, NATIVE/WETH equivalence, then dynamic pool discovery across all terminals.
 5. If the resolved token differs from the input, it converts -- wrapping/unwrapping ETH/WETH, or swapping through the best Uniswap V3 or V4 pool.
 6. Slippage protection: the caller can pass a minimum output quote in metadata (`quoteForSwap` key), or the terminal calculates one using TWAP (V3) or spot price (V4) with a dynamic sigmoid slippage tolerance based on estimated price impact.
 7. The output tokens are forwarded to the project's primary terminal via `terminal.pay(...)` or `terminal.addToBalanceOf(...)`.
 
+### Previewing Payments
+
+`previewPayFor(...)` mirrors the router's payment routing logic and forwards the preview to the terminal that would ultimately receive the payment. When a swap is required, it returns the router's best estimate using the same pool-discovery and quote-selection logic used to derive execution bounds.
+
+- Direct routes are exact.
+- Native/WETH wrap-unwrap routes are exact.
+- Cashout-only routes are exact when the downstream cashout terminal exposes an exact preview surface.
+- Swap routes return best-effort estimates based on current pool state and any caller-provided `quoteForSwap` metadata.
+
 ```mermaid
 sequenceDiagram
     participant Frontend client
@@ -104,6 +119,7 @@ Key `foundry.toml` settings:
 - `solc = '0.8.26'`
 - `evm_version = 'cancun'` (required for Uniswap V4's transient storage)
 - `optimizer_runs = 200`
+- `via_ir = true` (required for `JBRouterTerminal` to fit under EIP-170)
 - `fuzz.runs = 4096`
 - `invariant.runs = 1024`, `invariant.depth = 100`
 
@@ -129,7 +145,8 @@ nana-router-terminal-v6/
 └── test/
     ├── RouterTerminal.t.sol              # Unit tests (mocked dependencies)
     ├── RouterTerminalRegistry.t.sol      # Registry unit tests
-    └── RouterTerminalFork.t.sol          # Fork tests against mainnet Uniswap pools
+    ├── RouterTerminalFork.t.sol          # Fork tests against mainnet Uniswap pools
+    └── RouterTerminalPreviewFork.t.sol   # Fork parity tests for previewPayFor
 ```
 
 ## Payment Metadata

package/RISKS.md

@@ -23,6 +23,13 @@
 - **Fee-on-transfer tokens unsupported.** `_acceptFundsFor` in the terminal uses balance-delta, but the registry does NOT. Fee-on-transfer tokens through the registry will mismatch.
 - **Credit cashout path.** `_acceptFundsFor` processes `cashOutSource` metadata to transfer credits from `_msgSender()`. Requires `TRANSFER_CREDITS` permission. If a user has this permission set broadly, any caller through the trusted forwarder could drain their credits.
 - **Registry owner.** Controls which terminals are allowlisted and sets the global default. Disallowing a terminal clears the default if it matches but does NOT clear per-project terminal settings already set to the disallowed terminal.
+- **Synthetic accounting contexts.** `JBRouterTerminal.accountingContextForTokenOf()` uses best-effort decimals for
+  routing discovery: native tokens use `18`, ERC-20s probe `IERC20Metadata.decimals()` when available, and broken or
+  non-standard tokens fall back to `18`. `JBRouterTerminalRegistry` simply forwards that context. This is safe for
+  routing discovery but unsafe for integrations that treat the router or registry as a truthful accounting source for
+  non-18-decimal assets. Lending and debt-normalization flows must point at a real terminal, not the router layer.
+  The router now refuses to treat a primary terminal as direct acceptance unless that terminal also exposes non-empty
+  accounting contexts for the project, so router-stack terminals do not win the direct-forward fast path.
 
 ## 4. DoS Vectors
 

package/SKILLS.md

@@ -8,8 +8,8 @@ Accept payments in any ERC-20 token (or native ETH), dynamically discover what t
 
 | 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, cashes out JB project tokens, forwards to the primary terminal. Implements `IJBTerminal`, `IJBPermitTerminal`, `IUniswapV3SwapCallback`, `IUnlockCallback`, `IJBRouterTerminal`. |
-| `JBRouterTerminalRegistry` | Proxy terminal routing `pay`/`addToBalanceOf` to a per-project or default `JBRouterTerminal`. Project owners can set and lock their terminal choice. Implements `IJBTerminal` via `IJBRouterTerminalRegistry`. |
+| `JBRouterTerminal` | Core terminal: accepts any token, previews payment routes with `previewPayFor`, discovers the best route to the destination project's accepted token, swaps via Uniswap V3 or V4, cashes out JB project tokens, and forwards to the primary terminal. Implements `IJBTerminal`, `IJBPermitTerminal`, `IUniswapV3SwapCallback`, `IUnlockCallback`, `IJBRouterTerminal`. |
+| `JBRouterTerminalRegistry` | Proxy terminal routing `pay`, `previewPayFor`, and `addToBalanceOf` to a per-project or default `JBRouterTerminal`. Project owners can set and lock their terminal choice. Implements `IJBTerminal` via `IJBRouterTerminalRegistry`. |
 
 ## Key Functions
 
@@ -18,6 +18,7 @@ Accept payments in any ERC-20 token (or native ETH), dynamically discover what t
 | Function | What it does |
 |----------|--------------|
 | `pay(projectId, token, amount, beneficiary, minReturnedTokens, memo, metadata)` | Accept any token, route to the destination project's accepted token (cashout, swap, wrap/unwrap, or direct), forward to the project's primary terminal. Returns project token count. |
+| `previewPayFor(projectId, token, amount, beneficiary, metadata)` | Preview the terminal and mint result that the current payment route would produce. Swap routes return best-effort estimates using the router's quote-selection logic. |
 | `addToBalanceOf(projectId, token, amount, shouldReturnHeldFees, memo, metadata)` | Same routing flow as `pay` but calls `terminal.addToBalanceOf(...)` instead of `terminal.pay(...)`. |
 | `discoverPool(normalizedTokenIn, normalizedTokenOut) -> IUniswapV3Pool` | Search V3 factory for highest-liquidity pool across 4 fee tiers. Returns the V3 pool (or zero address if V4 was better). |
 | `discoverBestPool(normalizedTokenIn, normalizedTokenOut) -> PoolInfo` | Discover best pool across both V3 and V4, comparing in-range liquidity. Returns `PoolInfo` indicating protocol version and pool details. |
@@ -26,13 +27,14 @@ Accept payments in any ERC-20 token (or native ETH), dynamically discover what t
 | `currentSurplusOf(...) -> uint256` | Always returns 0. This terminal holds no surplus. |
 | `uniswapV3SwapCallback(amount0Delta, amount1Delta, data)` | V3 swap callback. Verifies caller is a legitimate pool via the factory. Wraps ETH if needed and transfers input tokens to the pool. |
 | `unlockCallback(data) -> bytes` | V4 swap callback. Called by PoolManager during `unlock()`. Executes the swap, settles input, takes output, checks slippage. |
-| `supportsInterface(interfaceId) -> bool` | Returns true for `IJBTerminal`, `IJBPermitTerminal`, `IERC165`, `IJBPermissioned`. |
+| `supportsInterface(interfaceId) -> bool` | Returns true for `IJBTerminal`, `IJBPermitTerminal`, `IJBRouterTerminal`, `IERC165`, `IJBPermissioned`. |
 
 ### JBRouterTerminalRegistry
 
 | Function | What it does |
 |----------|--------------|
 | `pay(projectId, token, amount, beneficiary, minReturnedTokens, memo, metadata)` | Resolves the terminal for the project (per-project or default), accepts funds, forwards payment. |
+| `previewPayFor(projectId, token, amount, beneficiary, metadata)` | Resolves the terminal for the project (per-project or default) and forwards the payment preview. |
 | `addToBalanceOf(projectId, token, amount, shouldReturnHeldFees, memo, metadata)` | Same resolution and forwarding but for balance additions. |
 | `terminalOf(projectId) -> IJBTerminal` | Returns the terminal for the project, or `defaultTerminal` if none is set. |
 | `setTerminalFor(projectId, terminal)` | Route a project to a specific allowed router terminal. Requires `SET_ROUTER_TERMINAL` permission (ID 28). Reverts if locked or terminal not allowed. |
@@ -50,6 +52,7 @@ Accept payments in any ERC-20 token (or native ETH), dynamically discover what t
 | Function | What it does |
 |----------|--------------|
 | `_route(destProjectId, tokenIn, amount, metadata)` | Core routing logic. Detects JB project tokens, runs `_cashOutLoop` if needed, then resolves output token and converts. |
+| `_previewRoute(destProjectId, tokenIn, amount, metadata)` | View mirror of `_route`. Returns the terminal, token, and amount that the current payment route would use, estimating swap outputs from current quote data when needed. |
 | `_resolveTokenOut(projectId, tokenIn, metadata)` | Priority: 1) `routeTokenOut` metadata override, 2) direct acceptance, 3) NATIVE/WETH equivalence, 4) `_discoverAcceptedToken`. |
 | `_discoverAcceptedToken(projectId, tokenIn)` | Iterates all terminals and their accounting contexts for a project. Finds the accepted token with the deepest Uniswap pool. Falls back to the first accepted token if no pool exists. |
 | `_convert(tokenIn, tokenOut, amount, projectId, metadata)` | No-op if same token, wrap/unwrap for NATIVE/WETH, or swap via `_handleSwap`. |
@@ -175,6 +178,7 @@ Accept payments in any ERC-20 token (or native ETH), dynamically discover what t
 - **V3 TWAP**: Reverts with `JBRouterTerminal_NoObservationHistory()` when a V3 pool has no observation history. The TWAP window is capped by the pool's oldest observation if shorter than 10 minutes.
 - **V4 spot price**: V4 vanilla pools have no built-in TWAP oracle. The terminal uses the current spot tick with the same sigmoid slippage formula.
 - **V4 requires cancun EVM**: Chains without EIP-1153 (transient storage) cannot use V4 routing. If `POOL_MANAGER` is `address(0)`, V4 discovery is skipped entirely.
+- **Preview estimates**: `previewPayFor()` returns exact values for direct and wrap-unwrap routes, and best-effort estimates for swap routes using current pool state or caller-provided quotes.
 - The `JBRouterTerminalRegistry` handles token custody during delegation -- it transfers tokens from the payer to itself, then approves and forwards to the underlying terminal.
 - `_msgSender()` (ERC-2771) is used instead of `msg.sender` for meta-transaction compatibility in both contracts.
 - The `JBSwapLib` library contains slippage tolerance math (sigmoid formula), price impact estimation, and V3-compatible `sqrtPriceLimitX96` calculation. It does not contain swap execution logic.

package/USER_JOURNEYS.md

@@ -2,6 +2,10 @@
 
 Every path a user or integrated contract can take through the router terminal.
 
+The journeys below describe payment routing behavior. They should not be read as proof that the router terminal or
+registry is a truthful accounting source for arbitrary tokens. Both surfaces report synthetic accounting contexts with
+`decimals = 18`, so any integration that depends on real token decimals must query a real terminal instead.
+
 ---
 
 ## Journey 1: Pay a Project Through the Router Terminal
@@ -162,6 +166,46 @@ Same as Journey 1. Additionally:
 
 ---
 
+## Journey 2A: Preview a Payment Through the Router Terminal
+
+The caller asks what a payment would do without moving funds.
+
+### Entry Point
+
+```solidity
+function previewPayFor(
+    uint256 projectId,
+    address token,
+    uint256 amount,
+    address beneficiary,
+    bytes calldata metadata
+)
+    external
+    view
+    returns (
+        JBRuleset memory ruleset,
+        uint256 beneficiaryTokenCount,
+        uint256 reservedTokenCount,
+        JBPayHookSpecification[] memory hookSpecifications
+    )
+```
+
+### Behavior
+
+1. `_previewAcceptFundsFor()` mirrors the router's source-of-funds logic in view context.
+2. `_previewRoute()` mirrors `_route()` and determines which terminal would ultimately receive the payment.
+3. If the route is direct or wrap-unwrap, the router forwards an exact preview to that destination terminal.
+4. If the route requires a swap, the router estimates the output using current quote data, then forwards that best-effort preview to the destination terminal.
+
+### Exactness Boundary
+
+- **Direct forwarding:** exact
+- **Native/WETH wrap-unwrap:** exact
+- **Cashout-only routes:** exact when the downstream cashout terminal exposes an exact preview surface
+- **Swap routes:** best-effort estimates using current pool state and any caller-provided `quoteForSwap`
+
+---
+
 ## Journey 3: Pay a Project Through the Registry
 
 The registry resolves which router terminal instance a project uses, then forwards the payment.
@@ -196,6 +240,42 @@ function pay(
 
 ---
 
+## Journey 3A: Preview a Payment Through the Registry
+
+The registry resolves which router terminal instance a project uses, then forwards the preview.
+
+### Entry Point
+
+```solidity
+// On JBRouterTerminalRegistry:
+function previewPayFor(
+    uint256 projectId,
+    address token,
+    uint256 amount,
+    address beneficiary,
+    bytes calldata metadata
+)
+    external
+    view
+    returns (
+        JBRuleset memory ruleset,
+        uint256 beneficiaryTokenCount,
+        uint256 reservedTokenCount,
+        JBPayHookSpecification[] memory hookSpecifications
+    )
+```
+
+### State Changes
+
+None. The registry resolves `_terminalOf[projectId]`, falling back to `defaultTerminal`, then forwards `previewPayFor()` to the resolved router terminal.
+
+### Edge Cases
+
+- **No terminal set and no default:** The preview will revert when forwarded to `address(0)`.
+- **Estimated downstream route:** The resolved router terminal may return a best-effort swap estimate rather than an execution-exact value.
+
+---
+
 ## Journey 4: Add to a Project's Balance Through the Registry
 
 ### Entry Point

package/foundry.toml

@@ -2,6 +2,7 @@
 solc = '0.8.26'
 evm_version = 'cancun'
 optimizer_runs = 200
+via_ir = true
 libs = ["node_modules", "lib"]
 fs_permissions = [{ access = "read-write", path = "./"}]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/router-terminal-v6",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
     "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.17",
+    "@bananapus/core-v6": "^0.0.23",
     "@bananapus/permission-ids-v6": "^0.0.10",
     "@openzeppelin/contracts": "^5.6.1",
     "@uniswap/permit2": "github:Uniswap/permit2",