Add functions for deriving light client data

setup.py

@@ -457,6 +457,7 @@ def imports(cls, preset_name: str) -> str:
 from typing import NewType, Union as PyUnion
 
 from eth2spec.phase0 import {preset_name} as phase0
+from eth2spec.test.helpers.merkle import build_proof
 from eth2spec.utils.ssz.ssz_typing import Path
 '''
 

specs/altair/sync-protocol.md

@@ -31,6 +31,9 @@
   - [`validate_light_client_update`](#validate_light_client_update)
   - [`apply_light_client_update`](#apply_light_client_update)
   - [`process_light_client_update`](#process_light_client_update)
+- [Deriving light client data](#deriving-light-client-data)
+  - [`create_light_client_bootstrap`](#create_light_client_bootstrap)
+  - [`create_light_client_update`](#create_light_client_update)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 <!-- /TOC -->
@@ -417,3 +420,105 @@ def process_light_client_update(store: LightClientStore,
         apply_light_client_update(store, update)
         store.best_valid_update = None
 ```
+
+## Deriving light client data
+
+Full nodes are expected to derive light client data from historic blocks and states and provide it to other clients.
+
+### `create_light_client_bootstrap`
+
+```python
+def create_light_client_bootstrap(state: BeaconState) -> LightClientBootstrap:
+    assert compute_epoch_at_slot(state.slot) >= ALTAIR_FORK_EPOCH
+    assert state.slot == state.latest_block_header.slot
+
+    return LightClientBootstrap(
+        header=BeaconBlockHeader(
+            slot=state.latest_block_header.slot,
+            proposer_index=state.latest_block_header.proposer_index,
+            parent_root=state.latest_block_header.parent_root,
+            state_root=hash_tree_root(state),
+            body_root=state.latest_block_header.body_root,
+        ),
+        current_sync_committee=state.current_sync_committee,
+        current_sync_committee_branch=build_proof(state.get_backing(), CURRENT_SYNC_COMMITTEE_INDEX)
+    )
+```
+
+Full nodes SHOULD provide `LightClientBootstrap` for all finalized epoch boundary blocks in the epoch range `[max(ALTAIR_FORK_EPOCH, current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS), current_epoch]` where `current_epoch` is defined by the current wall-clock time. Full nodes MAY also provide `LightClientBootstrap` for other blocks.
+
+Blocks are considered to be epoch boundary blocks if their block root can occur as part of a valid `Checkpoint`, i.e., if their slot is the initial slot of an epoch, or if all following slots through the initial slot of the next epoch are empty (no block proposed / orphaned).
+
+`LightClientBootstrap` is computed from the block's immediate post state (without applying empty slots).
+
+### `create_light_client_update`
+
+To form a `LightClientUpdate`, the following historical states and blocks are needed:
+- `state`: the post state of any block with a post-Altair parent block
+- `block`: the corresponding block
+- `attested_state`: the post state of the block referred to by `block.parent_root`
+- `finalized_block`: the block referred to by `attested_state.finalized_checkpoint.root`
+
+```python
+def create_light_client_update(state: BeaconState,
+                               block: SignedBeaconBlock,
+                               attested_state: BeaconState,
+                               finalized_block: Optional[SignedBeaconBlock]) -> LightClientUpdate:
+    assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH
+    assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS
+
+    assert state.slot == state.latest_block_header.slot
+    header = state.latest_block_header.copy()
+    header.state_root = hash_tree_root(state)
+    assert hash_tree_root(header) == hash_tree_root(block.message)
+    update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot))
+
+    assert attested_state.slot == attested_state.latest_block_header.slot
+    attested_header = attested_state.latest_block_header.copy()
+    attested_header.state_root = hash_tree_root(attested_state)
+    assert hash_tree_root(attested_header) == block.message.parent_root
+    update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot))
+
+    # `next_sync_committee` is only useful if the message is signed by the current sync committee
+    if update_attested_period == update_signature_period:
+        next_sync_committee = attested_state.next_sync_committee
+        next_sync_committee_branch = build_proof(attested_state.get_backing(), NEXT_SYNC_COMMITTEE_INDEX)
+    else:
+        next_sync_committee = SyncCommittee()
+        next_sync_committee_branch = [Bytes32() for _ in range(floorlog2(NEXT_SYNC_COMMITTEE_INDEX))]
+
+    # Indicate finality whenever possible
+    if finalized_block is not None:
+        if finalized_block.message.slot != GENESIS_SLOT:
+            finalized_header = BeaconBlockHeader(
+                slot=finalized_block.message.slot,
+                proposer_index=finalized_block.message.proposer_index,
+                parent_root=finalized_block.message.parent_root,
+                state_root=finalized_block.message.state_root,
+                body_root=hash_tree_root(finalized_block.message.body),
+            )
+            assert hash_tree_root(finalized_header) == attested_state.finalized_checkpoint.root
+        else:
+            finalized_header = BeaconBlockHeader()
+            assert attested_state.finalized_checkpoint.root == Bytes32()
+        finality_branch = build_proof(attested_state.get_backing(), FINALIZED_ROOT_INDEX)
+    else:
+        finalized_header = BeaconBlockHeader()
+        finality_branch = [Bytes32() for _ in range(floorlog2(FINALIZED_ROOT_INDEX))]
+
+    return LightClientUpdate(
+        attested_header=attested_header,
+        next_sync_committee=next_sync_committee,
+        next_sync_committee_branch=next_sync_committee_branch,
+        finalized_header=finalized_header,
+        finality_branch=finality_branch,
+        sync_aggregate=block.message.body.sync_aggregate,
+        signature_slot=block.message.slot,
+    )
+```
+
+Full nodes SHOULD provide the best derivable `LightClientUpdate` (according to `is_better_update`) for each sync committee period covering any epochs in range `[max(ALTAIR_FORK_EPOCH, current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS), current_epoch]` where `current_epoch` is defined by the current wall-clock time. Full nodes MAY also provide `LightClientUpdate` for other sync committee periods.
+
+- `LightClientUpdate` are assigned to sync committee periods based on their `attested_header.slot`
+- `LightClientUpdate` are only considered if `compute_sync_committee_period(compute_epoch_at_slot(update.attested_header.slot)) == compute_sync_committee_period(compute_epoch_at_slot(update.signature_slot))`
+- Only `LightClientUpdate` with `next_sync_committee` as selected by fork choice are provided, regardless of ranking by `is_better_update`. To uniquely identify a non-finalized sync committee fork, all of `period`, `current_sync_committee` and `next_sync_committee` need to be incorporated, as sync committees may reappear over time.