深入探索以太坊共识层:存款与提款

export const uint8 = basic('uint8', int(1), 0);
export const uint16 = basic('uint16', int(2), 0);
export const uint32 = basic('uint32', int(4), 0);
export const uint64 = basic('uint64', int(8, false), _0n);
export const uint128 = basic('uint128', int(16, false), _0n);
export const uint256 = basic('uint256', int(32, false), _0n);

import type { Bytes } from "micro-eth-signer/utils";
import * as ssz from "micro-eth-signer/advanced/ssz.js";
import * as P from "micro-packed";

const padh = (n: number | bigint, pad: number) =>
  n.toString(16).padStart(pad, "0");

const bytesToHex = (b: Bytes): string =>
  Array.from(b)
    .map((e) => padh(e, 2))
    .join("");

const example = ssz.uint16.encode(BigInt("12345"));
console.log(bytesToHex(example));

const example = ssz.vector(4, ssz.uint8).encode([1, 5, 0, 2]);
console.log(bytesToHex(example));

const example = ssz.vector(3, ssz.uint8).encode([1, 2, 3]);
console.log(bytesToHex(example));

const example = ssz
  .container({ x: ssz.uint8, y: ssz.list(16, ssz.uint8), z: ssz.uint16 })
  .encode({
    x: 1,
    y: [2, 3, 4, 5],
    z: 6
  });
console.log(bytesToHex(example));

const example = ssz
  .bitlist(8)
  .encode([true, true, true, true, true, true, true, true]);
console.log(bytesToHex(example));

class DepositData(Container):
    pubkey: BLSPubkey
    withdrawal_credentials: Bytes32
    amount: Gwei
    signature: BLSSignature  # Signing over DepositMessage

const BeaconState = container({
  genesis_time: uint64,
  genesis_validators_root: Root,
  slot: Slot,
  fork: Fork,
  latest_block_header: BeaconBlockHeader,
  block_roots: vector(SLOTS_PER_HISTORICAL_ROOT, Root),
  state_roots: vector(SLOTS_PER_HISTORICAL_ROOT, Root),
  historical_roots: list(HISTORICAL_ROOTS_LIMIT, Root),
  eth1_data: Eth1Data,
  eth1_data_votes: list(EPOCHS_PER_ETH1_VOTING_PERIOD * SLOTS_PER_EPOCH, Eth1Data),
  eth1_deposit_index: uint64,
  validators: list(VALIDATOR_REGISTRY_LIMIT, Validator),
  balances: list(VALIDATOR_REGISTRY_LIMIT, Gwei),
  randao_mixes: vector(EPOCHS_PER_HISTORICAL_VECTOR, Bytes32),
  slashings: vector(EPOCHS_PER_SLASHINGS_VECTOR, Gwei),
  previous_epoch_participation: list(VALIDATOR_REGISTRY_LIMIT, ParticipationFlags),
  current_epoch_participation: list(VALIDATOR_REGISTRY_LIMIT, ParticipationFlags),
  justification_bits: bitvector(JUSTIFICATION_BITS_LENGTH),
  previous_justified_checkpoint: Checkpoint,
  current_justified_checkpoint: Checkpoint,
  finalized_checkpoint: Checkpoint,
  inactivity_scores: list(VALIDATOR_REGISTRY_LIMIT, uint64),
  current_sync_committee: SyncCommittee,
  next_sync_committee: SyncCommittee,
  latest_execution_payload_header: ExecutionPayloadHeader,
  next_withdrawal_index: WithdrawalIndex,
  next_withdrawal_validator_index: ValidatorIndex,
  historical_summaries: list(HISTORICAL_ROOTS_LIMIT, HistoricalSummary),
});

import { sha256 } from "@noble/hashes/sha2.js";
import * as P from "micro-packed";
import { isBytes, type Bytes } from "micro-eth-signer/utils";
import { hexToBytes, bytesToHex } from "@noble/hashes/utils";

const BYTES_PER_CHUNK = 32; // Should be equal to digest size of hash
const EMPTY_CHUNK = new Uint8Array(BYTES_PER_CHUNK);
const hash = (a: Uint8Array, b: Uint8Array): Uint8Array =>
  sha256.create().update(a).update(b).digest();
const mixInLength = (root: Uint8Array, length: number) =>
  hash(root, P.U256LE.encode(BigInt(length)));

// Will OOM without this, because tree padded to next power of two.
const zeroHashes = /* @__PURE__ */ (() => {
  const res: Bytes[] = [EMPTY_CHUNK];
  for (let i = 0; i < 64; i++) res.push(hash(res[i], res[i]));
  return res;
})();

