@bananapus/core-v6 0.0.51 → 0.0.53

package/CHANGELOG.md

@@ -13,6 +13,17 @@ This file describes the verified change from `nana-core-v5` to the current `nana
 - `JBTokens`
 - the shared core interfaces, structs, and libraries under `src/`
 
+## 0.0.53 — Drop the `via_ir` requirement
+
+`JBCashOutHookSpecsLib.fulfill` originally took 10 named arguments. When `JBMultiTerminal._cashOutTokensOf` and `_payAfterCashOutTokensOf` called it, the call site ran past solc 0.8.28's 16-slot Yul stack ceiling, which forced every consumer of `@bananapus/core-v6` to enable `via_ir = true` in their own `foundry.toml` profile. That cascaded into stack-too-deep failures in downstream packages whose own functions couldn't tolerate `via_ir` (notably `nana-721-hook-v6`'s `JB721TiersHookStore.tiersOf`).
+
+This release reshapes `fulfill` to accept the existing `JBAfterCashOutRecordedContext` directly — the same struct the hook receives — so no parallel arg bundle is needed. The new signature is `fulfill(IJBFeelessAddresses, JBAfterCashOutRecordedContext, JBCashOutHookSpecification[])`. The per-iteration loop body is extracted into a private `_fulfillOne` helper so its locals don't share `fulfill`'s stack frame. Both call sites in `JBMultiTerminal` build the context field-by-field (one stack slot per assignment) instead of via a struct literal (which would push all ten fields onto the stack at once and trip the same ceiling at the caller).
+
+Integrator impact:
+- `JBCashOutHookSpecsLib.fulfill(IJBFeelessAddresses, uint256, JBTokenAmount, address, uint256, bytes, JBRuleset, uint256, address payable, JBCashOutHookSpecification[])` → `fulfill(IJBFeelessAddresses, JBAfterCashOutRecordedContext, JBCashOutHookSpecification[])`. The only on-chain caller is `JBMultiTerminal` (this PR updates both call sites), so the public ABI surface of `JBMultiTerminal` is unchanged.
+- Consumers of `@bananapus/core-v6@^0.0.53` can drop `via_ir = true` from their `foundry.toml` profiles if they only enabled it because of `JBCashOutHookSpecsLib`. `nana-core-v6`'s own profile flips `via_ir` to `false` to lock in the property.
+- All 997 unit/non-fork tests pass on the refactored library + call sites.
+
 ## Summary
 
 - v6 adds explicit preview APIs for pay and cash-out flows. Integrations can simulate more of the terminal path directly from the core contracts.
@@ -57,6 +68,9 @@ This file describes the verified change from `nana-core-v5` to the current `nana
 - `IJBCashOutTerminal.previewCashOutFrom(...)` is new.
 - `IJBCashOutTerminal.payAfterCashOutTokensOf(...)` is new.
 - `IJBCashOutTerminal.addToBalanceAfterCashOutTokensOf(...)` is new.
+- `IJBFeeTerminal.FEE()` is REMOVED. The terminal no longer re-exports the protocol fee constant; read
+  `JBConstants.FEE` directly. Off-chain integrators that previously called `terminal.FEE()` must switch to
+  reading the constant from `JBConstants`.
 - `IJBTerminalStore.previewPayFrom(...)` and `previewCashOutFrom(...)` are new.
 - `IJBTerminal.currentSurplusOf(...)` changed parameter shape.
 - `JBRulesetMetadata` adds `pauseCrossProjectFeeFreeInflows` and narrows `metadata` from 14 to 13 bits.
