@bananapus/core-v6 0.0.24 → 0.0.25

package/test/audit/USDTVoidReturnCompat.t.sol

@@ -0,0 +1,519 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+// Import the shared base test workflow that deploys all core Juicebox contracts.
+import {TestBaseWorkflow} from "../helpers/TestBaseWorkflow.sol";
+// Import the void-returning USDT mock token.
+import {MockUSDT} from "../mock/MockUSDT.sol";
+// Import the approval hook interface needed for ruleset configuration.
+import {IJBRulesetApprovalHook} from "../../src/interfaces/IJBRulesetApprovalHook.sol";
+// Import the split hook interface needed for split configuration.
+import {IJBSplitHook} from "../../src/interfaces/IJBSplitHook.sol";
+// Import constants used for fee maximums, native token address, and split percentages.
+import {JBConstants} from "../../src/libraries/JBConstants.sol";
+// Import the metadata resolver to pack/unpack ruleset metadata bits.
+import {JBRulesetMetadataResolver} from "../../src/libraries/JBRulesetMetadataResolver.sol";
+// Import the ruleset struct used to read current ruleset state.
+import {JBRuleset} from "../../src/structs/JBRuleset.sol";
+// Import currency amount struct for payout/surplus limit configuration.
+import {JBCurrencyAmount} from "../../src/structs/JBCurrencyAmount.sol";
+// Import fund access limit group struct for payout limit configuration.
+import {JBFundAccessLimitGroup} from "../../src/structs/JBFundAccessLimitGroup.sol";
+// Import ruleset config struct for project launch configuration.
+import {JBRulesetConfig} from "../../src/structs/JBRulesetConfig.sol";
+// Import ruleset metadata struct for per-ruleset settings.
+import {JBRulesetMetadata} from "../../src/structs/JBRulesetMetadata.sol";
+// Import split struct for defining payout split recipients.
+import {JBSplit} from "../../src/structs/JBSplit.sol";
+// Import split group struct for grouping splits by token.
+import {JBSplitGroup} from "../../src/structs/JBSplitGroup.sol";
+// Import terminal config struct for linking terminals to accounting contexts.
+import {JBTerminalConfig} from "../../src/structs/JBTerminalConfig.sol";
+// Import accounting context struct for token acceptance configuration.
+import {JBAccountingContext} from "../../src/structs/JBAccountingContext.sol";
+
+/// @notice Tests that USDT-style void-returning ERC-20 tokens work with JBMultiTerminal.
+/// @dev USDT's transfer/transferFrom/approve return void instead of bool. The terminal
+/// uses SafeERC20 which handles void returns, and Permit2 which uses low-level calls.
+/// These tests prove the full pay -> payout -> cashOut lifecycle works with such tokens.
+contract USDTVoidReturnCompat is TestBaseWorkflow {
+    // Use the metadata resolver library on ruleset structs.
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    // The USDT mock token instance used across all tests.
+    MockUSDT public usdt;
+    // The project owner address (multisig from the base workflow).
+    address public projectOwner;
+    // The address that receives split payouts in test scenarios.
+    address public splitBeneficiary;
+
+    function setUp() public override {
+        // Deploy all core Juicebox contracts via the base workflow.
+        super.setUp();
+        // Use the multisig as the project owner for test projects.
+        projectOwner = multisig();
+        // Create a dedicated address for receiving split payouts.
+        splitBeneficiary = address(0xBEEF);
+        // Deploy the void-returning USDT mock.
+        usdt = new MockUSDT();
+        // Label the USDT contract for clearer trace output.
+        vm.label(address(usdt), "MockUSDT");
+        // Launch the fee-collector project (project #1) required by the protocol.
+        _launchFeeProject();
+    }
+
+    // =========================================================================
+    //  Fee project helper — project #1 collects protocol fees
+    // =========================================================================
+
+    /// @notice Deploys project #1 which receives protocol fees.
+    function _launchFeeProject() internal {
+        // Create a single-element array for the fee project's ruleset configuration.
+        JBRulesetConfig[] memory feeRulesetConfig = new JBRulesetConfig[](1);
+        // The fee project starts immediately (no delay).
+        feeRulesetConfig[0].mustStartAtOrAfter = 0;
+        // Duration of 0 means the ruleset never expires automatically.
+        feeRulesetConfig[0].duration = 0;
+        // Set the weight to 1000 tokens per unit paid, scaled to 18 decimals.
+        feeRulesetConfig[0].weight = 1000e18;
+        // No weight decay between cycles.
+        feeRulesetConfig[0].weightCutPercent = 0;
+        // No approval hook required for this ruleset.
+        feeRulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        // Configure metadata: minimal settings, accept accounting contexts.
+        feeRulesetConfig[0].metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: false,
+            allowSetCustomToken: false,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+        // No splits for the fee project.
+        feeRulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        // No fund access limits for the fee project.
+        feeRulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        // Configure the terminal to accept native ETH tokens.
+        JBTerminalConfig[] memory termConfigs = new JBTerminalConfig[](1);
+        // Create accounting context for native token with 18 decimals.
+        JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
+        tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        // Link the terminal to the accounting context.
+        termConfigs[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: tokensToAccept});
+
+        // Launch project #1 as the fee collector.
+        jbController()
+            .launchProjectFor({
+                owner: address(420),
+                projectUri: "feeCollector",
+                rulesetConfigurations: feeRulesetConfig,
+                terminalConfigurations: termConfigs,
+                memo: ""
+            });
+    }
+
+    // =========================================================================
+    //  Test 1: Pay into a project with void-returning MockUSDT
+    // =========================================================================
+
+    /// @notice Verifies that paying with a void-returning token succeeds.
+    /// @dev The terminal uses SafeERC20 which correctly handles tokens that return no data.
+    function test_usdt_void_return_pay() public {
+        // Launch a project that accepts USDT.
+        uint256 pid = _launchUSDTProject();
+        // Use a dedicated payer address.
+        address payer = address(0xBA1E);
+        // Mint 1000 USDT (6 decimals) to the payer.
+        uint256 payAmount = 1000e6;
+        usdt.mint(payer, payAmount);
+
+        // Approve the terminal to spend the payer's USDT via Permit2.
+        vm.prank(payer);
+        // Approve Permit2 contract to pull USDT from the payer.
+        usdt.approve(address(permit2()), payAmount);
+
+        // Grant Permit2 allowance for the terminal to pull tokens.
+        vm.prank(payer);
+        permit2().approve(address(usdt), address(jbMultiTerminal()), uint160(payAmount), type(uint48).max);
+
+        // Execute the payment — this is the critical call that must handle void returns.
+        vm.prank(payer);
+        uint256 tokensReceived = jbMultiTerminal()
+            .pay({
+                projectId: pid,
+                token: address(usdt),
+                amount: payAmount,
+                beneficiary: payer,
+                minReturnedTokens: 0,
+                memo: "",
+                metadata: new bytes(0)
+            });
+
+        // Verify the payer received project tokens in exchange for the payment.
+        assertTrue(tokensReceived > 0, "Payer should receive project tokens from USDT payment");
+
+        // Verify the terminal recorded the balance correctly.
+        uint256 recordedBalance = jbTerminalStore().balanceOf(address(jbMultiTerminal()), pid, address(usdt));
+        // The recorded balance should equal the full payment amount (no transfer fee).
+        assertEq(recordedBalance, payAmount, "Terminal should record the full USDT pay amount");
+    }
+
+    // =========================================================================
+    //  Test 2: Execute a split payout that sends MockUSDT to a beneficiary
+    // =========================================================================
+
+    /// @notice Verifies that split payouts work with void-returning tokens.
+    /// @dev Split payouts go through executePayout -> _transferFrom -> SafeERC20.safeTransfer
+    /// which handles void returns by checking returndata length.
+    function test_usdt_void_return_split_payout() public {
+        // Launch a project with a split that pays out to splitBeneficiary.
+        uint256 pid = _launchUSDTProjectWithSplit();
+        // Use a dedicated payer address.
+        address payer = address(0xBA1E);
+        // Mint 1000 USDT to the payer.
+        uint256 payAmount = 1000e6;
+        usdt.mint(payer, payAmount);
+
+        // Approve Permit2 to pull USDT from payer.
+        vm.prank(payer);
+        usdt.approve(address(permit2()), payAmount);
+
+        // Grant Permit2 allowance for the terminal.
+        vm.prank(payer);
+        permit2().approve(address(usdt), address(jbMultiTerminal()), uint160(payAmount), type(uint48).max);
+
+        // Pay into the project to fund it.
+        vm.prank(payer);
+        jbMultiTerminal()
+            .pay({
+                projectId: pid,
+                token: address(usdt),
+                amount: payAmount,
+                beneficiary: payer,
+                minReturnedTokens: 0,
+                memo: "",
+                metadata: new bytes(0)
+            });
+
+        // Record the split beneficiary's USDT balance before the payout.
+        uint256 beneficiaryBefore = usdt.balanceOf(splitBeneficiary);
+
+        // Execute the payout — sends USDT through the split to the beneficiary.
+        vm.prank(projectOwner);
+        jbMultiTerminal()
+            .sendPayoutsOf({
+                projectId: pid,
+                token: address(usdt),
+                amount: 500e6,
+                currency: uint32(uint160(address(usdt))),
+                minTokensPaidOut: 0
+            });
+
+        // Calculate how much USDT the beneficiary actually received.
+        uint256 beneficiaryAfter = usdt.balanceOf(splitBeneficiary);
+        uint256 received = beneficiaryAfter - beneficiaryBefore;
+
+        // The beneficiary should have received tokens (less fees).
+        assertTrue(received > 0, "Split beneficiary should receive USDT from payout");
+    }
+
+    // =========================================================================
+    //  Test 3: Cash out project tokens for MockUSDT reclaim
+    // =========================================================================
+
+    /// @notice Verifies that cashing out tokens reclaims void-returning USDT.
+    /// @dev The cashOut flow uses _transferFrom -> SafeERC20.safeTransfer on the outbound side.
+    function test_usdt_void_return_cashOut() public {
+        // Launch a project that accepts USDT with 0% cashout tax for full reclaim.
+        uint256 pid = _launchUSDTProject();
+        // Use a dedicated payer address.
+        address payer = address(0xBA1E);
+        // Mint 1000 USDT to the payer.
+        uint256 payAmount = 1000e6;
+        usdt.mint(payer, payAmount);
+
+        // Approve Permit2 to pull USDT from payer.
+        vm.prank(payer);
+        usdt.approve(address(permit2()), payAmount);
+
+        // Grant Permit2 allowance for the terminal.
+        vm.prank(payer);
+        permit2().approve(address(usdt), address(jbMultiTerminal()), uint160(payAmount), type(uint48).max);
+
+        // Pay into the project to receive project tokens.
+        vm.prank(payer);
+        uint256 tokensReceived = jbMultiTerminal()
+            .pay({
+                projectId: pid,
+                token: address(usdt),
+                amount: payAmount,
+                beneficiary: payer,
+                minReturnedTokens: 0,
+                memo: "",
+                metadata: new bytes(0)
+            });
+
+        // Record the payer's USDT balance before cashing out.
+        uint256 payerBefore = usdt.balanceOf(payer);
+
+        // Cash out all project tokens to reclaim USDT.
+        vm.prank(payer);
+        uint256 reclaimAmount = jbMultiTerminal()
+            .cashOutTokensOf({
+                holder: payer,
+                projectId: pid,
+                cashOutCount: tokensReceived,
+                tokenToReclaim: address(usdt),
+                minTokensReclaimed: 0,
+                beneficiary: payable(payer),
+                metadata: new bytes(0)
+            });
+
+        // Calculate how much USDT the payer actually received back.
+        uint256 payerAfter = usdt.balanceOf(payer);
+        uint256 actualReclaimed = payerAfter - payerBefore;
+
+        // The reclaim amount should be positive (some goes to fees at 0% tax rate).
+        assertTrue(reclaimAmount > 0, "CashOut should reclaim USDT tokens");
+        // The payer should have received the reclaimed USDT.
+        assertEq(actualReclaimed, reclaimAmount, "Payer should receive the full reclaim amount");
+    }
+
+    // =========================================================================
+    //  Test 4: Full lifecycle — pay, payout, cashOut in sequence
+    // =========================================================================
+
+    /// @notice End-to-end test: pay with USDT, distribute payout, then cash out remainder.
+    /// @dev Proves the entire lifecycle works without reverting for void-returning tokens.
+    function test_usdt_void_return_full_lifecycle() public {
+        // Launch a project with splits and payout limits.
+        uint256 pid = _launchUSDTProjectWithSplit();
+        // Use a dedicated payer address.
+        address payer = address(0xBA1E);
+        // Mint 2000 USDT to the payer.
+        uint256 payAmount = 2000e6;
+        usdt.mint(payer, payAmount);
+
+        // Approve Permit2 to pull USDT from payer.
+        vm.prank(payer);
+        usdt.approve(address(permit2()), payAmount);
+
+        // Grant Permit2 allowance for the terminal.
+        vm.prank(payer);
+        permit2().approve(address(usdt), address(jbMultiTerminal()), uint160(payAmount), type(uint48).max);
+
+        // Step 1: Pay into the project.
+        vm.prank(payer);
+        uint256 tokensReceived = jbMultiTerminal()
+            .pay({
+                projectId: pid,
+                token: address(usdt),
+                amount: payAmount,
+                beneficiary: payer,
+                minReturnedTokens: 0,
+                memo: "",
+                metadata: new bytes(0)
+            });
+        // Verify payment succeeded by checking tokens were minted.
+        assertTrue(tokensReceived > 0, "Step 1: Payer should receive project tokens");
+
+        // Step 2: Distribute payouts through splits.
+        vm.prank(projectOwner);
+        jbMultiTerminal()
+            .sendPayoutsOf({
+                projectId: pid,
+                token: address(usdt),
+                amount: 500e6,
+                currency: uint32(uint160(address(usdt))),
+                minTokensPaidOut: 0
+            });
+        // Verify the split beneficiary received USDT.
+        assertTrue(usdt.balanceOf(splitBeneficiary) > 0, "Step 2: Split beneficiary should have USDT");
+
+        // Step 3: Cash out remaining project tokens.
+        vm.prank(payer);
+        uint256 reclaimAmount = jbMultiTerminal()
+            .cashOutTokensOf({
+                holder: payer,
+                projectId: pid,
+                cashOutCount: tokensReceived,
+                tokenToReclaim: address(usdt),
+                minTokensReclaimed: 0,
+                beneficiary: payable(payer),
+                metadata: new bytes(0)
+            });
+        // Verify the payer got USDT back from cashing out.
+        assertTrue(reclaimAmount > 0, "Step 3: CashOut should return USDT to payer");
+    }
+
+    // =========================================================================
+    //  Internal helpers
+    // =========================================================================
+
+    /// @notice Launches a project that accepts MockUSDT with no splits and no payout limits.
+    function _launchUSDTProject() internal returns (uint256) {
+        // Create a single-element array for the ruleset configuration.
+        JBRulesetConfig[] memory rulesetConfig = new JBRulesetConfig[](1);
+        // Start immediately.
+        rulesetConfig[0].mustStartAtOrAfter = 0;
+        // Non-expiring ruleset.
+        rulesetConfig[0].duration = 0;
+        // Weight scaled to 18 decimals for token issuance calculations.
+        rulesetConfig[0].weight = 1000e18;
+        // No weight decay.
+        rulesetConfig[0].weightCutPercent = 0;
+        // No approval hook.
+        rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        // Configure metadata: use USDT as base currency, 0% cashout tax.
+        rulesetConfig[0].metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(address(usdt))),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+        // No splits.
+        rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        // No fund access limits.
+        rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        // Configure the terminal to accept MockUSDT with 6 decimals.
+        JBTerminalConfig[] memory termConfigs = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
+        // Set up the accounting context for USDT: 6 decimals, currency = token address.
+        tokensToAccept[0] =
+            JBAccountingContext({token: address(usdt), decimals: 6, currency: uint32(uint160(address(usdt)))});
+        // Link the terminal to the USDT accounting context.
+        termConfigs[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: tokensToAccept});
+
+        // Launch the project and return its ID.
+        return jbController()
+            .launchProjectFor({
+                owner: projectOwner,
+                projectUri: "usdtProject",
+                rulesetConfigurations: rulesetConfig,
+                terminalConfigurations: termConfigs,
+                memo: ""
+            });
+    }
+
+    /// @notice Launches a project that accepts MockUSDT with a 100% split to splitBeneficiary.
+    function _launchUSDTProjectWithSplit() internal returns (uint256) {
+        // Create a single-element array for the ruleset configuration.
+        JBRulesetConfig[] memory rulesetConfig = new JBRulesetConfig[](1);
+        // Start immediately.
+        rulesetConfig[0].mustStartAtOrAfter = 0;
+        // Non-expiring ruleset.
+        rulesetConfig[0].duration = 0;
+        // Weight scaled to 18 decimals.
+        rulesetConfig[0].weight = 1000e18;
+        // No weight decay.
+        rulesetConfig[0].weightCutPercent = 0;
+        // No approval hook.
+        rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        // Configure metadata: USDT base currency, 0% cashout tax, 0% reserved.
+        rulesetConfig[0].metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(address(usdt))),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            allowSetCustomToken: true,
+            allowTerminalMigration: false,
+            allowSetTerminals: false,
+            ownerMustSendPayouts: false,
+            allowSetController: false,
+            allowAddAccountingContext: true,
+            allowAddPriceFeed: false,
+            holdFees: false,
+            useTotalSurplusForCashOuts: false,
+            useDataHookForPay: false,
+            useDataHookForCashOut: false,
+            dataHook: address(0),
+            metadata: 0
+        });
+
+        // Create a split that sends 100% of payouts to splitBeneficiary.
+        JBSplit[] memory splits = new JBSplit[](1);
+        splits[0] = JBSplit({
+            percent: uint32(JBConstants.SPLITS_TOTAL_PERCENT),
+            projectId: 0,
+            beneficiary: payable(splitBeneficiary),
+            preferAddToBalance: false,
+            lockedUntil: 0,
+            hook: IJBSplitHook(address(0))
+        });
+        // Group the splits under the USDT token's group ID (token address as uint256).
+        JBSplitGroup[] memory splitGroups = new JBSplitGroup[](1);
+        splitGroups[0] = JBSplitGroup({groupId: uint256(uint160(address(usdt))), splits: splits});
+        // Assign the split groups to the ruleset.
+        rulesetConfig[0].splitGroups = splitGroups;
+
+        // Configure a payout limit of 500 USDT so sendPayoutsOf can distribute funds.
+        JBCurrencyAmount[] memory payoutLimits = new JBCurrencyAmount[](1);
+        payoutLimits[0] = JBCurrencyAmount({amount: uint224(500e6), currency: uint32(uint160(address(usdt)))});
+        // Create the fund access limit group linking the terminal, token, and payout limit.
+        JBFundAccessLimitGroup[] memory fundAccessLimitGroups = new JBFundAccessLimitGroup[](1);
+        fundAccessLimitGroups[0] = JBFundAccessLimitGroup({
+            terminal: address(jbMultiTerminal()),
+            token: address(usdt),
+            payoutLimits: payoutLimits,
+            surplusAllowances: new JBCurrencyAmount[](0)
+        });
+        // Assign the fund access limit groups to the ruleset.
+        rulesetConfig[0].fundAccessLimitGroups = fundAccessLimitGroups;
+
+        // Configure the terminal to accept MockUSDT with 6 decimals.
+        JBTerminalConfig[] memory termConfigs = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
+        // USDT accounting context: 6 decimals, currency keyed to token address.
+        tokensToAccept[0] =
+            JBAccountingContext({token: address(usdt), decimals: 6, currency: uint32(uint160(address(usdt)))});
+        // Link terminal to accounting context.
+        termConfigs[0] = JBTerminalConfig({terminal: jbMultiTerminal(), accountingContextsToAccept: tokensToAccept});
+
+        // Launch the project with splits and payout limits, return its ID.
+        return jbController()
+            .launchProjectFor({
+                owner: projectOwner,
+                projectUri: "usdtSplitProject",
+                rulesetConfigurations: rulesetConfig,
+                terminalConfigurations: termConfigs,
+                memo: ""
+            });
+    }
+
+    // Allow the test contract to receive native ETH (required for some test helpers).
+    receive() external payable {}
+}