export const merkleize = (chunks: Uint8Array[], limit?: number): Uint8Array => {
  let chunksLen = chunks.length;
  if (limit !== undefined) {
    if (limit < chunks.length) {
      throw new Error(
        `SSZ/merkleize: limit (${limit}) is less than the number of chunks (${chunks.length})`,
      );
    }
    chunksLen = limit;
  }
  // log2(next power of two), we cannot use binary ops since it can be bigger than 2**32.
  const depth = Math.ceil(Math.log2(chunksLen));

  if (chunks.length == 0) return zeroHashes[depth];
  for (let l = 0; l < depth; l++) {
    const level = [];
    for (let i = 0; i < chunks.length; i += 2)
      level.push(
        hash(chunks[i], i + 1 < chunks.length ? chunks[i + 1] : zeroHashes[l]),
      );

    chunks = level;
  }

  return chunks[0];
};

const a = P.U256LE.encode(1n);
const b = P.U256LE.encode(2n);
const c = P.U256LE.encode(3n);

const z = P.U256LE.encode(0n);

console.log(bytesToHex(merkleize([a, b, c])));
console.log(bytesToHex(merkleize([a, b, c, z])));

const Epoch = ssz.uint64;
const Root = ssz.bytevector(32);
const Checkpoint = ssz.container({ epoch: Epoch, root: Root });
const merkleRoot = Checkpoint.merkleRoot({
  epoch: 3,
  root: hexToBytes(
    "49e21ba6fbe660d8aac793f1e168cdbf860a3b5b1791bdab188ba1c4b094b813",
  ),
});
console.log(bytesToHex(merkleRoot));

const epoch = P.U256LE.encode(3n);
const root = hexToBytes(
  "49e21ba6fbe660d8aac793f1e168cdbf860a3b5b1791bdab188ba1c4b094b813",
);

console.log(bytesToHex(merkleize([epoch, root])));

const ValidatorIndex = ssz.uint64;
const MAX_VALIDATORS_PER_COMMITTEE = 2048;

const indicesMerkleRoot = ssz
  .list(MAX_VALIDATORS_PER_COMMITTEE, ValidatorIndex)
  .merkleRoot([33652, 59750, 92360]);

const indicesMerkleData = ssz
  .list(MAX_VALIDATORS_PER_COMMITTEE, ValidatorIndex)
  .encode([33652, 59750, 92360]);

console.log(`Merkle Root: ${bytesToHex(indicesMerkleRoot)}`);
console.log(`Indices Data: ${bytesToHex(indicesMerkleData)}`);

const data = hexToBytes(
  "748300000000000066e9000000000000c8680100000000000000000000000000",
);

console.log(bytesToHex(hash(merkleize([data], 512), P.U256LE.encode(3n))));

const MAX_VALIDATORS_PER_COMMITTEE = 2048;
const Slot = ssz.uint64;
const Epoch = ssz.uint64;
const CommitteeIndex = ssz.uint64;
const Root = ssz.bytevector(32);
const ValidatorIndex = ssz.uint64;
const BLSSignature = ssz.bytevector(96);

const Checkpoint = ssz.container({ epoch: Epoch, root: Root });

const AttestationData = ssz.container({
  slot: Slot,
  index: CommitteeIndex,
  beacon_block_root: Root,
  source: Checkpoint,
  target: Checkpoint,
});

const IndexedAttestation = ssz.container({
  attesting_indices: ssz.list(MAX_VALIDATORS_PER_COMMITTEE, ValidatorIndex),
  data: AttestationData,
  signature: BLSSignature,
});

const indexData = {
  attesting_indices: [33652, 59750, 92360],
  data: {
    slot: 3080829,
    index: 9,
    beacon_block_root: hexToBytes(
      "4f4250c05956f5c2b87129cf7372f14dd576fc152543bf7042e963196b843fe6",
    ),
    source: {
      epoch: 96274,
      root: hexToBytes(
        "d24639f2e661bc1adcbe7157280776cf76670fff0fee0691f146ab827f4f1ade",
      ),
    },
    target: {
      epoch: 96275,
      root: hexToBytes(
        "9bcd31881817ddeab686f878c8619d664e8bfa4f8948707cba5bc25c8d74915d",
      ),
    },
  },
  signature: hexToBytes(
    "aaf504503ff15ae86723c906b4b6bac91ad728e4431aea3be2e8e3acc888d8af" +
      "5dffbbcf53b234ea8e3fde67fbb09120027335ec63cf23f0213cc439e8d1b856" +
      "c2ddfc1a78ed3326fb9b4fe333af4ad3702159dbf9caeb1a4633b752991ac437",
  ),
};

const attestation = IndexedAttestation.merkleRoot(indexData);
console.log(bytesToHex(attestation));

class DepositData(Container):
    pubkey: BLSPubkey
    withdrawal_credentials: Bytes32
    amount: Gwei
    signature: BLSSignature  # Signing over DepositMessage

bytes32 pubkey_root = sha256(abi.encodePacked(pubkey, bytes16(0)));
bytes32 signature_root = sha256(abi.encodePacked(
    sha256(abi.encodePacked(signature[:64])),
    sha256(abi.encodePacked(signature[64:], bytes32(0)))
));
bytes32 node = sha256(abi.encodePacked(
    sha256(abi.encodePacked(pubkey_root, withdrawal_credentials)),
    sha256(abi.encodePacked(amount, bytes24(0), signature_root))
));

