Withdrawals without queues

presets/mainnet/capella.yaml

@@ -1,23 +1,11 @@
 # Mainnet preset - Capella
 
 # Misc
-# ---------------------------------------------------------------
-# 2**8 (= 256) withdrawals
-MAX_PARTIAL_WITHDRAWALS_PER_EPOCH: 256
-
-
-# State list lengths
-# ---------------------------------------------------------------
-# 2**40 (= 1,099,511,627,776) withdrawals
-WITHDRAWAL_QUEUE_LIMIT: 1099511627776
-
-
 # Max operations per block
 # ---------------------------------------------------------------
 # 2**4 (= 16)
 MAX_BLS_TO_EXECUTION_CHANGES: 16
 
-
 # Execution
 # ---------------------------------------------------------------
 # 2**4 (= 16) withdrawals

presets/minimal/capella.yaml

@@ -1,17 +1,5 @@
 # Minimal preset - Capella
 
-# Misc
-# ---------------------------------------------------------------
-# [customized] 16 for more interesting tests at low validator count
-MAX_PARTIAL_WITHDRAWALS_PER_EPOCH: 16
-
-
-# State list lengths
-# ---------------------------------------------------------------
-# 2**40 (= 1,099,511,627,776) withdrawals
-WITHDRAWAL_QUEUE_LIMIT: 1099511627776
-
-
 # Max operations per block
 # ---------------------------------------------------------------
 # 2**4 (= 16)
@@ -20,5 +8,5 @@ MAX_BLS_TO_EXECUTION_CHANGES: 16
 
 # Execution
 # ---------------------------------------------------------------
-# [customized] Lower than MAX_PARTIAL_WITHDRAWALS_PER_EPOCH so not all processed in one block
-MAX_WITHDRAWALS_PER_PAYLOAD: 8
+# [customized] 2**2 (= 4)
+MAX_WITHDRAWALS_PER_PAYLOAD: 4

specs/capella/beacon-chain.md

