@bananapus/core-v6 0.0.53 → 0.0.55

package/src/libraries/JBCashOutHookSpecsLib.sol

@@ -1,176 +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 {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 `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 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,
-        JBAfterCashOutRecordedContext memory context,
-        JBCashOutHookSpecification[] memory specifications
-    )
-        external
-        returns (uint256 amountEligibleForFees)
-    {
-        // 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;) {
-            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 --------------------------- //
-    //*********************************************************************//
-
-    /// @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);
-    }
-}

package/src/libraries/JBHeldFeesLib.sol

@@ -1,288 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import {IJBDirectory} from "../interfaces/IJBDirectory.sol";
-import {IJBTerminal} from "../interfaces/IJBTerminal.sol";
-import {IJBTerminalStore} from "../interfaces/IJBTerminalStore.sol";
-import {JBFee} from "../structs/JBFee.sol";
-import {JBConstants} from "./JBConstants.sol";
-import {JBFees} from "./JBFees.sol";
-
-/// @notice Local callback into the terminal's `executeProcessFee(...)`. Kept here because the function is an
-/// implementation detail of the library/terminal pair, not a shared public interface.
-interface IJBHeldFeesExecutor {
-    /// @notice Sends a fee amount from a project to the fee-receiving terminal under an external CALL boundary,
-    /// so the library can wrap the call in `try/catch` (revert in the fee route is forgiven, not propagated).
-    /// @param projectId The project paying the fee.
-    /// @param token The token the fee is denominated in.
-    /// @param amount The fee amount.
-    /// @param beneficiary The address that receives any platform tokens minted by the fee payment.
-    /// @param feeTerminal The terminal that'll receive the fee.
-    function executeProcessFee(
-        uint256 projectId,
-        address token,
-        uint256 amount,
-        address beneficiary,
-        IJBTerminal feeTerminal
-    )
-        external;
-}
-
-/// @notice Held-fee bookkeeping for `JBMultiTerminal`. Extracted to reduce terminal bytecode size.
-/// @dev Called via DELEGATECALL — storage refs (`heldFeesOf`, `nextHeldFeeIndexOf`) point at the terminal's
-/// storage. `address(this)` inside library code is the terminal's address. Events are therefore emitted from
-/// the terminal.
-library JBHeldFeesLib {
-    //*********************************************************************//
-    // ------------------------------ events ----------------------------- //
-    //*********************************************************************//
-
-    /// @notice Emitted when a fee is sent to the fee-receiving terminal.
-    /// @param projectId The project the fee was for.
-    /// @param token The token the fee was paid in.
-    /// @param amount The fee amount.
-    /// @param wasHeld Whether the fee was previously held (true) or processed inline (false).
-    /// @param beneficiary The address that received any platform tokens minted by the fee payment.
-    /// @param caller The address that triggered the fee processing.
-    event ProcessFee(
-        uint256 indexed projectId,
-        address indexed token,
-        uint256 amount,
-        bool wasHeld,
-        address beneficiary,
-        address caller
-    );
-
-    /// @notice Emitted when a fee payment reverts and the amount is returned to the project's balance.
-    /// @param projectId The project the fee was for.
-    /// @param token The token the fee was paid in.
-    /// @param feeProjectId The ID of the fee-receiving project.
-    /// @param amount The fee amount returned.
-    /// @param reason The revert reason from the fee route.
-    /// @param caller The address that triggered the fee processing.
-    event FeeReverted(
-        uint256 indexed projectId,
-        address indexed token,
-        uint256 indexed feeProjectId,
-        uint256 amount,
-        bytes reason,
-        address caller
-    );
-
-    /// @notice Emitted when held fees are returned to the project's balance (e.g. on an `addToBalanceOf`).
-    /// @param projectId The project whose held fees were returned.
-    /// @param token The token the held fees were denominated in.
-    /// @param amount The amount used as the basis for the return calculation.
-    /// @param returnedFees The amount of fees actually returned.
-    /// @param leftoverAmount Any leftover from the basis amount that did not match a held fee.
-    /// @param caller The address that triggered the return.
-    event ReturnHeldFees(
-        uint256 indexed projectId,
-        address indexed token,
-        uint256 amount,
-        uint256 returnedFees,
-        uint256 leftoverAmount,
-        address caller
-    );
-
-    //*********************************************************************//
-    // ----------------------- internal functions ------------------------ //
-    //*********************************************************************//
-
-    /// @notice Processes up to `count` unlocked held fees for `(projectId, token)`, forwarding each to the fee
-    /// terminal and reclaiming the storage slot once the queue is drained.
-    /// @dev Re-reads `nextHeldFeeIndexOf[projectId][token]` from storage each iteration to be reentrancy-safe
-    /// against any nested call that may have advanced the index. The entry is deleted and the index advanced
-    /// BEFORE the external call so a reverting fee route cannot be replayed.
-    /// @param heldFeesOf Storage ref to the terminal's per-(project,token) held-fee queue.
-    /// @param nextHeldFeeIndexOf Storage ref to the next-index cursor for each (project,token) queue.
-    /// @param directory The terminal's directory, used to locate the fee-receiving terminal.
-    /// @param store The terminal's store, used to credit the fee back to the project on a failed route.
-    /// @param projectId The project to process held fees for.
-    /// @param token The token the held fees are denominated in.
-    /// @param count The maximum number of held fees to process.
-    function processHeldFees(
-        mapping(uint256 => mapping(address => JBFee[])) storage heldFeesOf,
-        mapping(uint256 => mapping(address => uint256)) storage nextHeldFeeIndexOf,
-        IJBDirectory directory,
-        IJBTerminalStore store,
-        uint256 projectId,
-        address token,
-        uint256 count
-    )
-        external
-    {
-        // Resolve the fee-receiving terminal once outside the loop.
-        IJBTerminal feeTerminal =
-            directory.primaryTerminalOf({projectId: JBConstants.FEE_BENEFICIARY_PROJECT_ID, token: token});
-
-        for (uint256 i; i < count;) {
-            uint256 currentIndex = nextHeldFeeIndexOf[projectId][token];
-
-            // Queue exhausted — break early so we can run the array cleanup below.
-            if (currentIndex >= heldFeesOf[projectId][token].length) break;
-
-            JBFee memory heldFee = heldFeesOf[projectId][token][currentIndex];
-
-            // Fees unlock sequentially; if the head isn't ready, nothing later is either.
-            // forge-lint: disable-next-line(block-timestamp)
-            if (heldFee.unlockTimestamp > block.timestamp) break;
-
-            // Delete + advance index BEFORE the external call (reentrancy safety: a reentrant
-            // `processHeldFeesOf` cannot re-process the same entry).
-            delete heldFeesOf[projectId][token][currentIndex];
-            nextHeldFeeIndexOf[projectId][token] = currentIndex + 1;
-
-            processFee({
-                store: store,
-                projectId: projectId,
-                token: token,
-                amount: JBFees.standardFeeAmountFrom({amountBeforeFee: heldFee.amount}),
-                beneficiary: heldFee.beneficiary,
-                feeTerminal: feeTerminal,
-                wasHeld: true
-            });
-
-            unchecked {
-                ++i;
-            }
-        }
-
-        // Reclaim the array storage slot once the queue has been fully drained.
-        if (
-            nextHeldFeeIndexOf[projectId][token] >= heldFeesOf[projectId][token].length
-                && heldFeesOf[projectId][token].length > 0
-        ) {
-            delete heldFeesOf[projectId][token];
-            delete nextHeldFeeIndexOf[projectId][token];
-        }
-    }
-
-    /// @notice Sends a fee to the fee-receiving terminal under a try/catch boundary.
-    /// @dev Routed through `IJBHeldFeesExecutor(address(this)).executeProcessFee(...)` so the call is a real
-    /// external CALL (try/catch semantics require it). Under DELEGATECALL `address(this)` is the terminal, so
-    /// this becomes a call to the terminal's `executeProcessFee` whose `msg.sender == address(this)` check
-    /// passes. On revert the amount is forgiven and added back to the project's balance — by design, a broken
-    /// fee route should not permanently lock project funds.
-    /// @param store The terminal's store, used for the forgive-on-revert credit.
-    /// @param projectId The project paying the fee.
-    /// @param token The token the fee is denominated in.
-    /// @param amount The fee amount.
-    /// @param beneficiary The address that receives any platform tokens minted by the fee payment.
-    /// @param feeTerminal The terminal that'll receive the fee.
-    /// @param wasHeld Whether the fee was previously held (true) or processed inline (false).
-    function processFee(
-        IJBTerminalStore store,
-        uint256 projectId,
-        address token,
-        uint256 amount,
-        address beneficiary,
-        IJBTerminal feeTerminal,
-        bool wasHeld
-    )
-        public
-    {
-        try IJBHeldFeesExecutor(address(this))
-            .executeProcessFee({
-            projectId: projectId, token: token, amount: amount, beneficiary: beneficiary, feeTerminal: feeTerminal
-        }) {
-            emit ProcessFee({
-                projectId: projectId,
-                token: token,
-                amount: amount,
-                wasHeld: wasHeld,
-                beneficiary: beneficiary,
-                caller: msg.sender
-            });
-        } catch (bytes memory reason) {
-            // Forgive the fee, credit it back to the project, and surface the failure for off-chain observability.
-            emit FeeReverted({
-                projectId: projectId,
-                token: token,
-                feeProjectId: JBConstants.FEE_BENEFICIARY_PROJECT_ID,
-                amount: amount,
-                reason: reason,
-                caller: msg.sender
-            });
-
-            store.recordAddedBalanceFor({projectId: projectId, token: token, amount: amount});
-        }
-    }
-
-    /// @notice Returns held fees up to `amount` in FIFO order from the project's held-fee queue.
-    /// @dev Walks the queue from `nextHeldFeeIndexOf` forward. Whole entries are consumed when `leftoverAmount`
-    /// covers their post-fee amount; the final entry can be partially consumed by shrinking its `.amount` in
-    /// place. The fee implied by the partial-consume branch uses `feeAmountResultingIn` (inverse of
-    /// `feeAmountFrom`) so the credited fee aligns with the amount that was actually returned. Dust amounts
-    /// below the floor produce `feeAmount == 0`.
-    /// @param heldFeesOf Storage ref to the terminal's per-(project,token) held-fee queue.
-    /// @param nextHeldFeeIndexOf Storage ref to the next-index cursor for each (project,token) queue.
-    /// @param projectId The project to return held fees for.
-    /// @param token The token the held fees are denominated in.
-    /// @param amount The reference amount to base the return on (typically the inbound addToBalance amount).
-    /// @return returnedFees The total fee amount returned to the project.
-    function returnHeldFees(
-        mapping(uint256 => mapping(address => JBFee[])) storage heldFeesOf,
-        mapping(uint256 => mapping(address => uint256)) storage nextHeldFeeIndexOf,
-        uint256 projectId,
-        address token,
-        uint256 amount
-    )
-        external
-        returns (uint256 returnedFees)
-    {
-        uint256 startIndex = nextHeldFeeIndexOf[projectId][token];
-        uint256 numberOfHeldFees = heldFeesOf[projectId][token].length;
-
-        // Empty queue — nothing to return.
-        if (startIndex >= numberOfHeldFees) return 0;
-
-        uint256 leftoverAmount = amount;
-        uint256 count = numberOfHeldFees - startIndex;
-        uint256 newStartIndex = startIndex;
-
-        for (uint256 i; i < count;) {
-            JBFee memory heldFee = heldFeesOf[projectId][token][startIndex + i];
-
-            if (leftoverAmount == 0) {
-                break;
-            } else {
-                // Recompute the fee charged on the stored gross amount so partial returns stay aligned.
-                uint256 feeAmount = JBFees.standardFeeAmountFrom({amountBeforeFee: heldFee.amount});
-                uint256 amountPaidOut = heldFee.amount - feeAmount;
-
-                if (leftoverAmount >= amountPaidOut) {
-                    // Whole entry consumed: credit its full fee, advance the cursor past it.
-                    unchecked {
-                        leftoverAmount -= amountPaidOut;
-                        returnedFees += feeAmount;
-                    }
-                    newStartIndex = startIndex + i + 1;
-                } else {
-                    // Partial entry: shrink the stored entry by what we consumed (incl. its own fee).
-                    feeAmount = JBFees.standardFeeAmountResultingIn({amountAfterFee: leftoverAmount});
-                    unchecked {
-                        heldFeesOf[projectId][token][startIndex + i].amount -= (leftoverAmount + feeAmount);
-                        returnedFees += feeAmount;
-                    }
-                    leftoverAmount = 0;
-                }
-            }
-
-            unchecked {
-                ++i;
-            }
-        }
-
-        if (startIndex != newStartIndex) nextHeldFeeIndexOf[projectId][token] = newStartIndex;
-
-        emit ReturnHeldFees({
-            projectId: projectId,
-            token: token,
-            amount: amount,
-            returnedFees: returnedFees,
-            leftoverAmount: leftoverAmount,
-            caller: msg.sender
-        });
-    }
-}