function deposit(
    bytes calldata pubkey,
    bytes calldata withdrawal_credentials,
    bytes calldata signature,
    bytes32 deposit_data_root
) override external payable {
    // Extended ABI length checks since dynamic types are used.
    require(pubkey.length == 48, "DepositContract: invalid pubkey length");
    require(withdrawal_credentials.length == 32, "DepositContract: invalid withdrawal_credentials length");
    require(signature.length == 96, "DepositContract: invalid signature length");

    // Check deposit amount
    require(msg.value >= 1 ether, "DepositContract: deposit value too low");
    require(msg.value % 1 gwei == 0, "DepositContract: deposit value not multiple of gwei");
    uint deposit_amount = msg.value / 1 gwei;
    require(deposit_amount <= type(uint64).max, "DepositContract: deposit value too high");

    // Emit `DepositEvent` log
    bytes memory amount = to_little_endian_64(uint64(deposit_amount));
    emit DepositEvent(
        pubkey,
        withdrawal_credentials,
        amount,
        signature,
        to_little_endian_64(uint64(deposit_count))
    );

    // Compute deposit data root (`DepositData` hash tree root)
    bytes32 pubkey_root = sha256(abi.encodePacked(pubkey, bytes16(0)));
    bytes32 signature_root = sha256(abi.encodePacked(
        sha256(abi.encodePacked(signature[:64])),
        sha256(abi.encodePacked(signature[64:], bytes32(0)))
    ));
    bytes32 node = sha256(abi.encodePacked(
        sha256(abi.encodePacked(pubkey_root, withdrawal_credentials)),
        sha256(abi.encodePacked(amount, bytes24(0), signature_root))
    ));

    // Verify computed and expected deposit data roots match
    require(node == deposit_data_root, "DepositContract: reconstructed DepositData does not match supplied deposit_data_root");

    // Avoid overflowing the Merkle tree (and prevent edge case in computing `branch`)
    require(deposit_count < MAX_DEPOSIT_COUNT, "DepositContract: merkle tree full");

    // Add deposit data root to Merkle tree (update a single `branch` node)
    deposit_count += 1;
    uint size = deposit_count;
    for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
        if ((size & 1) == 1) {
            branch[height] = node;
            return;
        }
        node = sha256(abi.encodePacked(branch[height], node));
        size /= 2;
    }
    // As the loop should always end prematurely with the `return` statement,
    // this code should be unreachable. We assert `false` just to be safe.
    assert(false);
}

for (uint256 i = vfi.funded; i < vfi.funded + _validatorCount; ) {
    bytes memory publicKey = operator.publicKeys[i];
    bytes memory signature = operator.signatures[i];
    address consensusLayerRecipient = _getDeterministicReceiver(publicKey, CONSENSUS_LAYER_SALT_PREFIX);
    bytes32 withdrawalCredentials = _addressToWithdrawalCredentials(consensusLayerRecipient);
    bytes32 pubkeyRoot = _getPubKeyRoot(publicKey);
    _depositValidator(publicKey, pubkeyRoot, signature, withdrawalCredentials);
    StakingContractStorageLib.getWithdrawers().value[pubkeyRoot] = msg.sender;
    emit Deposit(msg.sender, msg.sender, publicKey, signature);
    unchecked {
        ++i;
    }
}

/// @notice Internal utility to compute the receiver deterministic address
/// @param _publicKey Public Key assigned to the receiver
/// @param _prefix Prefix used to generate multiple receivers per public key
function _getDeterministicReceiver(bytes memory _publicKey, uint256 _prefix) internal view returns (address) {
    bytes32 publicKeyRoot = _getPubKeyRoot(_publicKey);
    bytes32 salt = sha256(abi.encodePacked(_prefix, publicKeyRoot));
    address implementation = StakingContractStorageLib.getFeeRecipientImplementation();
    return Clones.predictDeterministicAddress(implementation, salt);
}

bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] branch;
uint256 deposit_count;

bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] zero_hashes;

constructor() public {
    // Compute hashes in empty sparse Merkle tree
    for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH - 1; height++)
        zero_hashes[height + 1] = sha256(abi.encodePacked(zero_hashes[height], zero_hashes[height]));
}

// Add deposit data root to Merkle tree (update a single `branch` node)
deposit_count += 1;
uint size = deposit_count;
for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
    if ((size & 1) == 1) {
        branch[height] = node;
        return;
    }
    node = sha256(abi.encodePacked(branch[height], node));
    size /= 2;
}

function get_deposit_root() override external view returns (bytes32) {
    bytes32 node;
    uint size = deposit_count;
    for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
        if ((size & 1) == 1)
            node = sha256(abi.encodePacked(branch[height], node));
        else
            node = sha256(abi.encodePacked(node, zero_hashes[height]));
        size /= 2;
    }
    return sha256(abi.encodePacked(
        node,
        to_little_endian_64(uint64(deposit_count)),
        bytes24(0)
    ));
}

