@bananapus/core-v6 0.0.52 → 0.0.54

package/src/interfaces/IJBCashOutTerminal.sol

@@ -9,39 +9,6 @@ import {JBRuleset} from "../structs/JBRuleset.sol";
 
 /// @notice A terminal that can be cashed out from.
 interface IJBCashOutTerminal is IJBTerminal {
-    /// @notice Atomically cash out a holder's tokens of one project and add the reclaim to another project's
-    /// balance (no project tokens minted on the destination side).
-    /// @dev Equivalent to calling `cashOutTokensOf` followed by `addToBalanceOf` on the destination project,
-    /// except the source-side cash out fee is skipped (the equivalent fee is bound on the destination
-    /// project's side instead). Held-fee return is hardcoded to `false` on the destination side — this
-    /// entrypoint is for value top-up only, not fee unlock.
-    /// @dev The destination terminal is whichever terminal the directory has registered as the beneficiary
-    /// project's primary terminal for `tokenToReclaim` (which may itself be a router that swaps before adding
-    /// to balance). Cashout-side hooks (if specified by the data hook) execute additively.
-    /// @dev Round-trip fee preservation is enforced by snapshotting the beneficiary project's
-    /// accounting-context balances on this terminal before and after the routing, and crediting
-    /// `_feeFreeSurplusOf` by the per-token delta on each context that grew. The beneficiary project's current
-    /// ruleset can set `pauseCrossProjectFeeFreeInflows` to opt out.
-    /// @param holder The address whose project tokens are being burned.
-    /// @param projectId The ID of the project whose project tokens are being burned.
-    /// @param cashOutCount The number of project tokens to burn.
-    /// @param tokenToReclaim The terminal token reclaimed from the source project's surplus.
-    /// @param beneficiaryProjectId The destination project receiving the reclaim.
-    /// @param cashOutMetadata Forwarded to the source project's data hook and any cashout hook specifications.
-    /// @param addToBalanceMetadata Forwarded to the destination project's `addToBalanceOf` event.
-    /// @return reclaimAmount The gross reclaim amount returned by the store.
-    function addToBalanceAfterCashOutTokensOf(
-        address holder,
-        uint256 projectId,
-        uint256 cashOutCount,
-        address tokenToReclaim,
-        uint256 beneficiaryProjectId,
-        bytes calldata cashOutMetadata,
-        bytes calldata addToBalanceMetadata
-    )
-        external
-        returns (uint256 reclaimAmount);
-
     /// @notice A cash out was processed for a project.
     /// @param rulesetId The ID of the ruleset during the cash out.
     /// @param rulesetCycleNumber The cycle number of the ruleset during the cash out.
@@ -129,39 +96,4 @@ interface IJBCashOutTerminal is IJBTerminal {
     )
         external
         returns (uint256 reclaimAmount);
-
-    /// @notice Atomically cash out a holder's tokens of one project and pay the reclaim into another. Equivalent
-    /// to calling `cashOutTokensOf` followed by `pay` on the destination project, except the source-side cash out
-    /// fee is skipped (the equivalent fee is bound on the destination project's side instead).
-    /// @dev The destination terminal is whichever terminal the directory has registered as the beneficiary project's
-    /// primary terminal for `tokenToReclaim` (which may itself be a router that swaps before paying). Cashout-side
-    /// hooks (if specified by the data hook) execute additively.
-    /// @dev Round-trip fee preservation is enforced by snapshotting the beneficiary project's accounting-context
-    /// balances on this terminal before and after the routing, and crediting `_feeFreeSurplusOf` by the per-token
-    /// delta on each context that grew. The beneficiary project's current ruleset can set
-    /// `pauseCrossProjectFeeFreeInflows` to opt out.
-    /// @param holder The address whose project tokens are being burned.
-    /// @param projectId The ID of the project whose project tokens are being burned.
-    /// @param cashOutCount The number of project tokens to burn.
-    /// @param tokenToReclaim The terminal token reclaimed from the source project's surplus.
-    /// @param beneficiaryProjectId The destination project.
-    /// @param beneficiary The address that receives the newly minted tokens of the destination project.
-    /// @param minTokensOut The minimum number of destination-project tokens that must be minted; reverts otherwise.
-    /// @param cashOutMetadata Forwarded to the source project's data hook and any cashout hook specifications.
-    /// @param payMetadata Forwarded to the destination project's pay flow.
-    /// @return reclaimAmount The gross reclaim amount returned by the store.
-    /// @return beneficiaryTokenCount The number of destination-project tokens minted to `beneficiary`.
-    function payAfterCashOutTokensOf(
-        address holder,
-        uint256 projectId,
-        uint256 cashOutCount,
-        address tokenToReclaim,
-        uint256 beneficiaryProjectId,
-        address beneficiary,
-        uint256 minTokensOut,
-        bytes calldata cashOutMetadata,
-        bytes calldata payMetadata
-    )
-        external
-        returns (uint256 reclaimAmount, uint256 beneficiaryTokenCount);
 }