@@ -96,6 +110,8 @@ This file describes the verified change from `nana-core-v5` to the current `nana
     `HookAfterRecordCashOut` from the terminal address)
 - Renamed functions
   - `IJBController.addPriceFeed(...)` -> `addPriceFeedFor(...)`
+- Removed functions
+  - `IJBFeeTerminal.FEE()` (read `JBConstants.FEE` directly)
 - Changed function shapes
   - `IJBTerminal.currentSurplusOf(...)`
 - Added events

package/foundry.toml

@@ -3,7 +3,7 @@ solc = '0.8.28'
 bytecode_hash = "none"
 evm_version = 'cancun'
 optimizer_runs = 200
-via_ir = true
+via_ir = false
 libs = ["node_modules", "lib"]
 fs_permissions = [{ access = "read-write", path = "./"}]
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bananapus/core-v6",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/JBMultiTerminal.sol

@@ -81,16 +81,6 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     error JBMultiTerminal_TokenNotAccepted(address token);
     error JBMultiTerminal_UnderMin(uint256 value, uint256 min);
 
-    //*********************************************************************//
-    // ------------------------- public constants ------------------------ //
-    //*********************************************************************//
-
-    /// @notice This terminal's fee (as a fraction out of `JBConstants.MAX_FEE`).
-    /// @dev Fees are charged on payouts to addresses and surplus allowance usage, as well as cash outs while the
-    /// cash out tax rate is less than 100%. Re-exports `JBConstants.FEE` so external callers can read it through
-    /// the `IJBFeeTerminal` interface.
-    uint256 public constant override FEE = JBConstants.FEE;
-
     //*********************************************************************//
     // ------------------------ internal constants ----------------------- //
     //*********************************************************************//
@@ -260,7 +250,14 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         override
         returns (uint256 reclaimAmount)
     {
+        // Caller must hold (or be operator with) `CASH_OUT_TOKENS` permission on the source `holder`/`projectId`.
+        // Burning A's tokens is the load-bearing side effect — gating it stays at the same authority bar as the
+        // direct `cashOutTokensOf` entrypoint.
         _requireCashOutPermissionFrom({holder: holder, projectId: projectId});
+
+        // Destination opt-out check: B's current ruleset can set `pauseCrossProjectFeeFreeInflows = true` to
+        // refuse cross-project fee-free credits. Without this gate, anyone holding A's tokens could push a
+        // deferred-fee credit onto `_feeFreeSurplusOf[B]` without B consenting.
         _requireBeneficiaryAcceptsFeeFreeInflows(beneficiaryProjectId);
 
         // Burn source-project tokens, run cashout-side hooks, take any hook fees, and cap source fee-free.
@@ -278,13 +275,19 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Nothing to route if the data hook returned zero reclaim.
         if (reclaimAmount == 0) return 0;
 
-        // Route the reclaim to B's primary terminal as an `addToBalanceOf`, then credit B's fee-free surplus
-        // by the delivery delta. `_efficientAddToBalance` handles same-terminal vs cross-terminal and
-        // hardcodes `shouldReturnHeldFees: false` — this entrypoint cannot unlock B's held fees.
+        // Resolve B's primary terminal for the reclaim token. Could be this terminal (same-terminal short-
+        // circuit) or a router that swaps before depositing. Reverts if no primary terminal is registered.
         IJBTerminal destinationTerminal = _resolveBeneficiaryTerminal(beneficiaryProjectId, tokenToReclaim);
+
+        // Snapshot B's per-context balances on this terminal BEFORE routing. The post-routing comparison
+        // identifies the bucket the reclaim actually landed in (matters for cross-token routes where a router
+        // swaps to a different token in B's accounting-context list).
         (JBAccountingContext[] memory contexts, uint256[] memory balancesBefore) =
             _snapshotBeneficiaryContextBalances(beneficiaryProjectId);
 
+        // Route via `_efficientAddToBalance` — handles same-terminal vs cross-terminal (with the standard
+        // `_beforeTransferTo`/`_afterTransferTo` allowance dance) and hardcodes `shouldReturnHeldFees: false`,
+        // so this entrypoint cannot be used to unlock B's held fees on top of the source-side fee skip.
         _efficientAddToBalance({
             terminal: destinationTerminal,
             projectId: beneficiaryProjectId,
@@ -293,6 +296,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             metadata: addToBalanceMetadata
         });
 
+        // Credit `_feeFreeSurplusOf[B]` on the first of B's contexts whose balance grew. This binds the
+        // skipped source-side fee on the destination side: B's next non-feeless cashout pays it. Reverts if
+        // no context grew (no delivery landed) — without delivery, the fee skip would leak.
         _creditFirstGrowingBeneficiaryContext(beneficiaryProjectId, contexts, balancesBefore);
     }
 
@@ -737,7 +743,14 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         override
         returns (uint256 reclaimAmount, uint256 beneficiaryTokenCount)
     {
+        // Caller must hold (or be operator with) `CASH_OUT_TOKENS` permission on the source `holder`/`projectId`.
+        // Burning A's tokens is the load-bearing side effect — gating it stays at the same authority bar as the
+        // direct `cashOutTokensOf` entrypoint.
         _requireCashOutPermissionFrom({holder: holder, projectId: projectId});
+
+        // Destination opt-out check: B's current ruleset can set `pauseCrossProjectFeeFreeInflows = true` to
+        // refuse cross-project fee-free credits. Without this gate, anyone holding A's tokens could push a
+        // deferred-fee credit onto `_feeFreeSurplusOf[B]` without B consenting.
         _requireBeneficiaryAcceptsFeeFreeInflows(beneficiaryProjectId);
 
         // Burn source-project tokens, run cashout-side hooks, take any hook fees, and cap source fee-free.
@@ -1300,23 +1313,24 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             }
         }
 
-        // If the data hook returned cash out hook specifications, fulfill them.
+        // If the data hook returned cash out hook specifications, fulfill them. The context is built
+        // field-by-field rather than as a struct literal so each assignment uses only one stack slot at a
+        // time, keeping the call site under solc 0.8.28's non-via-ir Yul stack ceiling (a 10-field struct
+        // literal would otherwise trip it from inside `_cashOutTokensOf`).
         if (hookSpecifications.length != 0) {
-            // Fulfill the cash out hook specifications.
-            amountEligibleForFees += JBCashOutHookSpecsLib.fulfill({
-                feelessAddresses: FEELESS_ADDRESSES,
-                projectId: projectId,
-                holder: holder,
-                cashOutCount: cashOutCount,
-                ruleset: ruleset,
-                cashOutTaxRate: cashOutTaxRate,
-                beneficiary: beneficiary,
-                beneficiaryReclaimAmount: _tokenAmountOf({
-                    projectId: projectId, token: tokenToReclaim, value: reclaimAmount
-                }),
-                specifications: hookSpecifications,
-                metadata: metadata
-            });
+            JBTokenAmount memory reclaimTokenAmount =
+                _tokenAmountOf({projectId: projectId, token: tokenToReclaim, value: reclaimAmount});
+            JBAfterCashOutRecordedContext memory ctx;
+            ctx.holder = holder;
+            ctx.projectId = projectId;
+            ctx.rulesetId = ruleset.id;
+            ctx.cashOutCount = cashOutCount;
+            ctx.reclaimedAmount = reclaimTokenAmount;
+            ctx.forwardedAmount = reclaimTokenAmount;
+            ctx.cashOutTaxRate = cashOutTaxRate;
+            ctx.beneficiary = beneficiary;
+            ctx.cashOutMetadata = metadata;
+            amountEligibleForFees += JBCashOutHookSpecsLib.fulfill(FEELESS_ADDRESSES, ctx, hookSpecifications);
         }
 
         // Cap fee-free surplus at remaining balance.
@@ -1377,14 +1391,30 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
     )
         internal
     {
+        // Walk B's accounting contexts in declared order. The first context whose balance grew is treated as
+        // the bucket the router chose to deposit into (typically the post-swap token in a cross-token route).
+        // We bind the deferred source-side fee to that bucket and stop — subsequent grown contexts are ignored
+        // by design, capping the credit at one delivery delta even if a misbehaving router somehow split the
+        // deposit across multiple buckets.
         for (uint256 i; i < contexts.length;) {
+            // Read B's post-routing balance for this context's token. Compared against the pre-routing snapshot
+            // captured by `_snapshotBeneficiaryContextBalances` to detect the delivery delta.
             uint256 balanceAfter =
                 STORE.balanceOf({terminal: address(this), projectId: beneficiaryProjectId, token: contexts[i].token});
 
             if (balanceAfter > balancesBefore[i]) {
+                // Credit the delivery delta into B's fee-free counter for this token. `unchecked` is safe:
+                // `balanceAfter > balancesBefore[i]` is the loop condition, so the subtraction can't underflow,
+                // and the addition can't overflow before the underlying balance does (terminal balance is the
+                // upper bound on any cumulative credit — see the cap call below).
                 unchecked {
                     _feeFreeSurplusOf[beneficiaryProjectId][contexts[i].token] += balanceAfter - balancesBefore[i];
                 }
+
+                // Cap the credit at B's current balance for this token. If pay/addToBalance hooks pulled funds
+                // back out during routing, the post-balance read inside `_capFeeFreeSurplus` clamps the
+                // counter so it never exceeds what's actually sitting in B's bucket. Without this, B's later
+                // zero-tax cashouts would over-fee phantom amounts.
                 _capFeeFreeSurplus({projectId: beneficiaryProjectId, token: contexts[i].token});
                 return;
             }
@@ -1394,6 +1424,9 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
             }
         }
 
+        // No context grew. Either the destination terminal silently dropped the funds or routed them
+        // elsewhere (e.g. to a different terminal not registered as B's primary). Revert the entire
+        // cross-project flow so the source-side fee skip never becomes a leak — A's burn is undone too.
         revert JBMultiTerminal_BeneficiaryProjectNotPaid(beneficiaryProjectId);
     }
 
@@ -1545,20 +1578,19 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
         // Hook fees still apply (those funds leave the protocol to external hooks). Hook context sees
         // `address(this)` as the beneficiary since the terminal is custodying the reclaim mid-flow.
         if (hookSpecifications.length != 0) {
-            amountEligibleForFees = JBCashOutHookSpecsLib.fulfill({
-                feelessAddresses: FEELESS_ADDRESSES,
-                projectId: projectId,
-                beneficiaryReclaimAmount: _tokenAmountOf({
-                    projectId: projectId, token: tokenToReclaim, value: reclaimAmount
-                }),
-                holder: holder,
-                cashOutCount: cashOutCount,
-                metadata: cashOutMetadata,
-                ruleset: ruleset,
-                cashOutTaxRate: cashOutTaxRate,
-                beneficiary: payable(address(this)),
-                specifications: hookSpecifications
-            });
+            JBTokenAmount memory reclaimTokenAmount =
+                _tokenAmountOf({projectId: projectId, token: tokenToReclaim, value: reclaimAmount});
+            JBAfterCashOutRecordedContext memory ctx;
+            ctx.holder = holder;
+            ctx.projectId = projectId;
+            ctx.rulesetId = ruleset.id;
+            ctx.cashOutCount = cashOutCount;
+            ctx.reclaimedAmount = reclaimTokenAmount;
+            ctx.forwardedAmount = reclaimTokenAmount;
+            ctx.cashOutTaxRate = cashOutTaxRate;
+            ctx.beneficiary = payable(address(this));
+            ctx.cashOutMetadata = cashOutMetadata;
+            amountEligibleForFees = JBCashOutHookSpecsLib.fulfill(FEELESS_ADDRESSES, ctx, hookSpecifications);
         }
 
         // Cap the source project's fee-free surplus at remaining balance after the outflow. Same invariant as
@@ -2112,7 +2144,7 @@ contract JBMultiTerminal is JBPermissioned, ERC2771Context, IJBMultiTerminal {
                 projectId: projectId,
                 token: token,
                 amount: amount,
-                fee: FEE,
+                fee: JBConstants.FEE,
                 beneficiary: beneficiary,
                 caller: _msgSender()
             });

package/src/interfaces/IJBFeeTerminal.sol

@@ -71,9 +71,6 @@ interface IJBFeeTerminal is IJBTerminal {
         address caller
     );
 
-    /// @notice The terminal's fee as a fraction of `JBConstants.MAX_FEE`.
-    function FEE() external view returns (uint256);
-
     /// @notice The contract that tracks feeless addresses.
     function FEELESS_ADDRESSES() external view returns (IJBFeelessAddresses);
 

package/src/libraries/JBCashOutHookSpecsLib.sol

@@ -8,7 +8,6 @@ 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";
@@ -58,108 +57,104 @@ library JBCashOutHookSpecsLib {
     /// @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`.