deposit_count += 1;
uint size = deposit_count;
for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
    if ((size & 1) == 1) {
        branch[height] = node;
        return;
    }
    node = sha256(abi.encodePacked(branch[height], node));
    size /= 2;
}

function get_deposit_root() override external view returns (bytes32) {
    bytes32 node;
    uint size = deposit_count;
    for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
        if ((size & 1) == 1)
            node = sha256(abi.encodePacked(branch[height], node));
        else
            node = sha256(abi.encodePacked(node, zero_hashes[height]));
        size /= 2;
    }
    return sha256(abi.encodePacked(
        node,
        to_little_endian_64(uint64(deposit_count)),
        bytes24(0)
    ));
}

{
  "execution_requests": {
  "deposits": [
    {
      "pubkey": "0xada8cbda3e18b5eccfaed1d777dbd3c6a43b2debecd157b179f33a781c0c48183b7b5cc263b235d61829b236b38c704e",
      "withdrawal_credentials": "0x0100000000000000000000007e2a2fa2a064f693f0a55c5639476d913ff12d05",
      "amount": "32000000000",
      "signature": "0xa3d1ea016677ef70131a653195b4237f74786be19db7ce6650c383d396c8413e420741c1a62cfb7e8287c39d37b5b30606bd1c9d886a43ad4c21c2f38f9f69e7087d5038d2e960b38fabb363f4c0ddac946479e24601aa3c817e32dd29e4bfc3",
      "index": "2251904"
    }
  ],
  "withdrawals": [],
  "consolidations": []
  }
}

let expected_deposit_len = std::cmp::min(
    E::MaxDeposits::to_u64(),
    eth1_deposit_index_limit.safe_sub(state.eth1_deposit_index())?,
);
block_verify!(
    deposits.len() as u64 == expected_deposit_len,
    BlockProcessingError::DepositCountInvalid {
        expected: expected_deposit_len as usize,
        found: deposits.len(),
    }
);

// Check if deposit fits in the churn, otherwise, do no more deposit processing in this epoch.
is_churn_limit_reached =
    processed_amount.safe_add(deposit.amount)? > available_for_processing;
if is_churn_limit_reached {
    break;
}

let available_for_processing = state
    .deposit_balance_to_consume()?
    .safe_add(state.get_activation_exit_churn_limit(spec)?)?;

pub fn get_balance_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
    let total_active_balance = self.get_total_active_balance()?;
    let churn = std::cmp::max(
        spec.min_per_epoch_churn_limit_electra, // 128 ETH
        total_active_balance.safe_div(spec.churn_limit_quotient)?, // active balance / 65536
    );

    Ok(churn.safe_sub(churn.safe_rem(spec.effective_balance_increment)?)?)
}

/// Return the churn limit for the current epoch dedicated to activations and exits.
pub fn get_activation_exit_churn_limit(&self, spec: &ChainSpec) -> Result<u64, Error> {
    Ok(std::cmp::min(
        spec.max_per_epoch_activation_exit_churn_limit, // 256 ETH
        self.get_balance_churn_limit(spec)?,
    ))
}

// Accumulate churn only if the churn limit has been hit.
let deposit_balance_to_consume = if is_churn_limit_reached {
    available_for_processing.safe_sub(processed_amount)?
} else {
    0
};

/// @notice Withdraw the Consensus Layer Fee for a given validator public key
/// @dev Funds are sent to the withdrawer account
/// @param _publicKey Validator to withdraw Consensus Layer Fees from
function withdrawCLFee(bytes calldata _publicKey) external {
    _onlyWithdrawerOrAdmin(_publicKey);
    _deployAndWithdraw(_publicKey, CONSENSUS_LAYER_SALT_PREFIX, StakingContractStorageLib.getCLDispatcher());
}

/// @notice Internal utility to deploy and withdraw the fees from a receiver
/// @param _publicKey Public Key assigned to the receiver
/// @param _prefix Prefix used to generate multiple receivers per public key
/// @param _dispatcher Address of the dispatcher contract
function _deployAndWithdraw(
    bytes memory _publicKey,
    uint256 _prefix,
    address _dispatcher
) internal {
    bytes32 publicKeyRoot = _getPubKeyRoot(_publicKey);
    _revertIfSanctioned(msg.sender);
    bytes32 feeRecipientSalt = sha256(abi.encodePacked(_prefix, publicKeyRoot));
    address implementation = StakingContractStorageLib.getFeeRecipientImplementation();
    address feeRecipientAddress = Clones.predictDeterministicAddress(implementation, feeRecipientSalt);
    if (feeRecipientAddress.code.length == 0) {
        Clones.cloneDeterministic(implementation, feeRecipientSalt);
        IFeeRecipient(feeRecipientAddress).init(_dispatcher, publicKeyRoot);
    }
    IFeeRecipient(feeRecipientAddress).withdraw();
}