package/src/interfaces/IJBFeeTerminal.sol

@@ -27,7 +27,7 @@ interface IJBFeeTerminal is IJBTerminal {
     /// @param projectId The ID of the project the fee was held for.
     /// @param token The token the fee is denominated in.
     /// @param amount The amount from which the fee was calculated.
-    /// @param fee The fee amount held.
+    /// @param fee The fee numerator used to calculate the held fee, out of `JBConstants.MAX_FEE`.
     /// @param beneficiary The address that will receive project tokens when the fee is processed.
     /// @param caller The address that triggered the fee hold.
     event HoldFee(

package/src/libraries/JBConstants.sol

@@ -18,12 +18,9 @@ library JBConstants {
     /// @notice The denominator for split percentages (9-decimal precision). A split of 1,000,000,000 = 100%.
     uint32 public constant SPLITS_TOTAL_PERCENT = 1_000_000_000;
 
-    /// @notice The fee denominator. The protocol fee is `FEE / MAX_FEE` (currently 25/1000 = 2.5%).
+    /// @notice The fee denominator. The protocol fee is `STANDARD_FEE / MAX_FEE`.
     uint16 public constant MAX_FEE = 1000;
 
-    /// @notice The fee numerator. The protocol fee is `FEE / MAX_FEE` = 25/1000 = 2.5%, charged on outflows.
-    uint16 public constant FEE = 25;
-
-    /// @notice The project ID that receives protocol fees. Should be the first project launched at deployment.
-    uint256 public constant FEE_BENEFICIARY_PROJECT_ID = 1;
+    /// @notice The standard protocol fee numerator. The protocol fee is `STANDARD_FEE / MAX_FEE` = 2.5%.
+    uint16 public constant STANDARD_FEE = 25;
 }

package/src/libraries/JBFees.sol

@@ -3,53 +3,48 @@ pragma solidity 0.8.28;
 
 import {mulDiv} from "@prb/math/src/Common.sol";
 
-import {JBConstants} from "./../libraries/JBConstants.sol";
+import {JBConstants} from "./JBConstants.sol";
 
 /// @notice Fee calculations.
 library JBFees {
-    /// @notice Returns the fee amount that, when added to `amountAfterFee`, produces the gross amount needed to yield
-    /// `amountAfterFee` after the fee is deducted.
-    /// @dev Use this to back-calculate the fee from a desired post-fee payout.
-    /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
-    /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
-    /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.
-    function feeAmountResultingIn(uint256 amountAfterFee, uint256 feePercent) internal pure returns (uint256) {
-        return mulDiv(amountAfterFee, JBConstants.MAX_FEE, JBConstants.MAX_FEE - feePercent) - amountAfterFee;
-    }
-
     /// @notice Returns the fee that would be taken from `amountBeforeFee`.
     /// @dev Use this to forward-calculate the fee from a known pre-fee amount.
     /// @dev Fee rounding error is bounded by N-1 wei (N = number of splits). Economically
     /// insignificant. Rounds down (mulDiv floors), so the fee beneficiary may receive up to 1 wei less per split.
     /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
     /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
-    /// @return The fee amount, as a fixed point number with the same number of decimals as the provided `amount`.
+    /// @return The fee amount, as a fixed point number with the same number of decimals as `amountBeforeFee`.
     function feeAmountFrom(uint256 amountBeforeFee, uint256 feePercent) internal pure returns (uint256) {
         return mulDiv(amountBeforeFee, feePercent, JBConstants.MAX_FEE);
     }
 
-    /// @notice Specialization of `feeAmountFrom` that hardcodes the standard protocol fee
-    /// (`JBConstants.FEE / JBConstants.MAX_FEE` = 25 / 1000 = 1 / 40). Both numerator and denominator are
-    /// compile-time constants so callers don't need to pass them every call.
-    /// @dev Pre-reduced: `mulDiv(amount, 25, 1000)` ≡ `amount / 40` (gcd(25, 1000) = 25). Plain integer
-    /// division is exact (rounds down) and shaves the entire `mulDiv` 512-bit pipeline at every fee site.
-    /// If `JBConstants.FEE` or `JBConstants.MAX_FEE` changes, the constant `40` here MUST be reduced again.
+    /// @notice Returns the fee amount that, when added to `amountAfterFee`, produces the gross amount needed to yield
+    /// `amountAfterFee` after the fee is deducted.
+    /// @dev Use this to back-calculate the fee from a desired post-fee payout.
+    /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
+    /// @param feePercent The fee percent, out of `JBConstants.MAX_FEE`.
+    /// @return The fee amount, as a fixed point number with the same number of decimals as `amountAfterFee`.
+    function feeAmountResultingIn(uint256 amountAfterFee, uint256 feePercent) internal pure returns (uint256) {
+        return mulDiv(amountAfterFee, JBConstants.MAX_FEE, JBConstants.MAX_FEE - feePercent) - amountAfterFee;
+    }
+
+    /// @notice Returns the standard protocol fee taken from `amountBeforeFee`.
+    /// @dev The standard fee is `25 / 1_000`, pre-reduced to `1 / 40`. If `JBConstants.STANDARD_FEE` or
+    /// `JBConstants.MAX_FEE` changes, this denominator must be reduced again.
     /// @param amountBeforeFee The amount before the fee is applied, as a fixed point number.
     /// @return The fee amount, as a fixed point number with the same number of decimals as `amountBeforeFee`.
     function standardFeeAmountFrom(uint256 amountBeforeFee) internal pure returns (uint256) {
+        // `JBConstants.STANDARD_FEE / JBConstants.MAX_FEE` is currently `1 / 40`.
         return amountBeforeFee / 40;
     }
 
-    /// @notice Specialization of `feeAmountResultingIn` that hardcodes the standard protocol fee
-    /// (`JBConstants.FEE / JBConstants.MAX_FEE`). Use to back-calculate the standard fee from a known
-    /// post-fee payout.
-    /// @dev Pre-reduced: `mulDiv(amount, 1000, 1000 - 25) - amount` ≡ `mulDiv(amount, 40, 39) - amount`
-    /// (gcd(1000, 975) = 25). `mulDiv` (not raw `*`) preserves overflow-safety for the rare wildly-large
-    /// inputs and matches the rounding behavior of `feeAmountResultingIn` exactly. If `JBConstants.FEE` or
-    /// `JBConstants.MAX_FEE` changes, the constants `40` and `39` here MUST be reduced again.
+    /// @notice Back-calculates the standard protocol fee from a known post-fee amount.
+    /// @dev `1 / (1 - 25 / 1_000) - 1` reduces to `40 / 39 - 1`. If `JBConstants.STANDARD_FEE` or
+    /// `JBConstants.MAX_FEE` changes, these constants must be reduced again.
     /// @param amountAfterFee The desired post-fee amount, as a fixed point number.
     /// @return The fee amount that, when added to `amountAfterFee`, yields the gross pre-fee amount.
     function standardFeeAmountResultingIn(uint256 amountAfterFee) internal pure returns (uint256) {
+        // Use `mulDiv` instead of `amountAfterFee * 40 / 39` to preserve overflow safety.
         return mulDiv(amountAfterFee, 40, 39) - amountAfterFee;
     }
 }

package/src/libraries/JBRulesetMetadataResolver.sol

@@ -71,25 +71,20 @@ library JBRulesetMetadataResolver {
         return ((ruleset.metadata >> 79) & 1) == 1;
     }
 
-    function pauseCrossProjectFeeFreeInflows(JBRuleset memory ruleset) internal pure returns (bool) {
-        return ((ruleset.metadata >> 80) & 1) == 1;
-    }
-
     function useDataHookForPay(JBRuleset memory ruleset) internal pure returns (bool) {
-        return (ruleset.metadata >> 81) & 1 == 1;
+        return (ruleset.metadata >> 80) & 1 == 1;
     }
 
     function useDataHookForCashOut(JBRuleset memory ruleset) internal pure returns (bool) {
-        return (ruleset.metadata >> 82) & 1 == 1;
+        return (ruleset.metadata >> 81) & 1 == 1;
     }
 
     function dataHook(JBRuleset memory ruleset) internal pure returns (address) {
-        return address(uint160(ruleset.metadata >> 83));
+        return address(uint160(ruleset.metadata >> 82));
     }
 
     function metadata(JBRuleset memory ruleset) internal pure returns (uint16) {
-        // 13-bit field at bits 243-255.
-        return uint16(ruleset.metadata >> 243);
+        return uint16(ruleset.metadata >> 242);
     }
 
     /// @notice Pack the funding cycle metadata.
@@ -130,16 +125,14 @@ library JBRulesetMetadataResolver {
         if (rulesetMetadata.holdFees) packed |= 1 << 78;
         // scopeCashOutsToLocalBalances in bit 79.
         if (rulesetMetadata.scopeCashOutsToLocalBalances) packed |= 1 << 79;
-        // pause cross-project fee-free inflows in bit 80.
-        if (rulesetMetadata.pauseCrossProjectFeeFreeInflows) packed |= 1 << 80;
-        // use pay data source in bit 81.
-        if (rulesetMetadata.useDataHookForPay) packed |= 1 << 81;
-        // use cash out data source in bit 82.
-        if (rulesetMetadata.useDataHookForCashOut) packed |= 1 << 82;
-        // data source address in bits 83-242.
-        packed |= uint256(uint160(address(rulesetMetadata.dataHook))) << 83;
-        // metadata in bits 243-255 (13 bits).
-        packed |= (uint256(rulesetMetadata.metadata) & 0x1FFF) << 243;
+        // use pay data source in bit 80.
+        if (rulesetMetadata.useDataHookForPay) packed |= 1 << 80;
+        // use cash out data source in bit 81.
+        if (rulesetMetadata.useDataHookForCashOut) packed |= 1 << 81;
+        // data source address in bits 82-241.
+        packed |= uint256(uint160(address(rulesetMetadata.dataHook))) << 82;
+        // metadata in bits 242-255 (14 bits).
+        packed |= (uint256(rulesetMetadata.metadata) & 0x3FFF) << 242;
     }
 
     /// @notice Expand the funding cycle metadata.
@@ -162,7 +155,6 @@ library JBRulesetMetadataResolver {
             ownerMustSendPayouts: ownerMustSendPayouts(ruleset),
             holdFees: holdFees(ruleset),
             scopeCashOutsToLocalBalances: scopeCashOutsToLocalBalances(ruleset),
-            pauseCrossProjectFeeFreeInflows: pauseCrossProjectFeeFreeInflows(ruleset),
             useDataHookForPay: useDataHookForPay(ruleset),
             useDataHookForCashOut: useDataHookForCashOut(ruleset),
             dataHook: dataHook(ruleset),

package/src/structs/JBRulesetMetadata.sol

@@ -23,12 +23,10 @@ pragma solidity ^0.8.0;
 /// @custom:member holdFees If `true`, fees are accumulated but not processed until a future ruleset (or manually).
 /// @custom:member scopeCashOutsToLocalBalances If `true`, omnichain cash-out calculations use only the local chain's
 /// balances (not cross-chain aggregates).
-/// @custom:member pauseCrossProjectFeeFreeInflows If `true`, the project cannot be targeted by
-/// `payAfterCashOutTokensOf` calls during this ruleset.
 /// @custom:member useDataHookForPay If `true`, the data hook is called before recording payments.
 /// @custom:member useDataHookForCashOut If `true`, the data hook is called before recording cash outs.
 /// @custom:member dataHook Contract called before pay/cash-out to potentially override token counts or add hooks.
-/// @custom:member metadata 13 bits of application-specific metadata (upper 3 bits of the uint16 are ignored).
+/// @custom:member metadata 14 bits of application-specific metadata (upper 2 bits are ignored).
 struct JBRulesetMetadata {
     uint16 reservedPercent;
     uint16 cashOutTaxRate;
@@ -45,7 +43,6 @@ struct JBRulesetMetadata {
     bool ownerMustSendPayouts;
     bool holdFees;
     bool scopeCashOutsToLocalBalances;
-    bool pauseCrossProjectFeeFreeInflows;
     bool useDataHookForPay;
     bool useDataHookForCashOut;
     address dataHook;

package/test/helpers/JBTest.sol

@@ -68,8 +68,7 @@ contract JBTest is Test {
             useDataHookForPay: false,
             useDataHookForCashOut: false,
             dataHook: address(0),
-            metadata: 0,
-            pauseCrossProjectFeeFreeInflows: false
+            metadata: 0
         });
 
         uint256 packed = _rulesMetadata.packRulesetMetadata();
@@ -107,8 +106,7 @@ contract JBTest is Test {
             useDataHookForPay: false,
             useDataHookForCashOut: false,
             dataHook: address(0),
-            metadata: 0,
-            pauseCrossProjectFeeFreeInflows: false
+            metadata: 0
         });
     }
 
@@ -132,8 +130,7 @@ contract JBTest is Test {
             useDataHookForPay: false,
             useDataHookForCashOut: false,
             dataHook: address(0),
-            metadata: 0,
-            pauseCrossProjectFeeFreeInflows: false
+            metadata: 0
         });
 
         uint256 packed = _rulesMetadata.packRulesetMetadata();

package/src/libraries/JBCashOutHookSpecsLib.sol

@@ -1,181 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-
-import {IJBCashOutHook} from "../interfaces/IJBCashOutHook.sol";
-import {IJBFeelessAddresses} from "../interfaces/IJBFeelessAddresses.sol";
-import {JBAfterCashOutRecordedContext} from "../structs/JBAfterCashOutRecordedContext.sol";
-import {JBCashOutHookSpecification} from "../structs/JBCashOutHookSpecification.sol";
-import {JBRuleset} from "../structs/JBRuleset.sol";
-import {JBTokenAmount} from "../structs/JBTokenAmount.sol";
-import {JBConstants} from "./JBConstants.sol";
-import {JBFees} from "./JBFees.sol";
-
-/// @notice Cash-out hook specification fulfillment for `JBMultiTerminal`. Extracted to reduce terminal
-/// bytecode size, mirroring the `JBHeldFeesLib` pattern.
-/// @dev Called via DELEGATECALL — `address(this)` inside library code is the terminal's address, so token
-/// approvals and ETH-bearing hook calls operate on the terminal's balance and allowances. Events are
-/// emitted from the terminal address. The `caller` field of `HookAfterRecordCashOut` uses raw `msg.sender`
-/// (matching `JBHeldFeesLib`'s precedent) — this means meta-transactions through a trusted forwarder will
-/// surface the forwarder address in the event slot, but the actual hook execution semantics are unaffected.
-library JBCashOutHookSpecsLib {
-    // A library that adds default safety checks to ERC20 functionality.
-    using SafeERC20 for IERC20;
-
-    //*********************************************************************//
-    // ------------------------------ events ----------------------------- //
-    //*********************************************************************//
-
-    /// @notice A cash out hook was called after a cash out was recorded.
-    /// @param hook The cash out hook that was called.
-    /// @param context The context passed to the hook.
-    /// @param specificationAmount The amount specified for the hook.
-    /// @param fee The fee taken from the hook's amount.
-    /// @param caller The address that called the cash out function.
-    event HookAfterRecordCashOut(
-        IJBCashOutHook indexed hook,
-        JBAfterCashOutRecordedContext context,
-        uint256 specificationAmount,
-        uint256 fee,
-        address caller
-    );
-
-    //*********************************************************************//
-    // --------------------------- custom errors ------------------------- //
-    //*********************************************************************//
-
-    /// @notice Thrown when a hook returns without consuming the full forwarded ERC-20 amount.
-    error JBMultiTerminal_TemporaryAllowanceNotConsumed(address token, address spender, uint256 allowance);
-
-    //*********************************************************************//
-    // ----------------------- external functions ------------------------ //
-    //*********************************************************************//
-
-    /// @notice Iterates `specifications`, calling each non-noop hook with the right ETH/ERC-20 setup, and
-    /// accumulates the fee-eligible amount across non-feeless hooks.
-    /// @dev For each spec: if the hook is feeless, it gets the full spec amount; otherwise the hook gets
-    /// `amount - feeAmountFrom(amount)` and the gross spec amount is added to the eligible-for-fees total
-    /// (the caller takes the fee separately via `_takeFeeFrom`). Cross-token semantics: the hook context's
-    /// `forwardedAmount` carries the post-fee amount in the same token as `beneficiaryReclaimAmount`.
-    /// @param feelessAddresses Registry of fee-exempt addresses (consulted per-hook).
-    /// @param projectId The project being cashed out from.
-    /// @param beneficiaryReclaimAmount The token amount reference (token, decimals, currency, gross value).
-    /// @param holder The account whose project tokens were burned.
-    /// @param cashOutCount The number of project tokens burned.
-    /// @param metadata Bytes forwarded to each hook as `cashOutMetadata`.
-    /// @param ruleset The ruleset active during the cash out.
-    /// @param cashOutTaxRate The cash out tax rate applied.
-    /// @param beneficiary The address forwarded as the hook context's `beneficiary` (typically the user-supplied
-    /// recipient or `address(this)` for cross-project flows where the terminal custodies the reclaim mid-flow).
-    /// @param specifications The hook specifications returned by the data hook.
-    /// @return amountEligibleForFees Total spec amounts (gross) from non-feeless hooks, used by the caller to
-    /// charge fees in a single pass.
-    function fulfill(
-        IJBFeelessAddresses feelessAddresses,
-        uint256 projectId,
-        JBTokenAmount memory beneficiaryReclaimAmount,
-        address holder,
-        uint256 cashOutCount,
-        bytes memory metadata,
-        JBRuleset memory ruleset,
-        uint256 cashOutTaxRate,
-        address payable beneficiary,
-        JBCashOutHookSpecification[] memory specifications
-    )
-        external
-        returns (uint256 amountEligibleForFees)
-    {
-        JBAfterCashOutRecordedContext memory context = JBAfterCashOutRecordedContext({
-            holder: holder,
-            projectId: projectId,
-            rulesetId: ruleset.id,
-            cashOutCount: cashOutCount,
-            reclaimedAmount: beneficiaryReclaimAmount,
-            forwardedAmount: beneficiaryReclaimAmount,
-            cashOutTaxRate: cashOutTaxRate,
-            beneficiary: beneficiary,
-            hookMetadata: "",
-            cashOutMetadata: metadata
-        });
-
-        for (uint256 i; i < specifications.length;) {
-            JBCashOutHookSpecification memory specification = specifications[i];
-
-            // A noop specification is informational only and doesn't trigger the hook.
-            if (specification.noop) {
-                unchecked {
-                    ++i;
-                }
-                continue;
-            }
-
-            // Get the fee for the specified amount.
-            uint256 specificationAmountFee = feelessAddresses.isFeelessFor({
-                addr: address(specification.hook), projectId: projectId
-            })
-                ? 0
-                : JBFees.standardFeeAmountFrom({amountBeforeFee: specification.amount});
-
-            // Add the specification's amount to the amount eligible for fees.
-            if (specificationAmountFee != 0) {
-                amountEligibleForFees += specification.amount;
-                specification.amount -= specificationAmountFee;
-            }
-
-            // Pass the correct token `forwardedAmount` to the hook.
-            context.forwardedAmount = JBTokenAmount({
-                value: specification.amount,
-                token: beneficiaryReclaimAmount.token,
-                decimals: beneficiaryReclaimAmount.decimals,
-                currency: beneficiaryReclaimAmount.currency
-            });
-
-            // Pass the correct metadata from the data hook's specification.
-            context.hookMetadata = specification.metadata;
-
-            // Trigger any inherited pre-transfer logic.
-            // Keep a reference to the amount that'll be paid as a `msg.value`.
-            uint256 payValue = _beforeTransferTo({
-                to: address(specification.hook), token: beneficiaryReclaimAmount.token, amount: specification.amount
-            });
-
-            // Fulfill the specification.
-            specification.hook.afterCashOutRecordedWith{value: payValue}(context);
-
-            // Revoke the temporary pull allowance now that the hook call has finished.
-            _afterTransferTo({to: address(specification.hook), token: beneficiaryReclaimAmount.token});
-
-            emit HookAfterRecordCashOut({
-                hook: specification.hook,
-                context: context,
-                specificationAmount: specification.amount,
-                fee: specificationAmountFee,
-                caller: msg.sender
-            });
-            unchecked {
-                ++i;
-            }
-        }
-    }
-
-    //*********************************************************************//
-    // ----------------------- private helpers --------------------------- //
-    //*********************************************************************//
-
-    /// @notice Native-token transfers use `msg.value` (return the amount). ERC20 transfers grant a temporary
-    /// pull allowance and return 0 (the recipient is expected to consume it within the same call).
-    function _beforeTransferTo(address to, address token, uint256 amount) private returns (uint256) {
-        if (token == JBConstants.NATIVE_TOKEN) return amount;
-        IERC20(token).forceApprove({spender: to, value: amount});
-        return 0;
-    }
-
-    /// @notice Asserts the recipient consumed the temporary ERC20 allowance. No-op for native token.
-    function _afterTransferTo(address to, address token) private view {
-        if (token == JBConstants.NATIVE_TOKEN) return;
-        uint256 allowance = IERC20(token).allowance({owner: address(this), spender: to});
-        if (allowance != 0) revert JBMultiTerminal_TemporaryAllowanceNotConsumed(token, to, allowance);
-    }
-}