@rev-net/core-v6 0.0.33 → 0.0.35

package/test/TestHiddenTokens.t.sol

@@ -171,6 +171,8 @@ contract TestHiddenTokens is TestBaseWorkflow {
 
         uint256 totalSupplyBefore = jbController().TOKENS().totalSupplyOf(REVNET_ID);
 
+        _allowHolderToHide(USER, REVNET_ID);
+
         // Hide half the tokens.
         uint256 hideCount = userTokens / 2;
         vm.prank(USER);
@@ -202,23 +204,23 @@ contract TestHiddenTokens is TestBaseWorkflow {
         uint256 userTokensBefore = jbController().TOKENS().totalBalanceOf(USER, REVNET_ID);
         uint256 totalSupplyBefore = jbController().TOKENS().totalSupplyOf(REVNET_ID);
 
+        _allowHolderToHide(USER, REVNET_ID);
+
         // Hide tokens.
         uint256 hideCount = userTokensBefore / 2;
         vm.prank(USER);
         HIDDEN_TOKENS.hideTokensOf(REVNET_ID, hideCount, USER);
 
-        // Reveal tokens to beneficiary.
+        // Reveal tokens back to USER.
         vm.prank(USER);
-        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hideCount, BENEFICIARY, USER);
+        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hideCount, USER);
 
         uint256 totalSupplyAfter = jbController().TOKENS().totalSupplyOf(REVNET_ID);
         assertEq(totalSupplyAfter, totalSupplyBefore, "Total supply should be restored");
         assertEq(HIDDEN_TOKENS.hiddenBalanceOf(USER, REVNET_ID), 0, "Hidden balance should be zero");
         assertEq(HIDDEN_TOKENS.totalHiddenOf(REVNET_ID), 0, "Total hidden should be zero");
         assertEq(
-            jbController().TOKENS().totalBalanceOf(BENEFICIARY, REVNET_ID),
-            hideCount,
-            "Beneficiary should receive tokens"
+            jbController().TOKENS().totalBalanceOf(USER, REVNET_ID), userTokensBefore, "User should receive tokens"
         );
     }
 
@@ -242,6 +244,8 @@ contract TestHiddenTokens is TestBaseWorkflow {
         uint256 userTokens = jbController().TOKENS().totalBalanceOf(USER, REVNET_ID);
         uint256 hideCount = userTokens / 4;
 
+        _allowHolderToHide(USER, REVNET_ID);
+
         // Hide some tokens.
         vm.prank(USER);
         HIDDEN_TOKENS.hideTokensOf(REVNET_ID, hideCount, USER);
@@ -253,7 +257,7 @@ contract TestHiddenTokens is TestBaseWorkflow {
                 REVHiddenTokens.REVHiddenTokens_InsufficientHiddenBalance.selector, hideCount, hideCount + 1
             )
         );
-        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hideCount + 1, USER, USER);
+        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hideCount + 1, USER);
     }
 
     // ──────────────────── Test: Hidden tokens inflate cash out rate