package/test/fork/TestChainlinkPriceFeedFork.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {Test} from "forge-std/Test.sol";
 

package/test/fork/TestSequencerPriceFeedFork.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {Test} from "forge-std/Test.sol";
 

package/test/fork/TestTerminalPreviewParityFork.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.26;
+pragma solidity ^0.8.28;
 
 import {TestTerminalPreviewParity_Local} from "../TestTerminalPreviewParity.sol";
 import {IJBTerminal} from "../../src/interfaces/IJBTerminal.sol";

package/test/helpers/JBTest.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {JBRuleset} from "../../src/structs/JBRuleset.sol";
 import {JBRulesetMetadata} from "../../src/structs/JBRulesetMetadata.sol";

package/test/helpers/MetadataResolverHelper.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {JBMetadataResolver} from "../../src/libraries/JBMetadataResolver.sol";
 

package/test/mock/MockERC20.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 

package/test/mock/MockMaliciousBeneficiary.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {Test} from "forge-std/Test.sol";
 import {JBTerminalStore} from "../../src/JBTerminalStore.sol";

package/test/mock/MockMaliciousSplitHook.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {IJBSplitHook} from "../../src/interfaces/IJBSplitHook.sol";
 import {JBSplitHookContext} from "../../src/structs/JBSplitHookContext.sol";