/// @notice Triggers a withdrawal by sending its funds + its public key root to the dispatcher
/// @dev Can be called by any wallet as recipients are not parameters
function withdraw() external {
    dispatcher.dispatch{value: address(this).balance}(publicKeyRoot);
}

/// @notice Performs a withdrawal on this contract's balance
function dispatch(bytes32 _publicKeyRoot) external payable {
    IStakingContractFeeDetails stakingContract = IStakingContractFeeDetails(
        STAKING_CONTRACT_ADDRESS_SLOT.getAddress()
    );

    uint256 balance = address(this).balance; // this has taken into account msg.value
    if (balance == 0) {
        revert ZeroBalanceWithdrawal();
    }

    bool exitRequested = stakingContract.getExitRequestedFromRoot(_publicKeyRoot);
    bool withdrawn = stakingContract.getWithdrawnFromPublicKeyRoot(_publicKeyRoot);

    uint256 nonExemptBalance = balance;

    if (exitRequested && balance >= 31 ether && !withdrawn) {
        // If the skimmed rewards were withdrawn and the validator then underperformed
        // an healthy exit can be slightly lower than 32 ETH
        // We exempt the balance up to 32 ETH, happens only once.
        // !withdrawn prevents this logic being reused to not pay the fee on rewards
        uint256 exemption = nonExemptBalance > 32 ether ? 32 ether : nonExemptBalance;
        nonExemptBalance -= exemption;
        stakingContract.toggleWithdrawnFromPublicKeyRoot(_publicKeyRoot);
    }
    // In case of slashing the exit is not requested we don't exempt anything
    // This is in case of slashing, the staker will be rebated manually
    // A slashed validator may have accumulated enough skimmed rewards to still have a balance > 32 ETH
    // All of this will be taken into account and the staker will be compensated for the commission taken
    // on its principal and the loss according to the SLA described in the Terms&Conditions

    uint256 globalFee = (nonExemptBalance * stakingContract.getGlobalFee()) / BASIS_POINTS;
    uint256 operatorFee = (globalFee * stakingContract.getOperatorFee()) / BASIS_POINTS;
    address operator = stakingContract.getOperatorFeeRecipient(_publicKeyRoot);
    address treasury = stakingContract.getTreasury();
    address withdrawer = stakingContract.getWithdrawerFromPublicKeyRoot(_publicKeyRoot);

    (bool status, bytes memory data) = withdrawer.call{value: balance - globalFee}("");
    if (status == false) {
        revert WithdrawerReceiveError(data);
    }
    if (globalFee > 0) {
        (status, data) = treasury.call{value: globalFee - operatorFee}("");
        if (status == false) {
            revert TreasuryReceiveError(data);
        }
    }
    if (operatorFee > 0) {
        (status, data) = operator.call{value: operatorFee}("");
        if (status == false) {
            revert FeeRecipientReceiveError(data);
        }
    }
    emit Withdrawal(
        withdrawer,
        operator,
        _publicKeyRoot,
        balance - globalFee,
        operatorFee,
        globalFee - operatorFee
    );
}