@@ -275,6 +279,8 @@ contract TestHiddenTokens is TestBaseWorkflow {
 
         uint256 userTokens = jbController().TOKENS().totalBalanceOf(USER, REVNET_ID);
 
+        _allowHolderToHide(USER, REVNET_ID);
+
         // Hide half the user's tokens.
         uint256 hideCount = userTokens / 2;
         vm.prank(USER);
@@ -305,6 +311,8 @@ contract TestHiddenTokens is TestBaseWorkflow {
 
         uint256 userTokens = jbController().TOKENS().totalBalanceOf(USER, REVNET_ID);
 
+        _allowHolderToHide(USER, REVNET_ID);
+
         vm.prank(USER);
         vm.expectEmit(true, false, false, true);
         emit IREVHiddenTokens.HideTokens(REVNET_ID, userTokens, USER, USER);
@@ -326,13 +334,43 @@ contract TestHiddenTokens is TestBaseWorkflow {
 
         uint256 userTokens = jbController().TOKENS().totalBalanceOf(USER, REVNET_ID);
 
+        _allowHolderToHide(USER, REVNET_ID);
+
         vm.prank(USER);
         HIDDEN_TOKENS.hideTokensOf(REVNET_ID, userTokens, USER);
 
         vm.prank(USER);
         vm.expectEmit(true, false, false, true);
-        emit IREVHiddenTokens.RevealTokens(REVNET_ID, userTokens, BENEFICIARY, USER, USER);
-        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, userTokens, BENEFICIARY, USER);
+        emit IREVHiddenTokens.RevealTokens(REVNET_ID, userTokens, USER, USER);
+        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, userTokens, USER);
+    }
+
+    function test_setTokenHidingAllowedFor_allowsHolderToHide() public {
+        uint256 payAmount = 10e18;
+
+        vm.prank(USER);
+        jbMultiTerminal().pay{value: payAmount}({
+            projectId: REVNET_ID,
+            token: JBConstants.NATIVE_TOKEN,
+            amount: payAmount,
+            beneficiary: USER,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: ""
+        });
+
+        uint256 userTokens = jbController().TOKENS().totalBalanceOf(USER, REVNET_ID);
+        uint256 hideCount = userTokens / 2;
+
+        _allowHolderToHide(USER, REVNET_ID);
+
+        vm.prank(USER);
+        HIDDEN_TOKENS.hideTokensOf(REVNET_ID, hideCount, USER);
+
+        vm.prank(USER);
+        HIDDEN_TOKENS.revealTokensOf(REVNET_ID, hideCount, USER);
+
+        assertEq(jbController().TOKENS().totalBalanceOf(USER, REVNET_ID), userTokens, "User balance should be restored");
     }
 
     // ──────────────────── Internal helpers
@@ -351,6 +389,11 @@ contract TestHiddenTokens is TestBaseWorkflow {
         jbPermissions().setPermissionsFor(account, permissionsData);
     }
 