@@ -11,11 +11,8 @@
 - [Constants](#constants)
   - [Domain types](#domain-types)
 - [Preset](#preset)
-  - [Misc](#misc)
-  - [State list lengths](#state-list-lengths)
   - [Max operations per block](#max-operations-per-block)
   - [Execution](#execution)
-- [Configuration](#configuration)
 - [Containers](#containers)
   - [New containers](#new-containers)
     - [`Withdrawal`](#withdrawal)
@@ -27,17 +24,13 @@
     - [`BeaconBlockBody`](#beaconblockbody)
     - [`BeaconState`](#beaconstate)
 - [Helpers](#helpers)
-  - [Beacon state mutators](#beacon-state-mutators)
-    - [`withdraw_balance`](#withdraw_balance)
   - [Predicates](#predicates)
     - [`has_eth1_withdrawal_credential`](#has_eth1_withdrawal_credential)
     - [`is_fully_withdrawable_validator`](#is_fully_withdrawable_validator)
     - [`is_partially_withdrawable_validator`](#is_partially_withdrawable_validator)
 - [Beacon chain state transition function](#beacon-chain-state-transition-function)
-  - [Epoch processing](#epoch-processing)
-    - [Full withdrawals](#full-withdrawals)
-    - [Partial withdrawals](#partial-withdrawals)
   - [Block processing](#block-processing)
+    - [New `get_expected_withdrawals`](#new-get_expected_withdrawals)
     - [New `process_withdrawals`](#new-process_withdrawals)
     - [Modified `process_execution_payload`](#modified-process_execution_payload)
     - [Modified `process_operations`](#modified-process_operations)
@@ -75,18 +68,6 @@ We define the following Python custom types for type hinting and readability:
 
 ## Preset
 
-### Misc
-
-| Name | Value |
-| - | - |
-| `MAX_PARTIAL_WITHDRAWALS_PER_EPOCH` | `uint64(2**8)` (= 256) |
-
-### State list lengths
-
-| Name | Value | Unit |
-| - | - | :-: |
-| `WITHDRAWAL_QUEUE_LIMIT` | `uint64(2**40)` (= 1,099,511,627,776) | withdrawals enqueued in state |
-
 ### Max operations per block
 
 | Name | Value |
@@ -99,8 +80,6 @@ We define the following Python custom types for type hinting and readability:
 | - | - | - |
 | `MAX_WITHDRAWALS_PER_PAYLOAD` | `uint64(2**4)` (= 16) | Maximum amount of withdrawals allowed in each payload |
 
-## Configuration
-
 ## Containers
 
 ### New containers
@@ -241,32 +220,12 @@ class BeaconState(Container):
     # Execution
     latest_execution_payload_header: ExecutionPayloadHeader
     # Withdrawals
-    withdrawal_queue: List[Withdrawal, WITHDRAWAL_QUEUE_LIMIT]  # [New in Capella]
     next_withdrawal_index: WithdrawalIndex  # [New in Capella]
-    next_partial_withdrawal_validator_index: ValidatorIndex  # [New in Capella]
+    latest_withdrawal_validator_index: ValidatorIndex  # [New in Capella]
 ```
 
 ## Helpers
 
-### Beacon state mutators
-
-#### `withdraw_balance`
-
-```python
-def withdraw_balance(state: BeaconState, validator_index: ValidatorIndex, amount: Gwei) -> None:
-    # Decrease the validator's balance
-    decrease_balance(state, validator_index, amount)
-    # Create a corresponding withdrawal receipt
-    withdrawal = Withdrawal(
-        index=state.next_withdrawal_index,
-        validator_index=validator_index,
-        address=ExecutionAddress(state.validators[validator_index].withdrawal_credentials[12:]),
-        amount=amount,
-    )
-    state.next_withdrawal_index = WithdrawalIndex(state.next_withdrawal_index + 1)
-    state.withdrawal_queue.append(withdrawal)
-```
-
 ### Predicates
 
 #### `has_eth1_withdrawal_credential`
@@ -307,66 +266,6 @@ def is_partially_withdrawable_validator(validator: Validator, balance: Gwei) ->
 
 ## Beacon chain state transition function
 
-### Epoch processing
-
-```python
-def process_epoch(state: BeaconState) -> None:
-    process_justification_and_finalization(state)
-    process_inactivity_updates(state)
-    process_rewards_and_penalties(state)
-    process_registry_updates(state)
-    process_slashings(state)
-    process_eth1_data_reset(state)
-    process_effective_balance_updates(state)
-    process_slashings_reset(state)
-    process_randao_mixes_reset(state)
-    process_historical_roots_update(state)
-    process_participation_flag_updates(state)
-    process_sync_committee_updates(state)
-    process_full_withdrawals(state)  # [New in Capella]
-    process_partial_withdrawals(state)  # [New in Capella]
-
-```
-
-#### Full withdrawals
-
-*Note*: The function `process_full_withdrawals` is new.
-
-```python
-def process_full_withdrawals(state: BeaconState) -> None:
-    current_epoch = get_current_epoch(state)
-    for index in range(len(state.validators)):
-        balance = state.balances[index]
-        validator = state.validators[index]
-        if is_fully_withdrawable_validator(validator, balance, current_epoch):
-            withdraw_balance(state, ValidatorIndex(index), balance)
-```
-
-#### Partial withdrawals
-
-*Note*: The function `process_partial_withdrawals` is new.
-
-```python
-def process_partial_withdrawals(state: BeaconState) -> None:
-    partial_withdrawals_count = 0
-    # Begin where we left off last time
-    validator_index = state.next_partial_withdrawal_validator_index
-    for _ in range(len(state.validators)):
-        balance = state.balances[validator_index]
-        validator = state.validators[validator_index]
-        if is_partially_withdrawable_validator(validator, balance):
-            withdraw_balance(state, validator_index, balance - MAX_EFFECTIVE_BALANCE)
-            partial_withdrawals_count += 1
-
-        # Iterate to next validator to check for partial withdrawal
-        validator_index = ValidatorIndex((validator_index + 1) % len(state.validators))
-        # Exit if performed maximum allowable withdrawals
-        if partial_withdrawals_count == MAX_PARTIAL_WITHDRAWALS_PER_EPOCH:
-            break
-
-    state.next_partial_withdrawal_validator_index = validator_index
-```
-
 ### Block processing
 
 ```python
@@ -377,23 +276,57 @@ def process_block(state: BeaconState, block: BeaconBlock) -> None:
         process_execution_payload(state, block.body.execution_payload, EXECUTION_ENGINE)  # [Modified in Capella]
     process_randao(state, block.body)
     process_eth1_data(state, block.body)
-    process_operations(state, block.body)
+    process_operations(state, block.body)  # [Modified in Capella]
     process_sync_aggregate(state, block.body.sync_aggregate)
 ```
 
+#### New `get_expected_withdrawals`
+
+```python
+def get_expected_withdrawals(state: BeaconState) -> Sequence[Withdrawal]:
+    epoch = get_current_epoch(state)
+    withdrawal_index = state.next_withdrawal_index
+    validator_index = state.latest_withdrawal_validator_index 
+    withdrawals: List[Withdrawal] = []
+    for _ in range(len(state.validators)):
+        validator_index = ValidatorIndex((validator_index + 1) % len(state.validators))
+        validator = state.validators[validator_index]
+        balance = state.balances[validator_index]
+        if is_fully_withdrawable_validator(validator, balance, epoch):
+            withdrawals.append(Withdrawal(
+                index=withdrawal_index,
+                validator_index=validator_index,
+                address=ExecutionAddress(validator.withdrawal_credentials[12:]),
+                amount=balance,
+            ))
+            withdrawal_index += WithdrawalIndex(1)
+        elif is_partially_withdrawable_validator(validator, balance):
+            withdrawals.append(Withdrawal(
+                index=withdrawal_index,
+                validator_index=validator_index,
+                address=ExecutionAddress(validator.withdrawal_credentials[12:]),
+                amount=balance - MAX_EFFECTIVE_BALANCE,
+            ))
+            withdrawal_index += WithdrawalIndex(1)
+        if len(withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD:
+            break
+    return withdrawals
+```
+
 #### New `process_withdrawals`
 
 ```python
 def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
-    num_withdrawals = min(MAX_WITHDRAWALS_PER_PAYLOAD, len(state.withdrawal_queue))
-    dequeued_withdrawals = state.withdrawal_queue[:num_withdrawals]
-
-    assert len(dequeued_withdrawals) == len(payload.withdrawals)
-    for dequeued_withdrawal, withdrawal in zip(dequeued_withdrawals, payload.withdrawals):
-        assert dequeued_withdrawal == withdrawal
-
-    # Remove dequeued withdrawals from state
-    state.withdrawal_queue = state.withdrawal_queue[num_withdrawals:]
+    expected_withdrawals = get_expected_withdrawals(state)
+    assert len(payload.withdrawals) == len(expected_withdrawals)
+
+    for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
+        assert withdrawal == expected_withdrawal
+        decrease_balance(state, withdrawal.validator_index, withdrawal.amount)
+    if len(expected_withdrawals) > 0:
+        # `withdrawal` holds the last withdrawal object in the payload.
+        state.next_withdrawal_index = WithdrawalIndex(withdrawal.index + 1)
+        state.latest_withdrawal_validator_index = withdrawal.validator_index
 ```
 
 #### Modified `process_execution_payload`

specs/capella/fork.md

@@ -129,9 +129,8 @@ def upgrade_to_capella(pre: bellatrix.BeaconState) -> BeaconState:
         # Execution-layer
         latest_execution_payload_header=latest_execution_payload_header,
         # Withdrawals
-        withdrawal_queue=[],
         next_withdrawal_index=WithdrawalIndex(0),
-        next_partial_withdrawal_validator_index=ValidatorIndex(0),
+        latest_withdrawal_validator_index=ValidatorIndex(0),
     )
 
     return post

specs/capella/validator.md

@@ -58,13 +58,6 @@ All validator responsibilities remain unchanged other than those noted below.
 expected withdrawals for the slot must be gathered from the `state` (utilizing the
 helper `get_expected_withdrawals`) and passed into the `ExecutionEngine` within `prepare_execution_payload`.
 
-
-```python
-def get_expected_withdrawals(state: BeaconState) -> Sequence[Withdrawal]:
-    num_withdrawals = min(MAX_WITHDRAWALS_PER_PAYLOAD, len(state.withdrawal_queue))
-    return state.withdrawal_queue[:num_withdrawals]
-```
-
 *Note*: The only change made to `prepare_execution_payload` is to call
 `get_expected_withdrawals()` to set the new `withdrawals` field of `PayloadAttributes`.