pub fn get_expected_withdrawals<E: EthSpec>(
    state: &BeaconState<E>,
    spec: &ChainSpec,
) -> Result<(Withdrawals<E>, Option<usize>), BlockProcessingError> {
    let epoch = state.current_epoch();
    let mut withdrawal_index = state.next_withdrawal_index()?;
    let mut validator_index = state.next_withdrawal_validator_index()?;
    let mut withdrawals = Vec::<Withdrawal>::with_capacity(E::max_withdrawals_per_payload()); // max_withdrawals_per_payload = 16
    let fork_name = state.fork_name_unchecked();

    let bound = std::cmp::min(
        state.validators().len() as u64,
        spec.max_validators_per_withdrawals_sweep,
    );

    for _ in 0..bound {

let validator = state.get_validator(validator_index as usize)?;
let partially_withdrawn_balance = withdrawals
    .iter()
    .filter_map(|withdrawal| {
        (withdrawal.validator_index == validator_index).then_some(withdrawal.amount)
    })
    .safe_sum()?;
let balance = state
    .balances()
    .get(validator_index as usize)
    .ok_or(BeaconStateError::BalancesOutOfBounds(
        validator_index as usize,
    ))?
    .safe_sub(partially_withdrawn_balance)?;

if validator.is_partially_withdrawable_validator(balance, spec, fork_name) {
    withdrawals.push(Withdrawal {
        index: withdrawal_index,
        validator_index,
        address: validator
            .get_execution_withdrawal_address(spec)
            .ok_or(BlockProcessingError::WithdrawalCredentialsInvalid)?,
        amount: balance.safe_sub(validator.get_max_effective_balance(spec, fork_name))?,
    });
    withdrawal_index.safe_add_assign(1)?;
}
if withdrawals.len() == E::max_withdrawals_per_payload() {
    break;
}
validator_index = validator_index
    .safe_add(1)?
    .safe_rem(state.validators().len() as u64)?;

pub fn get_max_effective_balance(&self, spec: &ChainSpec, current_fork: ForkName) -> u64 {
    if current_fork >= ForkName::Electra {
        if self.has_compounding_withdrawal_credential(spec) {
            spec.max_effective_balance_electra // 2048 ETH
        } else {
            spec.min_activation_balance // 32 ETH
        }
    } else {
        spec.max_effective_balance
    }
}

/// Returns `true` if the validator is partially withdrawable.
///
/// Calls the correct function depending on the provided `fork_name`.
pub fn is_partially_withdrawable_validator(
    &self,
    balance: u64,
    spec: &ChainSpec,
    current_fork: ForkName,
) -> bool {
    if current_fork.electra_enabled() {
        self.is_partially_withdrawable_validator_electra(balance, spec, current_fork)
    } else {
        self.is_partially_withdrawable_validator_capella(balance, spec)
    }
}

/// Returns `true` if the validator is partially withdrawable.
///
/// Modified in electra as part of EIP 7251.
pub fn is_partially_withdrawable_validator_electra(
    &self,
    balance: u64,
    spec: &ChainSpec,
    current_fork: ForkName,
) -> bool {
    let max_effective_balance = self.get_max_effective_balance(spec, current_fork);
    let has_max_effective_balance = self.effective_balance == max_effective_balance;
    let has_excess_balance = balance > max_effective_balance;
    self.has_execution_withdrawal_credential(spec)
        && has_max_effective_balance
        && has_excess_balance
}

previous_excess = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, EXCESS_WITHDRAWAL_REQUESTS_STORAGE_SLOT)
count = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_COUNT_STORAGE_SLOT)
if previous_excess + count > TARGET_WITHDRAWAL_REQUESTS_PER_BLOCK:
    new_excess = previous_excess + count - TARGET_WITHDRAWAL_REQUESTS_PER_BLOCK

cast call 0x00000961ef480eb55e80d19ad83579a64c007002 --rpc-url $ETH_RPC_URL

const WithdrawRequest = ssz.container({
  validator_pubkey: ssz.bytes(48),
  amount: ssz.uint64,
});

import { hexToBytes } from "@noble/hashes/utils";
import * as ssz from "micro-eth-signer/advanced/ssz.js";

const calldata = hexToBytes(
  "86ee7bf82858f6913ee08515262bfa51988dd1eb64a7404604eaadc9bf89138a6d3288cd308da10e19bfbf8ec1f2297900000000073edd26",
);

const WithdrawRequest = ssz.container({
  validator_pubkey: ssz.bytes(48),
  amount: ssz.uint64,
});

const data = WithdrawRequest.decode(calldata);
console.log(data);

def add_withdrawal_request(Bytes48: validator_pubkey, uint64: amount):
    """
    Add withdrawal request adds new request to the withdrawal request queue, so long as a sufficient fee is provided.
    """

    # Verify sufficient fee was provided.
    fee = get_fee()
    require(msg.value >= fee, 'Insufficient value for fee')

    # Increment withdrawal request count.
    count = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_COUNT_STORAGE_SLOT)
    sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_COUNT_STORAGE_SLOT, count + 1)

    # Insert into queue.
    queue_tail_index = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_QUEUE_TAIL_STORAGE_SLOT)
    queue_storage_slot = WITHDRAWAL_REQUEST_QUEUE_STORAGE_OFFSET + queue_tail_index * 3
    sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, queue_storage_slot, msg.sender)
    sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, queue_storage_slot + 1, validator_pubkey[0:32])
    sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, queue_storage_slot + 2, validator_pubkey[32:48] ++ uint64_to_little_endian(amount))
    sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_QUEUE_TAIL_STORAGE_SLOT, queue_tail_index + 1)

const WithdrawRequest = ssz.container({
  source: ssz.bytes(40),
  validator_pubkey: ssz.bytes(48),
  amount: ssz.uint64,
});

let is_correct_source_address = validator
    .get_execution_withdrawal_address(spec)
    .map(|addr| addr == request.source_address)
    .unwrap_or(false);

func processRequestsSystemCall(requests *[][]byte, evm *vm.EVM, requestType byte, addr common.Address) error {
	if tracer := evm.Config.Tracer; tracer != nil {
		onSystemCallStart(tracer, evm.GetVMContext())
		if tracer.OnSystemCallEnd != nil {
			defer tracer.OnSystemCallEnd()
		}
	}
	msg := &Message{
		From:      params.SystemAddress,
		GasLimit:  30_000_000,
		GasPrice:  common.Big0,
		GasFeeCap: common.Big0,
		GasTipCap: common.Big0,
		To:        &addr,
	}
	evm.SetTxContext(NewEVMTxContext(msg))
	evm.StateDB.AddAddressToAccessList(addr)
	ret, _, err := evm.Call(msg.From, *msg.To, msg.Data, 30_000_000, common.U2560)
	evm.StateDB.Finalise(true)
	if err != nil {
		return fmt.Errorf("system call failed to execute: %v", err)
	}
	if len(ret) == 0 {
		return nil // skip empty output
	}
	// Append prefixed requestsData to the requests list.
	requestsData := make([]byte, len(ret)+1)
	requestsData[0] = requestType
	copy(requestsData[1:], ret)
	*requests = append(*requests, requestsData)
	return nil
}