+    function _allowHolderToHide(address holder, uint256 revnetId) internal {
+        vm.prank(address(REV_DEPLOYER));
+        HIDDEN_TOKENS.setTokenHidingAllowedFor(revnetId, holder, true);
+    }
+
     function _deployFeeProject() internal {
         JBAccountingContext[] memory acc = new JBAccountingContext[](1);
         acc[0] = JBAccountingContext({

package/test/TestTerminalEncodingInHash.t.sol

@@ -0,0 +1,326 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "forge-std/Test.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import /* {*} from */ "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import /* {*} from */ "./../src/REVDeployer.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "@croptop/core-v6/src/CTPublisher.sol";
+import {REVEmpty721Config} from "./helpers/REVEmpty721Config.sol";
+
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "@bananapus/core-v6/script/helpers/CoreDeploymentLib.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "@bananapus/721-hook-v6/script/helpers/Hook721DeploymentLib.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "@bananapus/suckers-v6/script/helpers/SuckerDeploymentLib.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "@croptop/core-v6/script/helpers/CroptopDeploymentLib.sol";
+// forge-lint: disable-next-line(unaliased-plain-import)
+import "@bananapus/router-terminal-v6/script/helpers/RouterTerminalDeploymentLib.sol";
+
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBAccountingContext} from "@bananapus/core-v6/src/structs/JBAccountingContext.sol";
+import {REVLoans} from "../src/REVLoans.sol";
+import {REVStageConfig, REVAutoIssuance} from "../src/structs/REVStageConfig.sol";
+import {REVDescription} from "../src/structs/REVDescription.sol";
+import {IREVLoans} from "./../src/interfaces/IREVLoans.sol";
+import {JBSuckerDeployerConfig} from "@bananapus/suckers-v6/src/structs/JBSuckerDeployerConfig.sol";
+import {JBSuckerRegistry} from "@bananapus/suckers-v6/src/JBSuckerRegistry.sol";
+import {JB721TiersHookDeployer} from "@bananapus/721-hook-v6/src/JB721TiersHookDeployer.sol";
+import {JB721TiersHook} from "@bananapus/721-hook-v6/src/JB721TiersHook.sol";
+import {JB721TiersHookStore} from "@bananapus/721-hook-v6/src/JB721TiersHookStore.sol";
+import {JB721CheckpointsDeployer} from "@bananapus/721-hook-v6/src/JB721CheckpointsDeployer.sol";
+import {IJB721CheckpointsDeployer} from "@bananapus/721-hook-v6/src/interfaces/IJB721CheckpointsDeployer.sol";
+import {JBAddressRegistry} from "@bananapus/address-registry-v6/src/JBAddressRegistry.sol";
+import {IJBAddressRegistry} from "@bananapus/address-registry-v6/src/interfaces/IJBAddressRegistry.sol";
+import {REVOwner} from "../src/REVOwner.sol";
+import {IREVDeployer} from "../src/interfaces/IREVDeployer.sol";
+import {MockSuckerRegistry} from "./mock/MockSuckerRegistry.sol";
+import {MockBuybackDataHook} from "./mock/MockBuybackDataHook.sol";
+
+/// @notice Tests that terminal addresses are included in the encoded configuration hash.
+contract TestTerminalEncodingInHash is TestBaseWorkflow {
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    // forge-lint: disable-next-line(mixed-case-variable)
+    bytes32 REV_DEPLOYER_SALT = "REVDeployer";
+
+    // forge-lint: disable-next-line(mixed-case-variable)
+    REVDeployer REV_DEPLOYER;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    REVOwner REV_OWNER;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    IJB721TiersHookDeployer HOOK_DEPLOYER;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    IJB721TiersHookStore HOOK_STORE;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    IJBAddressRegistry ADDRESS_REGISTRY;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    IREVLoans LOANS_CONTRACT;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    IJBSuckerRegistry SUCKER_REGISTRY;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    CTPublisher PUBLISHER;
+    // forge-lint: disable-next-line(mixed-case-variable)
+    MockBuybackDataHook MOCK_BUYBACK;
+
+    // forge-lint: disable-next-line(mixed-case-variable)
+    uint256 FEE_PROJECT_ID;
+
+    address private constant TRUSTED_FORWARDER = 0xB2b5841DBeF766d4b521221732F9B618fCf34A87;
+
+    function setUp() public override {
+        super.setUp();
+
+        FEE_PROJECT_ID = jbProjects().createFor(multisig());
+
+        SUCKER_REGISTRY = new JBSuckerRegistry(jbDirectory(), jbPermissions(), multisig(), address(0));
+        HOOK_STORE = new JB721TiersHookStore();
+        JB721TiersHook exampleHook = new JB721TiersHook(
+            jbDirectory(),
+            jbPermissions(),
+            jbPrices(),
+            jbRulesets(),
+            HOOK_STORE,
+            jbSplits(),
+            IJB721CheckpointsDeployer(address(new JB721CheckpointsDeployer())),
+            multisig()
+        );
+        ADDRESS_REGISTRY = new JBAddressRegistry();
+        HOOK_DEPLOYER = new JB721TiersHookDeployer(exampleHook, HOOK_STORE, ADDRESS_REGISTRY, multisig());
+        PUBLISHER = new CTPublisher(jbDirectory(), jbPermissions(), FEE_PROJECT_ID, multisig());
+        MOCK_BUYBACK = new MockBuybackDataHook();
+
+        LOANS_CONTRACT = new REVLoans({
+            controller: jbController(),
+            suckerRegistry: IJBSuckerRegistry(address(new MockSuckerRegistry())),
+            revId: FEE_PROJECT_ID,
+            owner: address(this),
+            permit2: permit2(),
+            trustedForwarder: TRUSTED_FORWARDER
+        });
+
+        REV_OWNER = new REVOwner(
+            IJBBuybackHookRegistry(address(MOCK_BUYBACK)),
+            jbDirectory(),
+            FEE_PROJECT_ID,
+            SUCKER_REGISTRY,
+            address(LOANS_CONTRACT),
+            address(0)
+        );
+
+        REV_DEPLOYER = new REVDeployer{salt: REV_DEPLOYER_SALT}(
+            jbController(),
+            SUCKER_REGISTRY,
+            FEE_PROJECT_ID,
+            HOOK_DEPLOYER,
+            PUBLISHER,
+            IJBBuybackHookRegistry(address(MOCK_BUYBACK)),
+            address(LOANS_CONTRACT),
+            TRUSTED_FORWARDER,
+            address(REV_OWNER)
+        );
+
+        REV_OWNER.setDeployer(REV_DEPLOYER);
+
+        vm.prank(multisig());
+        jbProjects().approve(address(REV_DEPLOYER), FEE_PROJECT_ID);
+
+        // Deploy fee project.
+        _deployFeeProject();
+    }
+
+    /// @notice Two revnets with identical base config but different terminals produce different hashes.
+    function test_differentTerminals_produceDifferentHashes() public {
+        // Deploy revnet A with the primary multi-terminal (same description salt for both).
+        (uint256 revnetA,) = REV_DEPLOYER.deployFor({
+            revnetId: 0,
+            configuration: _baseRevConfig("DIFF_TERM"),
+            terminalConfigurations: _terminalConfigs(jbMultiTerminal()),
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256("A")
+            }),
+            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
+            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
+        });
+
+        // Deploy revnet B with the secondary multi-terminal (same config, only terminal differs).
+        (uint256 revnetB,) = REV_DEPLOYER.deployFor({
+            revnetId: 0,
+            configuration: _baseRevConfig("DIFF_TERM"),
+            terminalConfigurations: _terminalConfigs(jbMultiTerminal2()),
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256("B")
+            }),
+            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
+            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
+        });
+
+        bytes32 hashA = REV_DEPLOYER.hashedEncodedConfigurationOf(revnetA);
+        bytes32 hashB = REV_DEPLOYER.hashedEncodedConfigurationOf(revnetB);
+
+        assertNotEq(hashA, hashB, "Different terminals must produce different configuration hashes");
+    }
+
+    /// @notice The hash includes the terminal address — verify by computing it off-chain.
+    function test_hashIncludesTerminalAddress() public {
+        // Deploy a revnet.
+        (uint256 revnetId,) = REV_DEPLOYER.deployFor({
+            revnetId: 0,
+            configuration: _baseRevConfig("VERIFY"),
+            terminalConfigurations: _terminalConfigs(jbMultiTerminal()),
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256("VERIFY")
+            }),
+            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
+            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
+        });
+
+        // Recompute the expected hash manually.
+        bytes memory encodedConfiguration = abi.encode(
+            uint32(uint160(JBConstants.NATIVE_TOKEN)), // baseCurrency
+            "Terminal Test", // name
+            "TERM", // ticker
+            bytes32("VERIFY") // salt
+        );
+        // Terminal address encoding.
+        encodedConfiguration = abi.encode(encodedConfiguration, jbMultiTerminal());
+        // Stage encoding.
+        encodedConfiguration = abi.encode(
+            encodedConfiguration,
+            block.timestamp, // startsAtOrAfter
+            uint256(0), // splitPercent
+            uint112(1000e18), // initialIssuance
+            uint256(0), // issuanceCutFrequency
+            uint256(0), // issuanceCutPercent
+            uint256(5000) // cashOutTaxRate
+        );
+        bytes32 expectedHash = keccak256(encodedConfiguration);
+
+        assertEq(
+            REV_DEPLOYER.hashedEncodedConfigurationOf(revnetId),
+            expectedHash,
+            "On-chain hash must match off-chain computation including terminal address"
+        );
+    }
+
+    /// @notice Terminal ordering matters — [A, B] != [B, A].
+    function test_terminalOrder_affectsHash() public {
+        // Deploy revnet with terminals in order [main, alt].
+        JBTerminalConfig[] memory tcAB = new JBTerminalConfig[](2);
+        JBAccountingContext[] memory acc = new JBAccountingContext[](1);
+        acc[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        tcAB[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: acc});
+        tcAB[1] = JBTerminalConfig({terminal: jbMultiTerminal2(), accountingContextsToAccept: acc});
+
+        (uint256 revnetAB,) = REV_DEPLOYER.deployFor({
+            revnetId: 0,
+            configuration: _baseRevConfig("ORDER"),
+            terminalConfigurations: tcAB,
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256("AB")
+            }),
+            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
+            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
+        });
+
+        // Deploy revnet with terminals in order [alt, main].
+        JBTerminalConfig[] memory tcBA = new JBTerminalConfig[](2);
+        tcBA[0] = JBTerminalConfig({terminal: jbMultiTerminal2(), accountingContextsToAccept: acc});
+        tcBA[1] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: acc});
+
+        (uint256 revnetBA,) = REV_DEPLOYER.deployFor({
+            revnetId: 0,
+            configuration: _baseRevConfig("ORDER"),
+            terminalConfigurations: tcBA,
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256("BA")
+            }),
+            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
+            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
+        });
+
+        bytes32 hashAB = REV_DEPLOYER.hashedEncodedConfigurationOf(revnetAB);
+        bytes32 hashBA = REV_DEPLOYER.hashedEncodedConfigurationOf(revnetBA);
+
+        assertNotEq(hashAB, hashBA, "Terminal order must affect the configuration hash");
+    }
+
+    // ─── Helpers
+    // ───────────────────────────────────────────────────────────────
+    // //
+
+    function _baseRevConfig(bytes32 salt) internal view returns (REVConfig memory) {
+        REVStageConfig[] memory stages = new REVStageConfig[](1);
+        stages[0] = REVStageConfig({
+            startsAtOrAfter: uint48(block.timestamp),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 0,
+            splits: new JBSplit[](0),
+            initialIssuance: uint112(1000e18),
+            issuanceCutFrequency: 0,
+            issuanceCutPercent: 0,
+            cashOutTaxRate: 5000,
+            extraMetadata: 0
+        });
+        return REVConfig({
+            description: REVDescription("Terminal Test", "TERM", "", salt),
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            splitOperator: multisig(),
+            stageConfigurations: stages
+        });
+    }
+
+    function _terminalConfigs(IJBMultiTerminal terminal) internal pure returns (JBTerminalConfig[] memory tc) {
+        JBAccountingContext[] memory acc = new JBAccountingContext[](1);
+        acc[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        tc = new JBTerminalConfig[](1);
+        tc[0] = JBTerminalConfig({terminal: terminal, accountingContextsToAccept: acc});
+    }
+
+    function _deployFeeProject() internal {
+        JBAccountingContext[] memory acc = new JBAccountingContext[](1);
+        acc[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        JBTerminalConfig[] memory tc = new JBTerminalConfig[](1);
+        tc[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: acc});
+        REVStageConfig[] memory stages = new REVStageConfig[](1);
+        stages[0] = REVStageConfig({
+            startsAtOrAfter: uint48(block.timestamp),
+            autoIssuances: new REVAutoIssuance[](0),
+            splitPercent: 0,
+            splits: new JBSplit[](0),
+            initialIssuance: uint112(1000e18),
+            issuanceCutFrequency: 0,
+            issuanceCutPercent: 0,
+            cashOutTaxRate: 0,
+            extraMetadata: 0
+        });
+        REVConfig memory feeConfig = REVConfig({
+            description: REVDescription("Fee Project", "FEE", "", bytes32("FEE")),
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            splitOperator: multisig(),
+            stageConfigurations: stages
+        });
+        vm.prank(multisig());
+        REV_DEPLOYER.deployFor({
+            revnetId: FEE_PROJECT_ID,
+            configuration: feeConfig,
+            terminalConfigurations: tc,
+            suckerDeploymentConfiguration: REVSuckerDeploymentConfig({
+                deployerConfigurations: new JBSuckerDeployerConfig[](0), salt: keccak256("FEE")
+            }),
+            tiered721HookConfiguration: REVEmpty721Config.empty721Config(uint32(uint160(JBConstants.NATIVE_TOKEN))),
+            allowedPosts: REVEmpty721Config.emptyAllowedPosts()
+        });
+    }
+}

