@bananapus/suckers-v6 0.0.30 → 0.0.31

package/RISKS.md

@@ -151,3 +151,11 @@ When the only available Uniswap pool for a cross-denomination swap is a hookless
 ### 10.9 Zero-value `prepare()` is allowed
 
 `prepare()` does not reject `projectTokenCount == 0`. A zero-value check would be trivially bypassed by passing `1` instead, so it provides no real protection against remap-window consumption. The cost to create a leaf with `projectTokenCount = 1` is negligible (1 wei of project tokens). The one-time remap window is protected by the token mapping's `enabled` flag and the outbox tree count, not by minimum deposit requirements.
+
+### 10.10 Cross-chain currency uses standardized `JBCurrencyIds.ETH` (1), not local token addresses
+
+Snapshot messages encode surplus and balance values using `JBCurrencyIds.ETH` (currency ID `1`) as the cross-chain currency identifier, not `uint32(uint160(JBConstants.NATIVE_TOKEN))` (currency ID `61166`). This is intentional: `NATIVE_TOKEN` (`0x000...EEEe`) is a local sentinel meaning "the native token on this chain," which may represent different assets on different networks (e.g., ETH on mainnet, MATIC on Polygon). A standardized semantic currency ID is required for cross-chain values to be comparable.
+
+On the consuming side, contracts like `REVOwner` and `REVLoans` query sucker-reported values using `uint32(uint160(NATIVE_TOKEN))` — the local terminal convention. The `JBPrices` oracle in `JBSuckerLib.convertPeerValue` resolves the conversion between currency ID `1` (ETH) and currency ID `61166` (native token) when a price feed is registered for the pair. If no feed exists, `convertPeerValue` returns `0`, which is acceptable: it means the project has not configured cross-chain pricing for that token pair, and remote values are simply not factored into local calculations.
+
+Projects that need accurate cross-chain surplus and supply accounting should register a price feed for the `1 ↔ 61166` pair via `JBPrices`. On chains where the native token is ETH, this is a 1:1 identity feed. On chains where the native token is not ETH, the feed should reflect the actual exchange rate.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/suckers-v6",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBArbitrumSucker.sol

@@ -206,8 +206,8 @@ contract JBArbitrumSucker is JBSucker, IJBArbitrumSucker {
             // slither-disable-next-line calls-loop,unused-return
             IArbL2GatewayRouter(address(GATEWAYROUTER))
                 .outboundTransfer({
-                    l1Token: _toAddress(remoteToken.addr), to: peerAddress, amount: amount, data: bytes("")
-                });
+                l1Token: _toAddress(remoteToken.addr), to: peerAddress, amount: amount, data: bytes("")
+            });
         } else {
             // Otherwise, the token is the native token, and the amount will be sent as `msg.value`.
             nativeValue = amount;
@@ -269,8 +269,7 @@ contract JBArbitrumSucker is JBSucker, IJBArbitrumSucker {
                     IL1ArbitrumGateway(gateway)
                 .getOutboundCalldata({
                     _token: token, _from: address(this), _to: _peerAddress(), _amount: amount, _data: bytes("")
-                })
-                .length;
+                }).length;
                 // slither-disable-next-line calls-loop
                 maxSubmissionCostERC20 = ARBINBOX.calculateRetryableSubmissionFee({
                     dataLength: outboundCalldataLength, baseFee: maxFeePerGas

package/src/JBSucker.sol

@@ -874,12 +874,12 @@ abstract contract JBSucker is ERC2771Context, JBPermissioned, Initializable, ERC
         // slither-disable-next-line calls-loop,unused-return
         IJBController(address(DIRECTORY.controllerOf(cachedProjectId)))
             .mintTokensOf({
-                projectId: cachedProjectId,
-                tokenCount: projectTokenAmount,
-                beneficiary: _toAddress(beneficiary),
-                memo: "",
-                useReservedPercent: false
-            });
+            projectId: cachedProjectId,
+            tokenCount: projectTokenAmount,
+            beneficiary: _toAddress(beneficiary),
+            memo: "",
+            useReservedPercent: false
+        });
     }
 
     /// @notice Inserts a new leaf into the outbox merkle tree for the specified `token`.

package/src/JBSwapCCIPSucker.sol