def read_withdrawal_requests():
    reqs = dequeue_withdrawal_requests()
    update_excess_withdrawal_requests()
    reset_withdrawal_requests_count()
    return ssz.serialize(reqs)

class ValidatorWithdrawalRequest(object):
    source_address: Bytes20
    validator_pubkey: Bytes48
    amount: uint64

def dequeue_withdrawal_requests():
    queue_head_index = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_QUEUE_HEAD_STORAGE_SLOT)
    queue_tail_index = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_QUEUE_TAIL_STORAGE_SLOT)
    num_in_queue = queue_tail_index - queue_head_index
    num_dequeued = min(num_in_queue, MAX_WITHDRAWAL_REQUESTS_PER_BLOCK)

    reqs = []
    for i in range(num_dequeued):
        queue_storage_slot = WITHDRAWAL_REQUEST_QUEUE_STORAGE_OFFSET + (queue_head_index + i) * 3
        source_address = address(sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, queue_storage_slot)[0:20])
        validator_pubkey = (
            sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, queue_storage_slot + 1)[0:32] + sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, queue_storage_slot + 2)[0:16]
        )
        amount = little_endian_to_uint64(sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, queue_storage_slot + 2)[16:24])
        req = ValidatorWithdrawalRequest(
            source_address=Bytes20(source_address),
            validator_pubkey=Bytes48(validator_pubkey),
            amount=uint64(amount)
        )
        reqs.append(req)

    new_queue_head_index = queue_head_index + num_dequeued
    if new_queue_head_index == queue_tail_index:
        # Queue is empty, reset queue pointers
        sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_QUEUE_HEAD_STORAGE_SLOT, 0)
        sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_QUEUE_TAIL_STORAGE_SLOT, 0)
    else:
        sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_QUEUE_HEAD_STORAGE_SLOT, new_queue_head_index)

    return reqs

def update_excess_withdrawal_requests():
    previous_excess = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, EXCESS_WITHDRAWAL_REQUESTS_STORAGE_SLOT)
    if previous_excess == EXCESS_INHIBITOR:
        previous_excess = 0

    count = sload(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_COUNT_STORAGE_SLOT)

    new_excess = 0
    if previous_excess + count > TARGET_WITHDRAWAL_REQUESTS_PER_BLOCK:
        new_excess = previous_excess + count - TARGET_WITHDRAWAL_REQUESTS_PER_BLOCK

    sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, EXCESS_WITHDRAWAL_REQUESTS_STORAGE_SLOT, new_excess)

def reset_withdrawal_requests_count():
    sstore(WITHDRAWAL_REQUEST_PREDEPLOY_ADDRESS, WITHDRAWAL_REQUEST_COUNT_STORAGE_SLOT, 0)

let amount = request.amount;
let is_full_exit_request = amount == spec.full_exit_request_amount;

// If partial withdrawal queue is full, only full exits are processed
if state.pending_partial_withdrawals()?.len() == E::pending_partial_withdrawals_limit()
    && !is_full_exit_request
{
    continue;
}

// Verify pubkey exists
let Some(validator_index) = state.pubkey_cache().get(&request.validator_pubkey) else {
    continue;
};

let validator = state.get_validator(validator_index)?;
// Verify withdrawal credentials
let has_correct_credential = validator.has_execution_withdrawal_credential(spec);
let is_correct_source_address = validator
    .get_execution_withdrawal_address(spec)
    .map(|addr| addr == request.source_address)
    .unwrap_or(false);

if !(has_correct_credential && is_correct_source_address) {
    continue;
}

// Verify the validator is active
if !validator.is_active_at(state.current_epoch()) {
    continue;
}

// Verify exit has not been initiated
if validator.exit_epoch != spec.far_future_epoch {
    continue;
}

// Verify the validator has been active long enough
if state.current_epoch()
    < validator
        .activation_epoch
        .safe_add(spec.shard_committee_period)? // 256
{
    continue;
}

let pending_balance_to_withdraw = state.get_pending_balance_to_withdraw(validator_index)?;
if is_full_exit_request {
    // Only exit validator if it has no pending withdrawals in the queue
    if pending_balance_to_withdraw == 0 {
        initiate_validator_exit(state, validator_index, spec)?
    }
    continue;
}

let balance = state.get_balance(validator_index)?;
let has_sufficient_effective_balance =
    validator.effective_balance >= spec.min_activation_balance;