package/test/audit/CodexCrossChainBuybackRouteMismatch.t.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import "forge-std/Test.sol";
+import "@bananapus/core-v6/test/helpers/TestBaseWorkflow.sol";
+import {IJBBuybackHookRegistry} from "@bananapus/buyback-hook-v6/src/interfaces/IJBBuybackHookRegistry.sol";
+import {IJBCashOutHook} from "@bananapus/core-v6/src/interfaces/IJBCashOutHook.sol";
+import {IJBRulesetDataHook} from "@bananapus/core-v6/src/interfaces/IJBRulesetDataHook.sol";
+import {JBConstants} from "@bananapus/core-v6/src/libraries/JBConstants.sol";
+import {JBCashOuts} from "@bananapus/core-v6/src/libraries/JBCashOuts.sol";
+import {JBBeforeCashOutRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforeCashOutRecordedContext.sol";
+import {JBCashOutHookSpecification} from "@bananapus/core-v6/src/structs/JBCashOutHookSpecification.sol";
+import {JBBeforePayRecordedContext} from "@bananapus/core-v6/src/structs/JBBeforePayRecordedContext.sol";
+import {JBPayHookSpecification} from "@bananapus/core-v6/src/structs/JBPayHookSpecification.sol";
+import {JBTokenAmount} from "@bananapus/core-v6/src/structs/JBTokenAmount.sol";
+import {JBRuleset} from "@bananapus/core-v6/src/structs/JBRuleset.sol";
+import {IJBSuckerRegistry} from "@bananapus/suckers-v6/src/interfaces/IJBSuckerRegistry.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+import {REVOwner} from "../../src/REVOwner.sol";
+
+contract ConfigurableSuckerRegistry {
+    uint256 public remoteSupply;
+    uint256 public remoteSurplus;
+
+    function setRemoteTotals(uint256 supply, uint256 surplus) external {
+        remoteSupply = supply;
+        remoteSurplus = surplus;
+    }
+
+    function isSuckerOf(uint256, address) external pure returns (bool) {
+        return false;
+    }
+
+    function remoteTotalSupplyOf(uint256) external view returns (uint256) {
+        return remoteSupply;
+    }
+
+    function remoteSurplusOf(uint256, uint256, uint256) external view returns (uint256) {
+        return remoteSurplus;
+    }
+}
+
+contract ThresholdBuybackRegistry is IJBRulesetDataHook {
+    uint256 public immutable minimumSwapAmountOut;
+
+    constructor(uint256 minAmountOut) {
+        minimumSwapAmountOut = minAmountOut;
+    }
+
+    function beforeCashOutRecordedWith(JBBeforeCashOutRecordedContext calldata context)
+        external
+        view
+        returns (
+            uint256 cashOutTaxRate,
+            uint256 cashOutCount,
+            uint256 totalSupply,
+            uint256 effectiveSurplusValue,
+            JBCashOutHookSpecification[] memory hookSpecifications
+        )
+    {
+        uint256 directCashOutAmount = JBCashOuts.cashOutFrom({
+            surplus: context.surplus.value,
+            cashOutCount: context.cashOutCount,
+            totalSupply: context.totalSupply,
+            cashOutTaxRate: context.cashOutTaxRate
+        });
+
+        hookSpecifications = new JBCashOutHookSpecification[](1);
+        hookSpecifications[0] = JBCashOutHookSpecification({
+            hook: IJBCashOutHook(address(this)),
+            noop: directCashOutAmount >= minimumSwapAmountOut,
+            amount: 0,
+            metadata: ""
+        });
+
+        cashOutTaxRate =
+            directCashOutAmount >= minimumSwapAmountOut ? context.cashOutTaxRate : JBConstants.MAX_CASH_OUT_TAX_RATE;
+        cashOutCount = context.cashOutCount;
+        totalSupply = context.totalSupply;
+        effectiveSurplusValue = 0;
+    }
+
+    function beforePayRecordedWith(JBBeforePayRecordedContext calldata context)
+        external
+        pure
+        returns (uint256 weight, JBPayHookSpecification[] memory hookSpecifications)
+    {
+        weight = context.weight;
+        hookSpecifications = new JBPayHookSpecification[](0);
+    }
+
+    function hasMintPermissionFor(uint256, JBRuleset calldata, address) external pure returns (bool) {
+        return false;
+    }
+
+    function setPoolFor(uint256, PoolKey calldata, uint256, address) external pure {}
+
+    function setPoolFor(uint256, uint24, int24, uint256, address) external pure {}
+
+    function initializePoolFor(uint256, uint24, int24, uint256, address, uint160) external pure {}
+
+    function supportsInterface(bytes4 interfaceId) external pure returns (bool) {
+        return interfaceId == type(IJBRulesetDataHook).interfaceId || interfaceId == type(IERC165).interfaceId;
+    }
+}
+
+contract CodexCrossChainBuybackRouteMismatchTest is TestBaseWorkflow {
+    REVOwner internal ownerHook;
+    ConfigurableSuckerRegistry internal suckerRegistry;
+    ThresholdBuybackRegistry internal buybackRegistry;
+
+    function setUp() public override {
+        super.setUp();
+
+        suckerRegistry = new ConfigurableSuckerRegistry();
+        buybackRegistry = new ThresholdBuybackRegistry(50 ether);
+
+        ownerHook = new REVOwner(
+            IJBBuybackHookRegistry(address(buybackRegistry)),
+            jbDirectory(),
+            999_999,
+            IJBSuckerRegistry(address(suckerRegistry)),
+            address(0),
+            address(0)
+        );
+    }
+
+    function test_buybackRouteUsesOmnichainContextForRouting() public {
+        suckerRegistry.setRemoteTotals(0, 900 ether);
+
+        JBBeforeCashOutRecordedContext memory context = JBBeforeCashOutRecordedContext({
+            terminal: address(jbMultiTerminal()),
+            holder: address(0xBEEF),
+            projectId: 1,
+            rulesetId: 0,
+            cashOutCount: 100,
+            totalSupply: 1000,
+            surplus: JBTokenAmount({
+                token: JBConstants.NATIVE_TOKEN,
+                value: 100 ether,
+                decimals: 18,
+                currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+            }),
+            useTotalSurplus: true,
+            cashOutTaxRate: 0,
+            beneficiaryIsFeeless: false,
+            metadata: ""
+        });
+
+        uint256 localDirectCashOut = JBCashOuts.cashOutFrom({
+            surplus: context.surplus.value,
+            cashOutCount: context.cashOutCount,
+            totalSupply: context.totalSupply,
+            cashOutTaxRate: context.cashOutTaxRate
+        });
+        uint256 omnichainDirectCashOut = JBCashOuts.cashOutFrom({
+            surplus: context.surplus.value + 900 ether,
+            cashOutCount: context.cashOutCount,
+            totalSupply: context.totalSupply,
+            cashOutTaxRate: context.cashOutTaxRate
+        });
+
+        assertLt(localDirectCashOut, 50 ether, "local route should prefer swap in the mock");
+        assertGe(omnichainDirectCashOut, 50 ether, "omnichain route should prefer direct reclaim");
+
+        (uint256 returnedTaxRate,, uint256 returnedSupply, uint256 returnedSurplus,) =
+            ownerHook.beforeCashOutRecordedWith(context);
+
+        // After the fix, REVOwner forwards the cross-chain-adjusted context to the buyback hook.
+        // The buyback hook now sees the full omnichain surplus (1000 ether) and correctly routes
+        // to direct reclaim (passthrough) instead of swap.
+        assertEq(returnedSupply, context.totalSupply, "owner returns cross-chain total supply");
+        assertEq(returnedSurplus, context.surplus.value + 900 ether, "owner returns cross-chain effective surplus");
+        // With omnichain context, the direct reclaim (100 ether) exceeds the threshold (50 ether),
+        // so the buyback hook chooses passthrough (returns the original cashOutTaxRate of 0).
+        assertEq(
+            returnedTaxRate,
+            context.cashOutTaxRate,
+            "routing correctly uses omnichain context - direct reclaim beats threshold"
+        );
+    }
+}