+    /// `forwardedAmount` carries the post-fee amount in the same token as `context.reclaimedAmount`.
+    /// @dev The caller builds `context` once (`JBAfterCashOutRecordedContext`) and passes it in; the
+    /// library mutates `context.forwardedAmount` and `context.hookMetadata` per spec. Bundling the
+    /// caller-side state into the existing hook-context struct keeps the call site under solc 0.8.28's
+    /// non-via-ir 16-slot Yul stack ceiling (the prior 10-arg shape tripped it from
+    /// `JBMultiTerminal._cashOutTokensOf`).
     /// @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 context Cash-out context to forward into each hook. `context.reclaimedAmount` doubles as the
+    /// token-amount reference for per-spec transfers; `context.forwardedAmount` / `context.hookMetadata`
+    /// are rewritten per iteration.
     /// @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,
+        JBAfterCashOutRecordedContext memory context,
         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
-        });
-
+        // Loop body is extracted into a helper to keep `fulfill`'s stack frame shallow enough for solc 0.8.28
+        // to compile *without* `via_ir`.
         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
-            });
+            amountEligibleForFees += _fulfillOne(feelessAddresses, context, specifications[i]);
             unchecked {
                 ++i;
             }
         }
     }
 
+    /// @notice Fulfill a single hook specification: charge the protocol fee (if non-feeless), set up the hook
+    /// call context, transfer the post-fee amount to the hook, and emit the after-cash-out event.
+    /// @dev Returns the gross spec amount when the hook is non-feeless (so the caller can accumulate it into
+    /// `amountEligibleForFees`), or `0` when the hook is feeless / noop. Mutates `context.forwardedAmount`
+    /// and `context.hookMetadata` so the caller's next iteration can overwrite them.
+    /// @param feelessAddresses Registry of fee-exempt addresses (consulted to skip the per-hook fee).
+    /// @param context Cash-out context forwarded into the hook. `context.reclaimedAmount` is used as the
+    /// token-amount reference for the per-spec transfer; `context.forwardedAmount` and
+    /// `context.hookMetadata` are overwritten by this call.
+    /// @param specification The hook specification to fulfill (hook address, amount, metadata, noop flag).
+    /// @return grossSpecAmount The gross spec amount when the hook is non-feeless (for caller accumulation
+    /// into `amountEligibleForFees`); `0` for feeless or noop specifications.
+    function _fulfillOne(
+        IJBFeelessAddresses feelessAddresses,
+        JBAfterCashOutRecordedContext memory context,
+        JBCashOutHookSpecification memory specification
+    )
+        private
+        returns (uint256 grossSpecAmount)
+    {
+        // A noop specification is informational only and doesn't trigger the hook.
+        if (specification.noop) return 0;
+
+        // Get the fee for the specified amount.
+        uint256 specificationAmountFee = feelessAddresses.isFeelessFor({
+            addr: address(specification.hook), projectId: context.projectId
+        })
+            ? 0
+            : JBFees.standardFeeAmountFrom({amountBeforeFee: specification.amount});
+
+        // Surface the gross spec amount to the caller so it can be accumulated into `amountEligibleForFees`.
+        if (specificationAmountFee != 0) {
+            grossSpecAmount = specification.amount;
+            specification.amount -= specificationAmountFee;
+        }
+
+        // Pass the correct token `forwardedAmount` to the hook.
+        context.forwardedAmount = JBTokenAmount({
+            value: specification.amount,
+            token: context.reclaimedAmount.token,
+            decimals: context.reclaimedAmount.decimals,
+            currency: context.reclaimedAmount.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: context.reclaimedAmount.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: context.reclaimedAmount.token});
+
+        emit HookAfterRecordCashOut({
+            hook: specification.hook,
+            context: context,
+            specificationAmount: specification.amount,
+            fee: specificationAmountFee,
+            caller: msg.sender
+        });
+    }
+
     //*********************************************************************//
     // ----------------------- private helpers --------------------------- //
     //*********************************************************************//