Docs time consensus funding at "roughly two days", but partial withdrawals wait in the exit queue, so a validator following them defaults

//SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.34;

import {BaseTest} from "./BaseTest.sol";
import {Coffer} from "../../src/Coffer.sol";

/// Y03: an honest validator funds a maturity through Withdraw · Consensus, timed by the docs'
/// "the ETH arrives in the contract with the beacon sweep, roughly two days after the request".
/// The consensus layer is MODELLED: Electra process_withdrawal_request puts a partial through
/// compute_exit_epoch_and_update_churn (the shared exit churn, 256 ETH/epoch) and then
/// MIN_VALIDATOR_WITHDRAWABILITY_DELAY (256 epochs ~27.3h). Live exit queue 2026-10-15
/// (measured from beacon state, 2026-10-15): about 5.4 days. The partial's arrival is applied with deal().
contract Y03FundingLatency is BaseTest {
    uint32 constant RATE_2PCT = 2_000_000;
    uint32 constant D90 = 90 days;
    uint32 constant D365 = 365 days;
    uint16 constant BUF = 200;
    uint128 constant START = 64 ether; // a 0x02 validator with excess above 32 ETH, so partials can fund
    uint256 constant WITHDRAWABILITY = 256 * 384; // 256 epochs * 6.4 min
    uint256 constant EXIT_QUEUE_NOW = 5 days + 9 hours; // measured 2026-10-15 from beacon state: newest pending partial withdrawable_epoch - 256 - head = 1,209 epochs
    uint256 constant DOCS_LATENCY = 2 days; // "roughly two days after the request"

    Coffer c;
    uint256 bondA;
    uint256 bondB;
    uint128 mA;
    uint128 mB;
    uint256 t0;

    function setUp() public override {
        super.setUp();
        address a = createCoffer(
            validator, validPublicKeyPart1, validPublicKeyPart2, RATE_2PCT, D90, D365, 1 ether, BUF, START
        );
        c = Coffer(payable(a));
        t0 = block.timestamp;
        (,,,,, uint32 v,,,,) = c.sValidatorConditions();
        bondA = buyBond(a, holder1, 20 ether, D90, v); // matures day 90
        bondB = buyBond(a, holder2, 30 ether, D365, v); // matures day 365
        (mA,,) = c.sHolderConditions(bondA);
        (mB,,) = c.sHolderConditions(bondB);
    }

    /// Validator requests a partial of mA `lead` seconds before bond A matures; it lands `latency` later.
    function _run(uint256 lead, uint256 latency) internal returns (bool defaulted, uint256 bPaidAt) {
        uint256 maturityA = t0 + D90;
        vm.warp(maturityA - lead);
        uint256 fee = uint256(bytes32(_fee()));
        vm.prank(validator);
        c.validatorWithdrawFromConsensus{value: fee * 6}(uint64(mA / 1 gwei) + 1); // app sends 6x the fee
        uint256 landsAt = maturityA - lead + latency;
        uint256 bal = address(c).balance;

        if (landsAt <= maturityA) {
            vm.warp(landsAt);
            vm.deal(address(c), address(c).balance + mA + 1 gwei);
        }
        // Holder A redeems at maturity, as the docs tell it to
        vm.warp(maturityA);
        vm.prank(holder1);
        bool paid = c.holderRedeemBondOrDefault(bondA);
        (,,,,,,,,, defaulted) = c.sValidatorConditions();
        assertEq(paid, !defaulted);

        if (defaulted) {
            // Holder B forces the validator's exit (irrevocable) and waits for funds
            uint256 f2 = uint256(bytes32(_fee()));
            vm.deal(holder2, holder2.balance + f2);
            vm.prank(holder2);
            c.exitValidator{value: f2}();
            // The consensus partial finally lands
            vm.warp(landsAt);
            vm.deal(address(c), address(c).balance + mA + 1 gwei);
            vm.prank(holder1);
            c.holderRedeemBondInDefault(bondA);
            // B is accelerated: claimable now at full maturity value; the rest of the stake sweeps in later
            vm.deal(address(c), address(c).balance + 44 ether); // modelled exit sweep of the remaining stake
            uint256 before = holder2.balance;
            vm.prank(holder2);
            c.holderRedeemBondInDefault(bondB);
            assertEq(holder2.balance - before, mB, "B paid in full, early");
            bPaidAt = block.timestamp;
        } else {
            bPaidAt = t0 + D365;
        }
        bal;
    }

    function _fee() internal view returns (bytes memory d) {
        (, d) = address(0x00000961Ef480Eb55e80D19ad83579A64c007002).staticcall("");
    }

    /// Docs-literal: request 3 days ahead (more than "roughly two days"); today's queue applies.
    function test_Y03_docsTimingDefaultsHonestValidator() public {
        (bool defaulted, uint256 bPaidAt) = _run(3 days, EXIT_QUEUE_NOW + WITHDRAWABILITY);
        assertTrue(defaulted, "honest validator defaulted");
        uint256 early = t0 + D365 - bPaidAt;
        emit log_named_uint("mA (wei)", mA);
        emit log_named_uint("mB (wei)", mB);
        emit log_named_uint("B paid days before its maturity", early / 1 days);
        // Validator pays B ~259 days early (cost at its own 2% rate) and loses its validator (forced exit)
        emit log_named_uint("time-value cost of acceleration at 2%/yr (wei)", uint256(mB) * 2 * early / (100 * 365 days));
        assertGt(early, 250 days);
    }

    /// Control A: the docs' latency holds (empty exit queue) -> no default.
    function test_Y03_control_emptyQueue() public {
        (bool defaulted,) = _run(3 days, 5 * 384 + WITHDRAWABILITY);
        assertFalse(defaulted);
    }

    /// Mutation: guidance says "exit-queue wait + ~27h; check the live queue" -> validator requests in time.
    function test_Y03_mutation_queueAwareGuidance() public {
        (bool defaulted,) = _run(EXIT_QUEUE_NOW + WITHDRAWABILITY + 1 days, EXIT_QUEUE_NOW + WITHDRAWABILITY);
        assertFalse(defaulted);
    }
}

[PASS] test_Y03_control_emptyQueue()
[PASS] test_Y03_docsTimingDefaultsHonestValidator()
  B paid days before its maturity: 271
  time-value cost of acceleration at 2%/yr (wei): 455116716529680365
[PASS] test_Y03_mutation_queueAwareGuidance()