@bananapus/core-v6 0.0.1

package/test/TestCashOutHooks.sol

@@ -0,0 +1,317 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+
+contract TestCashOutHooks_Local is TestBaseWorkflow {
+    using JBRulesetMetadataResolver for JBRuleset;
+
+    uint112 private constant _WEIGHT = 1000 * 10 ** 18;
+    address private constant _DATA_HOOK = address(bytes20(keccak256("datahook")));
+
+    IJBController private _controller;
+    IJBMultiTerminal private _terminal;
+    IJBTokens private _tokens;
+    address private _projectOwner;
+    address private _beneficiary;
+
+    uint64 _projectId;
+
+    function setUp() public override {
+        super.setUp();
+
+        vm.label(_DATA_HOOK, "Data Hook");
+
+        _controller = jbController();
+        _projectOwner = multisig();
+        _beneficiary = beneficiary();
+        _terminal = jbMultiTerminal();
+        _tokens = jbTokens();
+
+        JBRulesetMetadata memory _metadata = JBRulesetMetadata({
+            reservedPercent: 0,
+            cashOutTaxRate: 0,
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            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: true,
+            dataHook: _DATA_HOOK,
+            metadata: 0
+        });
+
+        // Package up ruleset configuration.
+        JBRulesetConfig[] memory _rulesetConfig = new JBRulesetConfig[](1);
+        _rulesetConfig[0].mustStartAtOrAfter = 0;
+        _rulesetConfig[0].duration = 0;
+        _rulesetConfig[0].weight = _WEIGHT;
+        _rulesetConfig[0].weightCutPercent = 0;
+        _rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        _rulesetConfig[0].metadata = _metadata;
+        _rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        _rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        JBTerminalConfig[] memory _terminalConfigurations = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory _tokensToAccept = new JBAccountingContext[](1);
+        _tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        _terminalConfigurations[0] =
+            JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: _tokensToAccept});
+
+        // Create a first project to collect fees.
+        _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "myIPFSHash",
+            rulesetConfigurations: _rulesetConfig,
+            terminalConfigurations: _terminalConfigurations,
+            memo: ""
+        });
+
+        _projectId = uint64(
+            _controller.launchProjectFor({
+                owner: _projectOwner,
+                projectUri: "myIPFSHash",
+                rulesetConfigurations: _rulesetConfig,
+                terminalConfigurations: _terminalConfigurations,
+                memo: ""
+            })
+        );
+
+        // Issue the project's tokens.
+        vm.prank(_projectOwner);
+        IJBToken _token = _controller.deployERC20For(_projectId, "TestName", "TestSymbol", bytes32(0));
+
+        // Make sure the project's new project token is set.
+        assertEq(address(_tokens.tokenOf(_projectId)), address(_token));
+    }
+
+    function testCashOutHookWithNoFees() public {
+        // Reference and bound pay amount.
+        uint256 _nativePayAmount = 10 ether;
+        uint256 _halfPaid = 5 ether;
+
+        // Cash out hook address.
+        address _cashOutHook = makeAddr("SOFA");
+        vm.label(_cashOutHook, "Cash Out Delegate");
+
+        // Keep a reference to the current ruleset.
+        (JBRuleset memory _ruleset,) = _controller.currentRulesetOf(_projectId);
+
+        vm.deal(address(this), _nativePayAmount);
+        uint256 _beneficiaryTokensReceived = _terminal.pay{value: _nativePayAmount}({
+            projectId: _projectId,
+            amount: _nativePayAmount,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: address(this),
+            minReturnedTokens: 0,
+            memo: "Forge Test",
+            metadata: ""
+        });
+
+        // Make sure the beneficiary has a balance of project tokens.
+        uint256 _beneficiaryTokenBalance =
+            UD60x18unwrap(UD60x18mul(UD60x18wrap(_nativePayAmount), UD60x18wrap(_WEIGHT)));
+        assertEq(_tokens.totalBalanceOf(address(this), _projectId), _beneficiaryTokenBalance);
+        assertEq(_beneficiaryTokensReceived, _beneficiaryTokenBalance);
+
+        // Make sure the native token balance in terminal is up to date.
+        uint256 _nativeTerminalBalance = _nativePayAmount;
+        assertEq(
+            jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN),
+            _nativeTerminalBalance
+        );
+
+        // Reference cash out hook specifications.
+        JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
+
+        _specifications[0] =
+            JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _halfPaid, metadata: ""});
+
+        vm.startPrank(multisig());
+        // Set the hook as feeless.
+        _terminal.FEELESS_ADDRESSES().setFeelessAddress(_cashOutHook, true);
+        vm.stopPrank();
+
+        // Cash out context.
+        JBAfterCashOutRecordedContext memory _cashOutContext = JBAfterCashOutRecordedContext({
+            holder: address(this),
+            projectId: _projectId,
+            rulesetId: _ruleset.id,
+            cashOutCount: _beneficiaryTokenBalance / 2,
+            reclaimedAmount: JBTokenAmount(
+                JBConstants.NATIVE_TOKEN,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
+                _halfPaid
+            ),
+            forwardedAmount: JBTokenAmount(
+                JBConstants.NATIVE_TOKEN,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
+                _halfPaid
+            ),
+            cashOutTaxRate: 0,
+            beneficiary: payable(address(this)),
+            hookMetadata: "",
+            cashOutMetadata: ""
+        });
+
+        // Mock the hook.
+        vm.mockCall(
+            _cashOutHook,
+            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector),
+            abi.encode(_cashOutContext)
+        );
+
+        // Assert that the hook gets called with the expected value.
+        vm.expectCall(
+            _cashOutHook,
+            _halfPaid,
+            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector, _cashOutContext)
+        );
+
+        vm.mockCall(
+            _DATA_HOOK,
+            abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
+            abi.encode(
+                _ruleset.cashOutTaxRate(), _beneficiaryTokenBalance / 2, _beneficiaryTokenBalance, _specifications
+            )
+        );
+
+        _terminal.cashOutTokensOf({
+            holder: address(this),
+            projectId: _projectId,
+            cashOutCount: _beneficiaryTokenBalance / 2,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(address(this)),
+            metadata: new bytes(0)
+        });
+    }
+
+    function testCashOutHookWithFeesAndCustomInfo() public {
+        // Reference and bound pay amount.
+        uint256 _nativePayAmount = 10 ether;
+        uint256 _halfPaid = 5 ether;
+
+        // Cash out hook address.
+        address _cashOutHook = makeAddr("SOFA");
+        vm.label(_cashOutHook, "Cash Out Delegate");
+
+        // Keep a reference to the current ruleset.
+        (JBRuleset memory _ruleset,) = _controller.currentRulesetOf(_projectId);
+
+        vm.deal(address(this), _nativePayAmount);
+        uint256 _beneficiaryTokensReceived = _terminal.pay{value: _nativePayAmount}({
+            projectId: _projectId,
+            amount: _nativePayAmount,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: address(this),
+            minReturnedTokens: 0,
+            memo: "Forge Test",
+            metadata: ""
+        });
+
+        // Make sure the beneficiary has a balance of project tokens.
+        uint256 _beneficiaryTokenBalance =
+            UD60x18unwrap(UD60x18mul(UD60x18wrap(_nativePayAmount), UD60x18wrap(_WEIGHT)));
+        assertEq(_tokens.totalBalanceOf(address(this), _projectId), _beneficiaryTokenBalance);
+        assertEq(_beneficiaryTokensReceived, _beneficiaryTokenBalance);
+
+        // Make sure the native token balance in terminal is up to date.
+        uint256 _nativeTerminalBalance = _nativePayAmount;
+        assertEq(
+            jbTerminalStore().balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN),
+            _nativeTerminalBalance
+        );
+
+        // Reference cash out hook specifications.
+        JBCashOutHookSpecification[] memory _specifications = new JBCashOutHookSpecification[](1);
+
+        _specifications[0] =
+            JBCashOutHookSpecification({hook: IJBCashOutHook(_cashOutHook), amount: _halfPaid, metadata: ""});
+
+        uint256 _customCashOutTaxRate = JBConstants.MAX_CASH_OUT_TAX_RATE / 2;
+        uint256 _customCashOutCount = 1 * 10 ** 18;
+        uint256 _customTotalSupply = 5 * 10 ** 18;
+
+        uint256 _forwardedAmount = _halfPaid - (_halfPaid * _terminal.FEE() / JBConstants.MAX_FEE);
+
+        uint256 _beneficiaryAmount = mulDiv(
+            mulDiv(_nativePayAmount, _customCashOutCount, _customTotalSupply),
+            (JBConstants.MAX_CASH_OUT_TAX_RATE - _customCashOutTaxRate)
+                + mulDiv(_customCashOutCount, _customCashOutTaxRate, _customTotalSupply),
+            JBConstants.MAX_CASH_OUT_TAX_RATE
+        );
+
+        _beneficiaryAmount -= mulDiv(_beneficiaryAmount, _terminal.FEE(), JBConstants.MAX_FEE);
+
+        // Cash out context.
+        JBAfterCashOutRecordedContext memory _cashOutContext = JBAfterCashOutRecordedContext({
+            holder: address(this),
+            projectId: _projectId,
+            rulesetId: _ruleset.id,
+            cashOutCount: _beneficiaryTokenBalance / 2,
+            reclaimedAmount: JBTokenAmount(
+                JBConstants.NATIVE_TOKEN,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
+                _beneficiaryAmount
+            ),
+            forwardedAmount: JBTokenAmount(
+                JBConstants.NATIVE_TOKEN,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).decimals,
+                _terminal.accountingContextForTokenOf(_projectId, JBConstants.NATIVE_TOKEN).currency,
+                _forwardedAmount
+            ),
+            cashOutTaxRate: uint16(_customCashOutTaxRate),
+            beneficiary: payable(address(this)),
+            hookMetadata: "",
+            cashOutMetadata: ""
+        });
+
+        // Mock the hook.
+        vm.mockCall(
+            _cashOutHook,
+            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector),
+            abi.encode(_cashOutContext)
+        );
+
+        // Assert that the hook gets called with the expected value.
+        vm.expectCall(
+            _cashOutHook,
+            _forwardedAmount,
+            abi.encodeWithSelector(IJBCashOutHook.afterCashOutRecordedWith.selector, _cashOutContext)
+        );
+
+        vm.mockCall(
+            _DATA_HOOK,
+            abi.encodeWithSelector(IJBRulesetDataHook.beforeCashOutRecordedWith.selector),
+            abi.encode(_customCashOutTaxRate, _customCashOutCount, _customTotalSupply, _specifications)
+        );
+
+        _terminal.cashOutTokensOf({
+            holder: address(this),
+            projectId: _projectId,
+            cashOutCount: _beneficiaryTokenBalance / 2,
+            tokenToReclaim: JBConstants.NATIVE_TOKEN,
+            minTokensReclaimed: 0,
+            beneficiary: payable(address(this)),
+            metadata: new bytes(0)
+        });
+    }
+
+    receive() external payable {}
+    fallback() external payable {}
+}