@@ -273,6 +273,7 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
 
             address localToken = _toAddress(root.token);
             uint256 localAmount;
+            bool swapFailed;
 
             if (any2EvmMessage.destTokenAmounts.length == 1) {
                 Client.EVMTokenAmount memory tokenAmount = any2EvmMessage.destTokenAmounts[0];
@@ -284,7 +285,7 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
                     // Swap bridge token -> local token via best V3/V4 pool.
                     // Wrapped in try-catch so a swap failure doesn't revert the entire CCIP message
                     // (which would leave tokens stuck in the OffRamp). On failure, bridge tokens are
-                    // stored for later retry via `retrySwap`.
+                    // stored for later retry via `retrySwap` (written below, after nonce validation).
                     // slither-disable-next-line reentrancy-benign,reentrancy-events
                     try this.executeSwapExternal({
                         tokenIn: tokenAmount.token, tokenOut: localToken, amount: tokenAmount.amount
@@ -293,59 +294,78 @@ contract JBSwapCCIPSucker is JBCCIPSucker, IUnlockCallback, IUniswapV3SwapCallba
                     ) {
                         localAmount = swapped;
                     } catch {
-                        // Store for later retry. Merkle root and batch range still get stored below.
-                        pendingSwapOf[localToken][root.remoteRoot.nonce] = PendingSwap({
-                            bridgeToken: tokenAmount.token, bridgeAmount: tokenAmount.amount, leafTotal: root.amount
-                        });
-                        // localAmount stays 0 — the conversion rate code below will set
-                        // localTotal: 0, gating claims until retrySwap succeeds.
+                        swapFailed = true;
+                        // localAmount stays 0 — pendingSwapOf and conversion rate are written
+                        // below, after fromRemote validates the nonce.
                     }
                 }
             }
 