let has_excess_balance = balance
    > spec
        .min_activation_balance
        .safe_add(pending_balance_to_withdraw)?;

// Only allow partial withdrawals with compounding withdrawal credentials
if validator.has_compounding_withdrawal_credential(spec)
    && has_sufficient_effective_balance
    && has_excess_balance
{
    let to_withdraw = std::cmp::min(
        balance
            .safe_sub(spec.min_activation_balance)?
            .safe_sub(pending_balance_to_withdraw)?,
        amount,
    );
    let exit_queue_epoch = state.compute_exit_epoch_and_update_churn(to_withdraw, spec)?;
    let withdrawable_epoch =
        exit_queue_epoch.safe_add(spec.min_validator_withdrawability_delay)?;
    state
        .pending_partial_withdrawals_mut()?
        .push(PendingPartialWithdrawal {
            validator_index: validator_index as u64,
            amount: to_withdraw,
            withdrawable_epoch,
        })?;
}

// [New in Electra:EIP7251]
// Consume pending partial withdrawals
let processed_partial_withdrawals_count =
    if let Ok(pending_partial_withdrawals) = state.pending_partial_withdrawals() {
        let mut processed_partial_withdrawals_count = 0;
        for withdrawal in pending_partial_withdrawals {
            if withdrawal.withdrawable_epoch > epoch
                || withdrawals.len() == spec.max_pending_partials_per_withdrawals_sweep as usize
            {
                break;
            }

            let validator = state.get_validator(withdrawal.validator_index as usize)?;

            let has_sufficient_effective_balance =
                validator.effective_balance >= spec.min_activation_balance;
            let total_withdrawn = withdrawals
                .iter()
                .filter_map(|w| {
                    (w.validator_index == withdrawal.validator_index).then_some(w.amount)
                })
                .safe_sum()?;
            let balance = state
                .get_balance(withdrawal.validator_index as usize)?
                .safe_sub(total_withdrawn)?;
            let has_excess_balance = balance > spec.min_activation_balance;

            if validator.exit_epoch == spec.far_future_epoch
                && has_sufficient_effective_balance
                && has_excess_balance
            {
                let withdrawable_balance = std::cmp::min(
                    balance.safe_sub(spec.min_activation_balance)?,
                    withdrawal.amount,
                );
                withdrawals.push(Withdrawal {
                    index: withdrawal_index,
                    validator_index: withdrawal.validator_index,
                    address: validator
                        .get_execution_withdrawal_address(spec)
                        .ok_or(BeaconStateError::NonExecutionAddressWithdrawalCredential)?,
                    amount: withdrawable_balance,
                });
                withdrawal_index.safe_add_assign(1)?;
            }
            processed_partial_withdrawals_count.safe_add_assign(1)?;
        }
        Some(processed_partial_withdrawals_count)
    } else {
        None
    };

/// Initiate the exit of the validator of the given `index`.
pub fn initiate_validator_exit<E: EthSpec>(
    state: &mut BeaconState<E>,
    index: usize,
    spec: &ChainSpec,
) -> Result<(), Error> {
    let validator = state.get_validator_cow(index)?;

    // Return if the validator already initiated exit
    if validator.exit_epoch != spec.far_future_epoch {
        return Ok(());
    }

    // Ensure the exit cache is built.
    state.build_exit_cache(spec)?;

    // Compute exit queue epoch
    let exit_queue_epoch = if state.fork_name_unchecked() >= ForkName::Electra {
        let effective_balance = state.get_effective_balance(index)?;
        state.compute_exit_epoch_and_update_churn(effective_balance, spec)?
    } else {
        let delayed_epoch = state.compute_activation_exit_epoch(state.current_epoch(), spec)?;
        let mut exit_queue_epoch = state
            .exit_cache()
            .max_epoch()?
            .map_or(delayed_epoch, |epoch| max(epoch, delayed_epoch));
        let exit_queue_churn = state.exit_cache().get_churn_at(exit_queue_epoch)?;

        if exit_queue_churn >= state.get_validator_churn_limit(spec)? {
            exit_queue_epoch.safe_add_assign(1)?;
        }
        exit_queue_epoch
    };

    let validator = state.get_validator_mut(index)?;
    validator.exit_epoch = exit_queue_epoch;
    validator.withdrawable_epoch =
        exit_queue_epoch.safe_add(spec.min_validator_withdrawability_delay)?;

    state
        .exit_cache_mut()
        .record_validator_exit(exit_queue_epoch)?;

    Ok(())
}

if validator.is_fully_withdrawable_validator(balance, epoch, spec, fork_name) {
    withdrawals.push(Withdrawal {
        index: withdrawal_index,
        validator_index,
        address: validator
            .get_execution_withdrawal_address(spec)
            .ok_or(BlockProcessingError::WithdrawalCredentialsInvalid)?,
        amount: balance,
    });
    withdrawal_index.safe_add_assign(1)?;
}