package/test/TestCashOutTimingEdge.sol

@@ -0,0 +1,229 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.6;
+
+import /* {*} from */ "./helpers/TestBaseWorkflow.sol";
+import {JBCashOuts} from "../src/libraries/JBCashOuts.sol";
+
+/// @notice Edge case tests for cross-ruleset cash outs and pending reserves inflation (H-4).
+/// Demonstrates that pending reserved tokens inflate totalSupply in cash-out calculations,
+/// systematically undervaluing cash-outs until reserves are distributed.
+contract TestCashOutTimingEdge_Local is TestBaseWorkflow {
+    IJBController private _controller;
+    IJBMultiTerminal private _terminal;
+    JBTokens private _tokens;
+    JBTerminalStore private _store;
+    uint256 private _projectId;
+    address private _projectOwner;
+    address private _payer;
+
+    uint112 private constant WEIGHT = 1000 * 10 ** 18;
+    uint112 private constant PAY_AMOUNT = 10 ether;
+
+    function setUp() public override {
+        super.setUp();
+
+        _projectOwner = multisig();
+        _payer = beneficiary();
+        _controller = jbController();
+        _terminal = jbMultiTerminal();
+        _tokens = jbTokens();
+        _store = jbTerminalStore();
+
+        // Ruleset: 50% reserved, 50% cash-out tax, no duration (persists forever).
+        JBRulesetMetadata memory metadata = JBRulesetMetadata({
+            reservedPercent: 5000, // 50%
+            cashOutTaxRate: 5000, // 50%
+            baseCurrency: uint32(uint160(JBConstants.NATIVE_TOKEN)),
+            pausePay: false,
+            pauseCreditTransfers: false,
+            allowOwnerMinting: true,
+            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
+        });
+
+        JBRulesetConfig[] memory rulesetConfig = new JBRulesetConfig[](1);
+        rulesetConfig[0].mustStartAtOrAfter = 0;
+        rulesetConfig[0].duration = 0;
+        rulesetConfig[0].weight = WEIGHT;
+        rulesetConfig[0].weightCutPercent = 0;
+        rulesetConfig[0].approvalHook = IJBRulesetApprovalHook(address(0));
+        rulesetConfig[0].metadata = metadata;
+        rulesetConfig[0].splitGroups = new JBSplitGroup[](0);
+        rulesetConfig[0].fundAccessLimitGroups = new JBFundAccessLimitGroup[](0);
+
+        JBTerminalConfig[] memory terminalConfigs = new JBTerminalConfig[](1);
+        JBAccountingContext[] memory tokensToAccept = new JBAccountingContext[](1);
+        tokensToAccept[0] = JBAccountingContext({
+            token: JBConstants.NATIVE_TOKEN, decimals: 18, currency: uint32(uint160(JBConstants.NATIVE_TOKEN))
+        });
+        terminalConfigs[0] = JBTerminalConfig({terminal: _terminal, accountingContextsToAccept: tokensToAccept});
+
+        // Fee project (#1).
+        _controller.launchProjectFor({
+            owner: address(420),
+            projectUri: "fee",
+            rulesetConfigurations: rulesetConfig,
+            terminalConfigurations: terminalConfigs,
+            memo: ""
+        });
+
+        // Test project (#2).
+        _projectId = _controller.launchProjectFor({
+            owner: _projectOwner,
+            projectUri: "test",
+            rulesetConfigurations: rulesetConfig,
+            terminalConfigurations: terminalConfigs,
+            memo: ""
+        });
+
+        // Deploy ERC20 for the project.
+        vm.prank(_projectOwner);
+        _controller.deployERC20For(_projectId, "Test", "TST", bytes32(0));
+    }
+
+    /// @notice H-4 CONFIRMATION: Pending reserves inflate totalSupply, reducing cash-out value.
+    /// When reserves exist but haven't been distributed, totalTokenSupplyWithReservedTokensOf
+    /// includes them in the denominator, making each token worth less.
+    function test_pendingReserves_inflateSupply_reduceCashOut() external {
+        // Pay the project.
+        _terminal.pay{value: PAY_AMOUNT}({
+            projectId: _projectId,
+            amount: PAY_AMOUNT,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: _payer,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        // Check payer's token balance. With 50% reserved, payer gets 50% of tokens.
+        uint256 payerTokens = _tokens.totalBalanceOf(_payer, _projectId);
+        assertGt(payerTokens, 0, "Payer should have tokens");
+
+        // Check pending reserves.
+        uint256 pendingReserves = _controller.pendingReservedTokenBalanceOf(_projectId);
+        assertGt(pendingReserves, 0, "Should have pending reserves");
+
+        // Total supply WITH pending reserves (used in cash-out calculation).
+        uint256 totalWithReserves = _controller.totalTokenSupplyWithReservedTokensOf(_projectId);
+        // Total supply WITHOUT pending reserves (actual circulating).
+        uint256 circulatingSupply = _tokens.totalSupplyOf(_projectId);
+
+        assertGt(totalWithReserves, circulatingSupply, "Total with reserves should exceed circulating");
+        assertEq(totalWithReserves, circulatingSupply + pendingReserves, "Total = circulating + pending reserves");
+
+        // Compute cash-out value with inflated supply (what the system does).
+        uint256 surplus = _store.balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN);
+        uint256 reclaimWithInflation = JBCashOuts.cashOutFrom({
+            surplus: surplus, cashOutCount: payerTokens, totalSupply: totalWithReserves, cashOutTaxRate: 5000
+        });
+
+        // Compute what the cash-out WOULD be without pending reserves (hypothetical).
+        uint256 reclaimWithoutInflation = JBCashOuts.cashOutFrom({
+            surplus: surplus, cashOutCount: payerTokens, totalSupply: circulatingSupply, cashOutTaxRate: 5000
+        });
+
+        // H-4 CONFIRMED: Cash-out with pending reserves is LESS than without.
+        assertLt(reclaimWithInflation, reclaimWithoutInflation, "H-4: Pending reserves reduce cash-out value");
+
+        // Quantify the impact.
+        uint256 lostValue = reclaimWithoutInflation - reclaimWithInflation;
+        assertGt(lostValue, 0, "Lost value should be non-zero");
+    }
+
+    /// @notice Distribute reserves first, then cash out — value should be higher.
+    function test_distributeReserves_thenCashOut_higherReclaim() external {
+        // Pay the project.
+        _terminal.pay{value: PAY_AMOUNT}({
+            projectId: _projectId,
+            amount: PAY_AMOUNT,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: _payer,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        uint256 payerTokens = _tokens.totalBalanceOf(_payer, _projectId);
+
+        // Snapshot cash-out value BEFORE distributing reserves.
+        uint256 surplus = _store.balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN);
+        uint256 totalBefore = _controller.totalTokenSupplyWithReservedTokensOf(_projectId);
+        uint256 reclaimBefore = JBCashOuts.cashOutFrom({
+            surplus: surplus, cashOutCount: payerTokens, totalSupply: totalBefore, cashOutTaxRate: 5000
+        });
+
+        // Distribute reserves. This mints pending tokens and zeroes pending balance.
+        _controller.sendReservedTokensToSplitsOf(_projectId);
+
+        // After distribution, pending reserves should be 0.
+        assertEq(
+            _controller.pendingReservedTokenBalanceOf(_projectId), 0, "Pending reserves should be 0 after distribution"
+        );
+
+        // Total supply should be the same (pending tokens are now real tokens).
+        uint256 totalAfter = _controller.totalTokenSupplyWithReservedTokensOf(_projectId);
+        assertEq(totalAfter, totalBefore, "Total supply unchanged after distribution");
+
+        // Cash-out value should be the same since total didn't change.
+        // The fix for H-4 would be: don't include pending reserves in totalSupply.
+        uint256 reclaimAfter = JBCashOuts.cashOutFrom({
+            surplus: surplus, cashOutCount: payerTokens, totalSupply: totalAfter, cashOutTaxRate: 5000
+        });
+
+        assertEq(reclaimAfter, reclaimBefore, "Reclaim unchanged after distributing (same totalSupply)");
+    }
+
+    /// @notice Quantify exact impact: with 50% reserved, cash-out gets ~44% less value
+    /// than it would if pending reserves were excluded from totalSupply.
+    function test_pendingReserves_quantifyImpact() external {
+        _terminal.pay{value: PAY_AMOUNT}({
+            projectId: _projectId,
+            amount: PAY_AMOUNT,
+            token: JBConstants.NATIVE_TOKEN,
+            beneficiary: _payer,
+            minReturnedTokens: 0,
+            memo: "",
+            metadata: new bytes(0)
+        });
+
+        uint256 payerTokens = _tokens.totalBalanceOf(_payer, _projectId);
+        uint256 surplus = _store.balanceOf(address(_terminal), _projectId, JBConstants.NATIVE_TOKEN);
+        uint256 totalWithReserves = _controller.totalTokenSupplyWithReservedTokensOf(_projectId);
+        uint256 circulatingOnly = _tokens.totalSupplyOf(_projectId);
+
+        uint256 reclaimActual = JBCashOuts.cashOutFrom({
+            surplus: surplus, cashOutCount: payerTokens, totalSupply: totalWithReserves, cashOutTaxRate: 5000
+        });
+
+        uint256 reclaimFair = JBCashOuts.cashOutFrom({
+            surplus: surplus, cashOutCount: payerTokens, totalSupply: circulatingOnly, cashOutTaxRate: 5000
+        });
+
+        // With 50% reserved:
+        // - circulatingOnly = payerTokens (payer gets all non-reserved tokens)
+        // - totalWithReserves = 2 * payerTokens
+        // At 50% tax and cashOutCount == circulatingOnly:
+        //   reclaimFair = surplus (full amount, since cashOutCount >= totalSupply)
+        //   reclaimActual = surplus * (payerTokens / 2*payerTokens) * ((5000 + 5000*0.5) / 10000)
+        //                 = surplus * 0.5 * 0.75 = surplus * 0.375
+
+        // The impact is significant — actual is only 37.5% of surplus vs 100%.
+        assertGt(reclaimFair, reclaimActual, "Fair reclaim significantly higher than actual");
+
+        // Log the percentage lost.
+        uint256 percentLost = ((reclaimFair - reclaimActual) * 10_000) / reclaimFair;
+        assertGt(percentLost, 5000, "More than 50% value lost due to pending reserves");
+    }
+}