-            // Record the batch range so _findNonceForLeafIndex can resolve leaf ownership
-            // independently of nonce ordering. Each nonce is self-describing: [start, end).
-            if (batchEnd > 0) {
-                _batchStartOf[localToken][root.remoteRoot.nonce] = batchStart;
-                _batchEndOf[localToken][root.remoteRoot.nonce] = batchEnd;
-                if (root.remoteRoot.nonce > _highestReceivedNonce[localToken]) {
-                    _highestReceivedNonce[localToken] = root.remoteRoot.nonce;
+            // Capture the inbox nonce before fromRemote to detect whether the root was accepted.
+            uint64 inboxNonceBefore = _inboxOf[localToken].nonce;
+
+            // Store the inbox merkle root for later claims.
+            // Must be called BEFORE writing batch metadata and conversion rates so that stale
+            // (duplicate/replayed) roots that fromRemote silently rejects do not overwrite
+            // metadata from the original accepted delivery.
+            this.fromRemote(root);
+
+            // Only write batch metadata and conversion rates if fromRemote accepted this root.
+            // fromRemote updates _inboxOf[localToken].nonce when the root's nonce is strictly
+            // greater than the current inbox nonce; stale roots are silently rejected.
+            // We detect acceptance by checking if the nonce actually changed.
+            if (_inboxOf[localToken].nonce > inboxNonceBefore) {
+                // Record the batch range so _findNonceForLeafIndex can resolve leaf ownership
+                // independently of nonce ordering. Each nonce is self-describing: [start, end).
+                if (batchEnd > 0) {
+                    _batchStartOf[localToken][root.remoteRoot.nonce] = batchStart;
+                    _batchEndOf[localToken][root.remoteRoot.nonce] = batchEnd;
+                    if (root.remoteRoot.nonce > _highestReceivedNonce[localToken]) {
+                        _highestReceivedNonce[localToken] = root.remoteRoot.nonce;
+                    }
                 }
-            }
 
-            // Zero-output swap guard: When a swap succeeds but returns zero local tokens, the
-            // batch must NOT be marked claimable. Without this guard, `_addToBalance` would see
-            // `pendingSwapOf.bridgeAmount == 0` (no pending swap stored) and allow claims to
-            // proceed — minting the full bridged project-token amount while adding zero terminal
-            // backing, breaking cross-chain solvency.
-            //
-            // Route zero-output swaps into `pendingSwapOf` so the swap can be retried via
-            // `retrySwap` once pool conditions improve. Only store the conversion rate when
-            // the swap produced a positive local amount.
-            if (root.amount > 0) {
-                if (localAmount == 0 && any2EvmMessage.destTokenAmounts.length == 1) {
-                    Client.EVMTokenAmount memory zeroSwapTokenAmount = any2EvmMessage.destTokenAmounts[0];
-                    // Only route to pending if there were actual bridge tokens delivered.
-                    // If bridgeAmount is also 0 (zero-value batch), store the conversion rate
-                    // normally — there is nothing to retry.
-                    if (zeroSwapTokenAmount.amount > 0) {
-                        pendingSwapOf[localToken][root.remoteRoot.nonce] = PendingSwap({
-                            bridgeToken: zeroSwapTokenAmount.token,
-                            bridgeAmount: zeroSwapTokenAmount.amount,
-                            leafTotal: root.amount
-                        });
+                // Store pendingSwapOf for failed swaps now that nonce is validated.
+                if (swapFailed) {
+                    Client.EVMTokenAmount memory failedTokenAmount = any2EvmMessage.destTokenAmounts[0];
+                    pendingSwapOf[localToken][root.remoteRoot.nonce] = PendingSwap({
+                        bridgeToken: failedTokenAmount.token,
+                        bridgeAmount: failedTokenAmount.amount,
+                        leafTotal: root.amount
+                    });
+                }
+
+                // Zero-output swap guard: When a swap succeeds but returns zero local tokens, the
+                // batch must NOT be marked claimable. Without this guard, `_addToBalance` would see
+                // `pendingSwapOf.bridgeAmount == 0` (no pending swap stored) and allow claims to
+                // proceed — minting the full bridged project-token amount while adding zero terminal
+                // backing, breaking cross-chain solvency.
+                //
+                // Route zero-output swaps into `pendingSwapOf` so the swap can be retried via
+                // `retrySwap` once pool conditions improve. Only store the conversion rate when
+                // the swap produced a positive local amount.
+                if (root.amount > 0 && !swapFailed) {
+                    if (localAmount == 0 && any2EvmMessage.destTokenAmounts.length == 1) {
+                        Client.EVMTokenAmount memory zeroSwapTokenAmount = any2EvmMessage.destTokenAmounts[0];
+                        // Only route to pending if there were actual bridge tokens delivered.
+                        // If bridgeAmount is also 0 (zero-value batch), store the conversion rate
+                        // normally — there is nothing to retry.
+                        if (zeroSwapTokenAmount.amount > 0) {
+                            pendingSwapOf[localToken][root.remoteRoot.nonce] = PendingSwap({
+                                bridgeToken: zeroSwapTokenAmount.token,
+                                bridgeAmount: zeroSwapTokenAmount.amount,
+                                leafTotal: root.amount
+                            });
+                        } else {
+                            _conversionRateOf[localToken][root.remoteRoot.nonce] =
+                                ConversionRate({leafTotal: root.amount, localTotal: 0});
+                        }
                     } else {
                         _conversionRateOf[localToken][root.remoteRoot.nonce] =
-                            ConversionRate({leafTotal: root.amount, localTotal: 0});
+                            ConversionRate({leafTotal: root.amount, localTotal: localAmount});
                     }
-                } else {
-                    _conversionRateOf[localToken][root.remoteRoot.nonce] =
-                        ConversionRate({leafTotal: root.amount, localTotal: localAmount});
                 }
             }
-
-            // Store the inbox merkle root for later claims.
-            this.fromRemote(root);
         } else {
             revert JBCCIPSucker_UnknownMessageType(messageType);
         }

package/src/libraries/JBSwapPoolLib.sol

@@ -183,40 +183,50 @@ library JBSwapPoolLib {
     /// @return Encoded output amount.
     function executeV4UnlockCallback(IPoolManager poolManager, bytes calldata data) external returns (bytes memory) {
         // Decode the swap parameters packed during _executeV4Swap.
-        (PoolKey memory key, bool zeroForOne, int256 amountSpecified, uint160 sqrtPriceLimitX96, uint256 minAmountOut) =
-            abi.decode(data, (PoolKey, bool, int256, uint160, uint256));
+        (
+            PoolKey memory key,
+            bool zeroForOne,
+            int256 amountSpecified,
+            uint160 sqrtPriceLimitX96,
+            uint256 minAmountOut,
+            address weth
+        ) = abi.decode(data, (PoolKey, bool, int256, uint160, uint256, address));
 
-        // Execute the swap through the V4 PoolManager.
-        BalanceDelta delta = poolManager.swap({
-            key: key,
-            params: SwapParams({
-                zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: sqrtPriceLimitX96
-            }),
-            hookData: ""
-        });
-
-        // V4 sign convention: negative = we owe (input), positive = we're owed (output).
-        int128 delta0 = delta.amount0();
-        int128 delta1 = delta.amount1();
         uint256 amountIn;
         uint256 amountOut;
 
-        // Extract input and output amounts based on swap direction.
-        if (zeroForOne) {
-            amountIn = uint256(uint128(-delta0));
-            amountOut = uint256(uint128(delta1));
-        } else {
-            amountIn = uint256(uint128(-delta1));
-            amountOut = uint256(uint128(delta0));
-        }
+        {
+            // Execute the swap through the V4 PoolManager.
+            BalanceDelta delta = poolManager.swap({
+                key: key,
+                params: SwapParams({
+                    zeroForOne: zeroForOne, amountSpecified: amountSpecified, sqrtPriceLimitX96: sqrtPriceLimitX96
+                }),
+                hookData: ""
+            });
 
-        // Enforce the minimum output from the TWAP quote.
-        if (amountOut < minAmountOut) revert JBSwapPoolLib_SlippageExceeded(amountOut, minAmountOut);
+            // V4 sign convention: negative = we owe (input), positive = we're owed (output).
+            int128 delta0 = delta.amount0();
+            int128 delta1 = delta.amount1();
+
+            // Extract input and output amounts based on swap direction.
+            if (zeroForOne) {
+                amountIn = uint256(uint128(-delta0));
+                amountOut = uint256(uint128(delta1));
+            } else {
+                amountIn = uint256(uint128(-delta1));
+                amountOut = uint256(uint128(delta0));
+            }
+
+            // Enforce the minimum output from the TWAP quote.
+            if (amountOut < minAmountOut) revert JBSwapPoolLib_SlippageExceeded(amountOut, minAmountOut);
+        }
 
         // Settle input (pay what we owe to the PoolManager).
         Currency inputCurrency = zeroForOne ? key.currency0 : key.currency1;
         if (Currency.unwrap(inputCurrency) == address(0)) {
-            // Native ETH: settle by sending ETH value directly.
+            // Native ETH: unwrap WETH if needed, then settle by sending ETH value directly.
+            if (weth != address(0)) IWrappedNativeToken(weth).withdraw(amountIn);
             // slither-disable-next-line unused-return,arbitrary-send-eth
             poolManager.settle{value: amountIn}();
         } else {
@@ -832,17 +842,22 @@ library JBSwapPoolLib {
         // Determine swap direction based on currency ordering in the pool key.
         bool zeroForOne = Currency.unwrap(key.currency0) == v4In;
 
-        // Compute the sqrt price limit from the expected amounts.
-        uint160 sqrtPriceLimitX96 = JBSwapLib.sqrtPriceLimitFromAmounts({
-            amountIn: amount, minimumAmountOut: minAmountOut, zeroForOne: zeroForOne
-        });
+        // Build the encoded unlock data in a scoped block to avoid stack-too-deep.
+        bytes memory unlockData;
+        {
+            // Compute the sqrt price limit from the expected amounts.
+            uint160 sqrtPriceLimitX96 = JBSwapLib.sqrtPriceLimitFromAmounts({
+                amountIn: amount, minimumAmountOut: minAmountOut, zeroForOne: zeroForOne
+            });
 
-        // V4 uses negative amounts for exact-input swaps.
-        int256 exactInputAmount = -int256(amount);
+            // V4 uses negative amounts for exact-input swaps.
+            int256 exactInputAmount = -int256(amount);
+
+            unlockData = abi.encode(key, zeroForOne, exactInputAmount, sqrtPriceLimitX96, minAmountOut, config.weth);
+        }
 
         // Unlock the PoolManager and encode the swap parameters for the callback.
-        bytes memory result =
-            config.poolManager.unlock(abi.encode(key, zeroForOne, exactInputAmount, sqrtPriceLimitX96, minAmountOut));
+        bytes memory result = config.poolManager.unlock(unlockData);
 
         // Decode the output amount returned by the unlock callback.
         amountOut = abi.decode(result, (uint256));

package/test/ForkArbitrum.t.sol

@@ -199,12 +199,12 @@ contract ForkArbitrumDeployerTest is TestBaseWorkflow, IERC721Receiver {
 
         jbController()
             .launchProjectFor({
-                owner: address(this),
-                projectUri: "arb-fork-test",
-                rulesetConfigurations: _rulesetConfigurations,
-                terminalConfigurations: _terminalConfigurations,
-                memo: ""
-            });
+            owner: address(this),
+            projectUri: "arb-fork-test",
+            rulesetConfigurations: _rulesetConfigurations,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
     }
 
     function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
@@ -340,12 +340,12 @@ contract ForkArbitrumNativeTransferTest is TestBaseWorkflow {
 
         jbController()
             .launchProjectFor({
-                owner: multisig(),
-                projectUri: "arb-native-fork-test",
-                rulesetConfigurations: _rulesetConfigurations,
-                terminalConfigurations: _terminalConfigurations,
-                memo: ""
-            });
+            owner: multisig(),
+            projectUri: "arb-native-fork-test",
+            rulesetConfigurations: _rulesetConfigurations,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
     }
 
     /// @notice Test native ETH transfer from L1 → Arbitrum L2 via the real Arbitrum inbox.

package/test/ForkCelo.t.sol

@@ -212,12 +212,12 @@ contract ForkCeloTest is TestBaseWorkflow {
 
         jbController()
             .launchProjectFor({
-                owner: multisig(),
-                projectUri: "celo-fork-test-native",
-                rulesetConfigurations: _rulesetConfigurations,
-                terminalConfigurations: _terminalConfigurations,
-                memo: ""
-            });
+            owner: multisig(),
+            projectUri: "celo-fork-test-native",
+            rulesetConfigurations: _rulesetConfigurations,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
     }
 
     /// @notice Launch a project on Celo that accepts WETH (ETH as ERC-20).
@@ -259,12 +259,12 @@ contract ForkCeloTest is TestBaseWorkflow {
 
         jbController()
             .launchProjectFor({
-                owner: multisig(),
-                projectUri: "celo-fork-test-weth",
-                rulesetConfigurations: _rulesetConfigurations,
-                terminalConfigurations: _terminalConfigurations,
-                memo: ""
-            });
+            owner: multisig(),
+            projectUri: "celo-fork-test-weth",
+            rulesetConfigurations: _rulesetConfigurations,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
     }
 
     // ── Tests

package/test/ForkClaimMainnet.t.sol

@@ -3,6 +3,7 @@ pragma solidity 0.8.28;
 
 // forge-lint: disable-next-line(unaliased-plain-import)
 import /* {*} from */ "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+import {SuckerForkHelpers} from "./helpers/SuckerForkHelpers.sol";
 import {IJBSucker} from "../src/interfaces/IJBSucker.sol";
 import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
 import {JBPermissionsData} from "@bananapus/core-v6/src/structs/JBPermissionsData.sol";
@@ -22,7 +23,7 @@ import {JBSucker} from "../src/JBSucker.sol";
 import "forge-std/Test.sol";
 import {JBCCIPSuckerDeployer} from "src/deployers/JBCCIPSuckerDeployer.sol";
 import {JBCCIPSucker} from "../src/JBCCIPSucker.sol";
-import {CCIPLocalSimulatorFork, Register} from "@chainlink/local/src/ccip/CCIPLocalSimulatorFork.sol";
+import {CCIPLocalSimulatorFork} from "@chainlink/local/src/ccip/CCIPLocalSimulatorFork.sol";
 import {CCIPHelper} from "../src/libraries/CCIPHelper.sol";
 
 /// @dev Captured leaf data from InsertToOutboxTree event.
@@ -39,9 +40,8 @@ struct LeafData {
 /// @dev Tests the full round-trip: pay → prepare → toRemote (L1) → manual ccipReceive → claim (L2).
 /// Uses the dual-fork pattern from ForkMainnet.t.sol (real CCIP router on send side) combined with
 /// the manual ccipReceive pattern from ForkSwapMainnet.t.sol (prank as router on receive side).
-abstract contract CCIPSuckerClaimForkTestBase is TestBaseWorkflow {
+abstract contract CCIPSuckerClaimForkTestBase is SuckerForkHelpers {
     CCIPLocalSimulatorFork ccipLocalSimulatorFork;
-    JBRulesetMetadata _metadata;
 
     JBCCIPSuckerDeployer suckerDeployerL1;
     JBCCIPSuckerDeployer suckerDeployerL2;
@@ -61,13 +61,6 @@ abstract contract CCIPSuckerClaimForkTestBase is TestBaseWorkflow {
     function _l1ForkBlock() internal pure virtual returns (uint256);
     function _l2ForkBlock() internal pure virtual returns (uint256);
 
-    // ── Token overrides (defaults: native token on both sides)
-    // ────────────────────────────────
-
-    function _terminalToken() internal view virtual returns (address) {
-        return JBConstants.NATIVE_TOKEN;
-    }
-
     function _remoteTerminalToken() internal view virtual returns (bytes32) {
         return bytes32(uint256(uint160(JBConstants.NATIVE_TOKEN)));
     }
@@ -77,83 +70,22 @@ abstract contract CCIPSuckerClaimForkTestBase is TestBaseWorkflow {
         return true;
     }
 
-    // ── LINK token addresses per mainnet chain
-    // ────────────────────────────────
-
-    function _linkTokenOf(uint256 chainId) internal pure returns (address) {
-        if (chainId == 1) return 0x514910771AF9Ca656af840dff83E8264EcF986CA;
-        if (chainId == 42_161) return 0xf97f4df75117a78c1A5a0DBb814Af92458539FB4;
-        if (chainId == 10) return 0x350a791Bfc2C21F9Ed5d10980Dad2e2638ffa7f6;
-        if (chainId == 8453) return 0x88Fb150BDc53A65fe94Dea0c9BA0a6dAf8C6e196;
-        if (chainId == 4217) return 0x15C03488B29e27d62BAf10E30b0c474bf60E0264;
-        revert("Unsupported chain for LINK token");
-    }
-
-    // ── Register mainnet network details
-    // ──────────────────────────────────
-
-    function _registerMainnetDetails(uint256 chainId) internal {
-        Register.NetworkDetails memory details = Register.NetworkDetails({
-            chainSelector: CCIPHelper.selectorOfChain(chainId),
-            routerAddress: CCIPHelper.routerOfChain(chainId),
-            linkAddress: _linkTokenOf(chainId),
-            wrappedNativeAddress: CCIPHelper.wethOfChain(chainId),
-            ccipBnMAddress: address(0),
-            ccipLnMAddress: address(0),
-            rmnProxyAddress: address(0),
-            registryModuleOwnerCustomAddress: address(0),
-            tokenAdminRegistryAddress: address(0)
-        });
-        ccipLocalSimulatorFork.setNetworkDetails(chainId, details);
-    }
-
-    /// @dev Deploy mock ERC20 at the terminal token address if it has no code on the current fork.
-    function _ensureTerminalTokenExists() internal {
-        address token = _terminalToken();
-        if (token != JBConstants.NATIVE_TOKEN && token.code.length == 0) {
-            vm.etch(token, CCIPHelper.wethOfChain(block.chainid).code);
-        }
-    }
-
     // ── Setup
     // ─────────────────────────────────────────────────────────────
 
     function setUp() public override {
         // ── L1
-        // ────────────────────────────────────────────────────────────
         l1Fork = vm.createSelectFork(_l1RpcUrl(), _l1ForkBlock());
         _ensureTerminalTokenExists();
 
         ccipLocalSimulatorFork = new CCIPLocalSimulatorFork();
         vm.makePersistent(address(ccipLocalSimulatorFork));
 
-        // Register mainnet network details (CCIPLocalSimulatorFork only ships with testnets).
-        _registerMainnetDetails(_l1ChainId());
-        _registerMainnetDetails(_l2ChainId());
-
-        _metadata = JBRulesetMetadata({
-            reservedPercent: JBConstants.MAX_RESERVED_PERCENT / 2,
-            cashOutTaxRate: 0,
-            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
-            pausePay: false,
-            pauseCreditTransfers: false,
-            allowOwnerMinting: true,
-            allowSetCustomToken: false,
-            allowTerminalMigration: false,
-            allowSetTerminals: false,
-            allowSetController: false,
-            allowAddAccountingContext: true,
-            allowAddPriceFeed: true,
-            ownerMustSendPayouts: false,
-            holdFees: false,
-            useTotalSurplusForCashOuts: true,
-            useDataHookForPay: false,
-            useDataHookForCashOut: false,
-            dataHook: address(0),
-            metadata: 0
-        });
+        _registerMainnetDetails(ccipLocalSimulatorFork, _l1ChainId());
+        _registerMainnetDetails(ccipLocalSimulatorFork, _l2ChainId());
+
+        _initMetadata();
 
-        // Deploy full JB infrastructure on L1.
         super.setUp();
         vm.stopPrank();
 
@@ -196,11 +128,9 @@ abstract contract CCIPSuckerClaimForkTestBase is TestBaseWorkflow {
         vm.stopPrank();
 
         // ── L2
-        // ────────────────────────────────────────────────────────────
         l2Fork = vm.createSelectFork(_l2RpcUrl(), _l2ForkBlock());
         _ensureTerminalTokenExists();
 
-        // Deploy full JB infrastructure on L2.
         super.setUp();
         vm.stopPrank();
 
@@ -243,51 +173,6 @@ abstract contract CCIPSuckerClaimForkTestBase is TestBaseWorkflow {
         vm.mockCall(address(0), abi.encodeCall(IJBSuckerRegistry.toRemoteFee, ()), abi.encode(uint256(0)));
     }
 
-    /// @notice Launch a project that accepts `_terminalToken()`.
-    function _launchProject() internal {
-        address token = _terminalToken();
-
-        // Ensure baseCurrency matches the terminal token so no price feed is needed.
-        _metadata.baseCurrency = uint32(uint160(token));
-
-        JBCurrencyAmount[] memory _surplusAllowances = new JBCurrencyAmount[](1);
-        _surplusAllowances[0] = JBCurrencyAmount({amount: 5 * 10 ** 18, currency: uint32(uint160(token))});
-
-        JBFundAccessLimitGroup[] memory _fundAccessLimitGroup = new JBFundAccessLimitGroup[](1);
-        _fundAccessLimitGroup[0] = JBFundAccessLimitGroup({
-            terminal: address(jbMultiTerminal()),
-            token: token,
-            payoutLimits: new JBCurrencyAmount[](0),
-            surplusAllowances: _surplusAllowances
-        });
-
-        JBRulesetConfig[] memory _rulesetConfigurations = new JBRulesetConfig[](1);
-        _rulesetConfigurations[0].mustStartAtOrAfter = 0;
-        _rulesetConfigurations[0].duration = 0;
-        _rulesetConfigurations[0].weight = 1000 * 10 ** 18;
-        _rulesetConfigurations[0].weightCutPercent = 0;
-        _rulesetConfigurations[0].approvalHook = IJBRulesetApprovalHook(address(0));
-        _rulesetConfigurations[0].metadata = _metadata;
-        _rulesetConfigurations[0].splitGroups = new JBSplitGroup[](0);
-        _rulesetConfigurations[0].fundAccessLimitGroups = _fundAccessLimitGroup;
-
-        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](1);
-        _tokensToAccept[0] = JBAccountingContext({token: token, decimals: 18, currency: uint32(uint160(token))});
-
-        JBTerminalConfig[] memory _terminalConfigurations = new JBTerminalConfig[](1);
-        _terminalConfigurations[0] =
-            JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: _tokensToAccept});
-
-        jbController()
-            .launchProjectFor({
-                owner: multisig(),
-                projectUri: "claim-fork-test",
-                rulesetConfigurations: _rulesetConfigurations,
-                terminalConfigurations: _terminalConfigurations,
-                memo: ""
-            });
-    }
-
     // ── Helpers
     // ─────────────────────────────────────────────────────────────