package/test/mock/MockPriceFeed.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.28;
 
 import {IJBPriceFeed} from "../../src/interfaces/IJBPriceFeed.sol";
 

package/test/mock/MockUSDT.sol

@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+/// @notice Mimics Tether (USDT) whose transfer/transferFrom/approve return void instead of bool.
+/// @dev Uses inline assembly to return empty data (no bool), matching USDT's on-chain behavior.
+/// This breaks naive IERC20 callers that expect a bool return value.
+contract MockUSDT {
+    // Token metadata matching USDT's 6-decimal convention.
+    string public name = "Mock Tether USD";
+    // Short ticker symbol for the mock token.
+    string public symbol = "USDT";
+    // USDT uses 6 decimals, not 18 like most ERC-20 tokens.
+    uint8 public decimals = 6;
+    // Running total of all minted tokens.
+    uint256 public totalSupply;
+
+    // Maps each address to its token balance.
+    mapping(address => uint256) public balanceOf;
+    // Maps owner => spender => allowance for delegated transfers.
+    mapping(address => mapping(address => uint256)) public allowance;
+
+    /// @notice Mints tokens to a recipient (test helper, not part of USDT interface).
+    /// @param to The address to receive newly minted tokens.
+    /// @param amount The number of tokens to mint.
+    function mint(address to, uint256 amount) external {
+        // Credit the recipient's balance with the minted amount.
+        balanceOf[to] += amount;
+        // Increase the total supply to reflect the new tokens.
+        totalSupply += amount;
+    }
+
+    /// @notice Sets the spender's allowance. Returns VOID like real USDT.
+    /// @param spender The address authorized to spend tokens.
+    /// @param amount The maximum amount the spender can transfer.
+    function approve(address spender, uint256 amount) external {
+        // Record the new allowance for the caller-spender pair.
+        allowance[msg.sender][spender] = amount;
+        // Use assembly to return without any data (void), matching USDT behavior.
+        assembly {
+            return(0, 0)
+        }
+    }
+
+    /// @notice Transfers tokens from caller to recipient. Returns VOID like real USDT.
+    /// @param to The address to receive the tokens.
+    /// @param amount The number of tokens to transfer.
+    function transfer(address to, uint256 amount) external {
+        // Ensure the sender has enough tokens to cover the transfer.
+        require(balanceOf[msg.sender] >= amount, "MockUSDT: insufficient balance");
+        // Debit the sender's balance by the transfer amount.
+        balanceOf[msg.sender] -= amount;
+        // Credit the recipient's balance with the transferred tokens.
+        balanceOf[to] += amount;
+        // Use assembly to return without any data (void), matching USDT behavior.
+        assembly {
+            return(0, 0)
+        }
+    }
+
+    /// @notice Transfers tokens on behalf of an owner. Returns VOID like real USDT.
+    /// @param from The address whose tokens are being spent.
+    /// @param to The address to receive the tokens.
+    /// @param amount The number of tokens to transfer.
+    function transferFrom(address from, address to, uint256 amount) external {
+        // Ensure the owner has enough tokens for the transfer.
+        require(balanceOf[from] >= amount, "MockUSDT: insufficient balance");
+        // Ensure the caller is authorized to spend at least this amount.
+        require(allowance[from][msg.sender] >= amount, "MockUSDT: insufficient allowance");
+        // Reduce the caller's remaining allowance by the transferred amount.
+        allowance[from][msg.sender] -= amount;
+        // Debit the owner's balance by the transfer amount.
+        balanceOf[from] -= amount;
+        // Credit the recipient's balance with the transferred tokens.
+        balanceOf[to] += amount;
+        // Use assembly to return without any data (void), matching USDT behavior.
+        assembly {
+            return(0, 0)
+        }
+    }
+}