From 17221c806501e11943fd8359754f79b65713468d Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Thu, 12 Nov 2020 10:26:25 -0700
Subject: [PATCH 01/43] more clearly define min epoch range for blocksbyrange
 requests

---
 README.md                         |  1 +
 specs/phase0/p2p-interface.md     | 41 ++++++++++++++++++++++++++++---
 specs/phase0/weak-subjectivity.md |  5 +++-
 3 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index a3ca7c586..8104ec7cc 100644
--- a/README.md
+++ b/README.md
@@ -20,6 +20,7 @@ Core specifications for Eth2 clients be found in [specs](specs/). These are divi
 * [Deposit Contract](specs/phase0/deposit-contract.md)
 * [Honest Validator](specs/phase0/validator.md)
 * [P2P Networking](specs/phase0/p2p-interface.md)
+* [Weak Subjectivity](specs/phase0/weak-subjectivity.md.md)
 
 ### Phase 1
 * [From Phase 0 to Phase 1](specs/phase1/phase1-fork.md)
diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 5dc892991..8104b54c7 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -93,6 +93,7 @@ It consists of four main sections:
     - [Why is it called Req/Resp and not RPC?](#why-is-it-called-reqresp-and-not-rpc)
     - [Why do we allow empty responses in block requests?](#why-do-we-allow-empty-responses-in-block-requests)
     - [Why does `BeaconBlocksByRange` let the server choose which branch to send blocks from?](#why-does-beaconblocksbyrange-let-the-server-choose-which-branch-to-send-blocks-from)
+    - [Why are `BlocksByRange` requests only required to be served for the latest `MIN_EPOCHS_FOR_BLOCK_REQUESTS` epochs?](#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs)
     - [What's the effect of empty slots on the sync algorithm?](#whats-the-effect-of-empty-slots-on-the-sync-algorithm)
   - [Discovery](#discovery)
     - [Why are we using discv5 and not libp2p Kademlia DHT?](#why-are-we-using-discv5-and-not-libp2p-kademlia-dht)
@@ -171,6 +172,7 @@ This section outlines constants that are used in this spec.
 |---|---|---|
 | `GOSSIP_MAX_SIZE` | `2**20` (= 1048576, 1 MiB) | The maximum allowed size of uncompressed gossip messages. |
 | `MAX_REQUEST_BLOCKS` | `2**10` (= 1024) | Maximum number of blocks in a single request |
+| `MIN_EPOCHS_FOR_BLOCK_REQUESTS` | `MIN_VALIDATOR_WITHDRAWABILITY_DELAY + CHURN_LIMIT_QUOTIENT // 2` (= 33024, ~5 months) | The minimum epoch range over which a node must serve blocks |
 | `MAX_CHUNK_SIZE` | `2**20` (1048576, 1 MiB) | The maximum allowed size of uncompressed req/resp chunked responses. |
 | `TTFB_TIMEOUT` | `5s` | The maximum time to wait for first byte of request response (time-to-first-byte). |
 | `RESP_TIMEOUT` | `10s` | The maximum time for complete response transfer. |
@@ -179,7 +181,6 @@ This section outlines constants that are used in this spec.
 | `MESSAGE_DOMAIN_INVALID_SNAPPY` | `0x00000000` | 4-byte domain for gossip message-id isolation of *invalid* snappy messages |
 | `MESSAGE_DOMAIN_VALID_SNAPPY`  | `0x01000000` | 4-byte domain for gossip message-id isolation of *valid* snappy messages |
 
-
 ## MetaData
 
 Clients MUST locally store the following `MetaData`:
@@ -746,10 +747,17 @@ The request MUST be encoded as an SSZ-container.
 The response MUST consist of zero or more `response_chunk`.
 Each _successful_ `response_chunk` MUST contain a single `SignedBeaconBlock` payload.
 
-Clients MUST keep a record of signed blocks seen since the start of the weak subjectivity period
-and MUST support serving requests of blocks up to their own `head_block_root`.
+Clients MUST keep a record of signed blocks seen on the epoch range
+`[max(GENESIS_EPOCH, current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS), current_epoch]`
+where `current_epoch` is defined by the current wall-clock time,
+and clients MUST support serving requests of blocks on this range.
 
-Clients MUST respond with at least the first block that exists in the range, if they have it, and no more than `MAX_REQUEST_BLOCKS` blocks.
+*Note*: The above requirement implies that nodes that start from a recent weak subjectivity checkpoint
+MUST backfill the local block database to at least epoch `current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS`
+to be compliant with `BlocksByRange` requests.
+
+Clients MUST respond with at least the first block that exists in the range, if they have it,
+and no more than `MAX_REQUEST_BLOCKS` blocks.
 
 The following blocks, where they exist, MUST be sent in consecutive order.
 
@@ -1394,6 +1402,31 @@ To avoid this race condition, we allow the responding side to choose which branc
 The requesting client then goes on to validate the blocks and incorporate them in their own database
 -- because they follow the same rules, they should at this point arrive at the same canonical chain.
 
+### Why are `BlocksByRange` requests only required to be served for the latest `MIN_EPOCHS_FOR_BLOCK_REQUESTS` epochs?
+
+Due to economic finality and weak subjectivity requirements of a proof-of-stake blockchain, for a new node to safely join the network
+the node must provide a recent checkpoint found out-of-band. This checkpoint can be in the form of a `root` & `epoch` or it can be the entire
+beacon state and then a simple block sync from there to the head. We expect the latter to be the dominant UX strategy.
+
+These checkpoints *in the worst case* (i.e. very large validator set and maximal allowed safety decay) must be from the
+most recent `MIN_EPOCHS_FOR_BLOCK_REQUESTS` epochs, and thus a user must be able to block sync to the head from this starting point.
+Thus, this defines the epoch range outside which nodes may prune blocks, and
+the epoch range that a new node syncing from a checkpoint must backfill.
+
+`MIN_EPOCHS_FOR_BLOCK_REQUESTS` is calculated using the arithmetic from `compute_weak_subjectivity_period` found in the
+[weak subjectivity guide](./weak-subjectivity.md). Specifically to find this max epoch range, we use the worst case event of a very large validator size
+(`>= MIN_PER_EPOCH_CHURN_LIMIT * CHURN_LIMIT_QUOTIENT`).
+
+```python
+MIN_EPOCHS_FOR_BLOCK_REQUESTS = (
+    MIN_VALIDATOR_WITHDRAWABILITY_DELAY
+    + MAX_SAFETY_DECAY * CHURN_LIMIT_QUOTIENT // (2 * 100)
+)
+```
+
+Where `MAX_SAFETY_DECAY = 100` and thus `MIN_EPOCHS_FOR_BLOCK_REQUESTS = 33024` (~5 months).
+
+
 ### What's the effect of empty slots on the sync algorithm?
 
 When syncing one can only tell that a slot has been skipped on a particular branch
diff --git a/specs/phase0/weak-subjectivity.md b/specs/phase0/weak-subjectivity.md
index b4d78cb12..797f972a1 100644
--- a/specs/phase0/weak-subjectivity.md
+++ b/specs/phase0/weak-subjectivity.md
@@ -94,7 +94,9 @@ A brief reference for what these values look like in practice:
 
 ## Weak Subjectivity Sync
 
-Clients should allow users to input a Weak Subjectivity Checkpoint at startup, and guarantee that any successful sync leads to the given Weak Subjectivity Checkpoint along the canonical chain. If such a sync is not possible, the client should treat this as a critical and irrecoverable failure.
+Clients should allow users to input a Weak Subjectivity Checkpoint at startup,
+and guarantee that any successful sync leads to the given Weak Subjectivity Checkpoint along the canonical chain.
+If such a sync is not possible, the client should treat this as a critical and irrecoverable failure.
 
 ### Weak Subjectivity Sync Procedure
 
@@ -112,6 +114,7 @@ Clients should allow users to input a Weak Subjectivity Checkpoint at startup, a
       Emit descriptive critical error if this assert fails, then exit client process.
 
 ### Checking for Stale Weak Subjectivity Checkpoint
+
 Clients may choose to validate that the input Weak Subjectivity Checkpoint is not stale at the time of startup.
 To support this mechanism, the client needs to take the state at the Weak Subjectivity Checkpoint as
 a CLI parameter input (or fetch the state associated with the input Weak Subjectivity Checkpoint from some source).

From 56aafbe533c6f5ed7881a65b22c41c1d7367c50e Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 9 Dec 2020 12:37:56 -0700
Subject: [PATCH 02/43] add note about signature check when backfilling
 beaconblocks

---
 specs/phase0/p2p-interface.md | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 8104b54c7..df17258ab 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -94,6 +94,7 @@ It consists of four main sections:
     - [Why do we allow empty responses in block requests?](#why-do-we-allow-empty-responses-in-block-requests)
     - [Why does `BeaconBlocksByRange` let the server choose which branch to send blocks from?](#why-does-beaconblocksbyrange-let-the-server-choose-which-branch-to-send-blocks-from)
     - [Why are `BlocksByRange` requests only required to be served for the latest `MIN_EPOCHS_FOR_BLOCK_REQUESTS` epochs?](#why-are-blocksbyrange-requests-only-required-to-be-served-for-the-latest-min_epochs_for_block_requests-epochs)
+    - [Why must the proposer signature be checked when backfilling blocks in the database?](#why-must-the-proposer-signature-be-checked-when-backfilling-blocks-in-the-database)
     - [What's the effect of empty slots on the sync algorithm?](#whats-the-effect-of-empty-slots-on-the-sync-algorithm)
   - [Discovery](#discovery)
     - [Why are we using discv5 and not libp2p Kademlia DHT?](#why-are-we-using-discv5-and-not-libp2p-kademlia-dht)
@@ -754,7 +755,10 @@ and clients MUST support serving requests of blocks on this range.
 
 *Note*: The above requirement implies that nodes that start from a recent weak subjectivity checkpoint
 MUST backfill the local block database to at least epoch `current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS`
-to be compliant with `BlocksByRange` requests.
+to be compliant with `BlocksByRange` requests. To safely perform such a
+backfill of blocks to the recent state, the node MUST validate both (1) the
+proposer signatures and (2) that the blocks form a valid chain up to the most
+recent block referenced in the weak subjectivity state.
 
 Clients MUST respond with at least the first block that exists in the range, if they have it,
 and no more than `MAX_REQUEST_BLOCKS` blocks.
@@ -1426,6 +1430,20 @@ MIN_EPOCHS_FOR_BLOCK_REQUESTS = (
 
 Where `MAX_SAFETY_DECAY = 100` and thus `MIN_EPOCHS_FOR_BLOCK_REQUESTS = 33024` (~5 months).
 
+### Why must the proposer signature be checked when backfilling blocks in the database?
+
+When backfilling blocks in a database from a know safe block/state (e.g. when starting from a weak subjectivity state),
+the node not only must ensure the `BeaconBlock`s form a chain to the known safe block,
+but also must check that the proposer signature is valid in the `SignedBeaconBlock` wrapper.
+
+This is because the signature is not part of the `BeaconBlock` hash chain, and
+thus could be corrupted by an attacker serving valid `BeaconBlock`s but invalid
+signatures contained in `SignedBeaconBlock`.
+
+Although in this particular use case this does not represent a decay in safety
+(due to the assumptions of starting at a weak subjectivity checkpoint), it
+would represent invalid historic data and could be unwittingly transmitted to
+additional nodes.
 
 ### What's the effect of empty slots on the sync algorithm?
 

From 2ad8fdb818f58778391d93540892d35570f33237 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 13 Jan 2021 18:03:40 -0700
Subject: [PATCH 03/43] add ability for node to randomly request and descore if
 not serving blocks on WS period

---
 specs/phase0/p2p-interface.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index df17258ab..4a412ac19 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -753,6 +753,11 @@ Clients MUST keep a record of signed blocks seen on the epoch range
 where `current_epoch` is defined by the current wall-clock time,
 and clients MUST support serving requests of blocks on this range.
 
+Synced clients unable to reply to Block requests within the
+`MIN_EPOCHS_FOR_BLOCK_REQUESTS` epoch range MAY get descored or disconnected at any time.
+Note, due to this it is risky behaviour to begin participating as a full node at the head if having
+not yet backfilled on this range.
+
 *Note*: The above requirement implies that nodes that start from a recent weak subjectivity checkpoint
 MUST backfill the local block database to at least epoch `current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS`
 to be compliant with `BlocksByRange` requests. To safely perform such a

From 786e611c71d5c62bf30c988c692ab88d1a54d8f3 Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 12:05:32 +0100
Subject: [PATCH 04/43] Flags to BitVector

---
 specs/altair/beacon-chain.md | 31 +++++--------------------------
 1 file changed, 5 insertions(+), 26 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 7bf0c2d99..66b069cc5 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -69,7 +69,7 @@ Altair is the first beacon chain hard fork. Its main features are:
 
 | Name | SSZ equivalent | Description |
 | - | - | - |
-| `ParticipationFlags` | `uint8` | a succinct representation of 8 boolean participation flags |
+| `ParticipationFlags` | `BitVector[PARTICIPATION_FLAGS_LENGTH]` | a succinct representation of up to 8 boolean participation flags |
 
 ## Constants
 
@@ -99,6 +99,7 @@ Altair is the first beacon chain hard fork. Its main features are:
 | Name | Value |
 | - | - |
 | `G2_POINT_AT_INFINITY` | `BLSSignature(b'\xc0' + b'\x00' * 95)` |
+| `PARTICIPATION_FLAGS_LENGTH` | `8` |
 
 ## Configuration
 
@@ -247,28 +248,6 @@ def get_flag_indices_and_weights() -> Sequence[Tuple[int, uint64]]:
     )
 ```
 
-#### `add_flag`
-
-```python
-def add_flag(flags: ParticipationFlags, flag_index: int) -> ParticipationFlags:
-    """
-    Return a new ``ParticipationFlags`` adding ``flag_index`` to ``flags``.
-    """
-    flag = ParticipationFlags(2**flag_index)
-    return flags | flag
-```
-
-#### `has_flag`
-
-```python
-def has_flag(flags: ParticipationFlags, flag_index: int) -> bool:
-    """
-    Return whether ``flags`` has ``flag_index`` set.
-    """
-    flag = ParticipationFlags(2**flag_index)
-    return flags & flag == flag
-```
-
 ### Beacon state accessors
 
 #### `get_sync_committee_indices`
@@ -348,7 +327,7 @@ def get_unslashed_participating_indices(state: BeaconState, flag_index: int, epo
     else:
         epoch_participation = state.previous_epoch_participation
     active_validator_indices = get_active_validator_indices(state, epoch)
-    participating_indices = [i for i in active_validator_indices if has_flag(epoch_participation[i], flag_index)]
+    participating_indices = [i for i in active_validator_indices if epoch_participation[i][flag_index]]
     return set(filter(lambda index: not state.validators[index].slashed, participating_indices))
 ```
 
@@ -492,8 +471,8 @@ def process_attestation(state: BeaconState, attestation: Attestation) -> None:
     proposer_reward_numerator = 0
     for index in get_attesting_indices(state, data, attestation.aggregation_bits):
         for flag_index, weight in get_flag_indices_and_weights():
-            if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
-                epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
+            if flag_index in participation_flag_indices and not epoch_participation[index][flag_index]:
+                epoch_participation[index][flag_index] = True
                 proposer_reward_numerator += get_base_reward(state, index) * weight
 
     # Reward proposer

From df6bd1b6c33833c264561da361436453e5e55f4c Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 12:26:37 +0100
Subject: [PATCH 05/43] BitVector -> Bitvector

---
 specs/altair/beacon-chain.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 66b069cc5..e023db1f7 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -69,7 +69,7 @@ Altair is the first beacon chain hard fork. Its main features are:
 
 | Name | SSZ equivalent | Description |
 | - | - | - |
-| `ParticipationFlags` | `BitVector[PARTICIPATION_FLAGS_LENGTH]` | a succinct representation of up to 8 boolean participation flags |
+| `ParticipationFlags` | `Bitvector[PARTICIPATION_FLAGS_LENGTH]` | a succinct representation of up to 8 boolean participation flags |
 
 ## Constants
 

From 238a9b03fc794bfe322ebec4b67290df4159891c Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 18:09:36 +0100
Subject: [PATCH 06/43] Correct confusing comments in
 "get_sync_committee_indices"

---
 specs/altair/beacon-chain.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index e023db1f7..719f93033 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -205,6 +205,7 @@ class BeaconState(Container):
 ```python
 class SyncAggregate(Container):
     sync_committee_bits: Bitvector[SYNC_COMMITTEE_SIZE]
+    # TODO! Need multiple signatures as discussed between Justin and Vitalik May 3 2021 (see Telegram)
     sync_committee_signature: BLSSignature
 ```
 
@@ -255,8 +256,9 @@ def get_flag_indices_and_weights() -> Sequence[Tuple[int, uint64]]:
 ```python
 def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[ValidatorIndex]:
     """
-    Return the sequence of sync committee indices (which may include duplicate indices)
+    Return the sequence of sync committee indices
     for a given ``state`` and ``epoch``.
+    Can contain duplicate indices for small validator sets (< 2 * SYNC_COMMITTEE_SIZE)
     """
     MAX_RANDOM_BYTE = 2**8 - 1
     base_epoch = Epoch((max(epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD, 1) - 1) * EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
@@ -270,7 +272,7 @@ def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[Val
         candidate_index = active_validator_indices[shuffled_index]
         random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
         effective_balance = state.validators[candidate_index].effective_balance
-        if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:  # Sample with replacement
+        if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE * random_byte:
             sync_committee_indices.append(candidate_index)
         i += 1
     return sync_committee_indices

From a382cf6d5c97409868a3da558351522b8b710d95 Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 20:04:06 +0100
Subject: [PATCH 07/43] Refactor participation flag list

---
 specs/altair/beacon-chain.md | 34 ++++++++++------------------------
 1 file changed, 10 insertions(+), 24 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 719f93033..e311734d9 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -100,6 +100,9 @@ Altair is the first beacon chain hard fork. Its main features are:
 | - | - |
 | `G2_POINT_AT_INFINITY` | `BLSSignature(b'\xc0' + b'\x00' * 95)` |
 | `PARTICIPATION_FLAGS_LENGTH` | `8` |
+| `PARTICIPATION_FLAGS` | `3` |
+| `TIMELY_HEAD_WEIGHT` | `uint64(12)` |
+| `PARTICIPATION_FLAG_WEIGHTS` | `[TIMELY_HEAD_WEIGHT, TIMELY_SOURCE_WEIGHT, TIMELY_TARGET_WEIGHT]` |
 
 ## Configuration
 
@@ -233,22 +236,6 @@ def eth2_fast_aggregate_verify(pubkeys: Sequence[BLSPubkey], message: Bytes32, s
     return bls.FastAggregateVerify(pubkeys, message, signature)
 ```
 
-### Misc
-
-#### `get_flag_indices_and_weights`
-
-```python
-def get_flag_indices_and_weights() -> Sequence[Tuple[int, uint64]]:
-    """
-    Return paired tuples of participation flag indices along with associated incentivization weights.
-    """
-    return (
-        (TIMELY_HEAD_FLAG_INDEX, TIMELY_HEAD_WEIGHT),
-        (TIMELY_SOURCE_FLAG_INDEX, TIMELY_SOURCE_WEIGHT),
-        (TIMELY_TARGET_FLAG_INDEX, TIMELY_TARGET_WEIGHT),
-    )
-```
-
 ### Beacon state accessors
 
 #### `get_sync_committee_indices`
@@ -336,16 +323,16 @@ def get_unslashed_participating_indices(state: BeaconState, flag_index: int, epo
 #### `get_flag_index_deltas`
 
 ```python
-def get_flag_index_deltas(state: BeaconState, flag_index: int, weight: uint64) -> Tuple[Sequence[Gwei], Sequence[Gwei]]:
+def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence[Gwei], Sequence[Gwei]]:
     """
     Return the deltas for a given ``flag_index`` scaled by ``weight`` by scanning through the participation flags.
     """
     rewards = [Gwei(0)] * len(state.validators)
     penalties = [Gwei(0)] * len(state.validators)
     unslashed_participating_indices = get_unslashed_participating_indices(state, flag_index, get_previous_epoch(state))
-    increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from balances to avoid uint64 overflow
-    unslashed_participating_increments = get_total_balance(state, unslashed_participating_indices) // increment
-    active_increments = get_total_active_balance(state) // increment
+    weight = PARTICIPATION_FLAG_WEIGHTS[flag_index]
+    unslashed_participating_increments = get_total_balance(state, unslashed_participating_indices) // EFFECTIVE_BALANCE_INCREMENT
+    active_increments = get_total_active_balance(state) // EFFECTIVE_BALANCE_INCREMENT
     for index in get_eligible_validator_indices(state):
         base_reward = get_base_reward(state, index)
         if index in unslashed_participating_indices:
@@ -376,7 +363,7 @@ def get_inactivity_penalty_deltas(state: BeaconState) -> Tuple[Sequence[Gwei], S
         previous_epoch = get_previous_epoch(state)
         matching_target_indices = get_unslashed_participating_indices(state, TIMELY_TARGET_FLAG_INDEX, previous_epoch)
         for index in get_eligible_validator_indices(state):
-            for (_, weight) in get_flag_indices_and_weights():
+            for weight in PARTICIPATION_FLAG_WEIGHTS:
                 # This inactivity penalty cancels the flag reward corresponding to the flag index
                 penalties[index] += Gwei(get_base_reward(state, index) * weight // WEIGHT_DENOMINATOR)
             if index not in matching_target_indices:
@@ -472,7 +459,7 @@ def process_attestation(state: BeaconState, attestation: Attestation) -> None:
     # Update epoch participation flags
     proposer_reward_numerator = 0
     for index in get_attesting_indices(state, data, attestation.aggregation_bits):
-        for flag_index, weight in get_flag_indices_and_weights():
+        for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
             if flag_index in participation_flag_indices and not epoch_participation[index][flag_index]:
                 epoch_participation[index][flag_index] = True
                 proposer_reward_numerator += get_base_reward(state, index) * weight
@@ -613,8 +600,7 @@ def process_rewards_and_penalties(state: BeaconState) -> None:
     if get_current_epoch(state) == GENESIS_EPOCH:
         return
 
-    flag_indices_and_numerators = get_flag_indices_and_weights()
-    flag_deltas = [get_flag_index_deltas(state, index, numerator) for (index, numerator) in flag_indices_and_numerators]
+    flag_deltas = [get_flag_index_deltas(state, flag_index) for flag_index in range(PARTICIPATION_FLAGS)]
     deltas = flag_deltas + [get_inactivity_penalty_deltas(state)]
     for (rewards, penalties) in deltas:
         for index in range(len(state.validators)):

From 227d1007e67558e7b7a419723efe932470976441 Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 20:09:14 +0100
Subject: [PATCH 08/43] Update toc

---
 specs/altair/beacon-chain.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index e311734d9..bd9c23bf3 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -27,10 +27,6 @@
 - [Helper functions](#helper-functions)
   - [`Predicates`](#predicates)
     - [`eth2_fast_aggregate_verify`](#eth2_fast_aggregate_verify)
-  - [Misc](#misc-2)
-    - [`get_flag_indices_and_weights`](#get_flag_indices_and_weights)
-    - [`add_flag`](#add_flag)
-    - [`has_flag`](#has_flag)
   - [Beacon state accessors](#beacon-state-accessors)
     - [`get_sync_committee_indices`](#get_sync_committee_indices)
     - [`get_sync_committee`](#get_sync_committee)

From 687641a79bbe9db18de358f6c230e05a59cb905e Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 21:55:36 +0100
Subject: [PATCH 09/43] Remove extra variable

---
 specs/altair/beacon-chain.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index bd9c23bf3..1a50e7337 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -97,7 +97,6 @@ Altair is the first beacon chain hard fork. Its main features are:
 | `G2_POINT_AT_INFINITY` | `BLSSignature(b'\xc0' + b'\x00' * 95)` |
 | `PARTICIPATION_FLAGS_LENGTH` | `8` |
 | `PARTICIPATION_FLAGS` | `3` |
-| `TIMELY_HEAD_WEIGHT` | `uint64(12)` |
 | `PARTICIPATION_FLAG_WEIGHTS` | `[TIMELY_HEAD_WEIGHT, TIMELY_SOURCE_WEIGHT, TIMELY_TARGET_WEIGHT]` |
 
 ## Configuration

From 55471bc5d4f69678baf6950e6197b5206b2cbb8a Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 21:58:03 +0100
Subject: [PATCH 10/43] Revert "BitVector -> Bitvector"

This reverts commit df6bd1b6c33833c264561da361436453e5e55f4c.
---
 specs/altair/beacon-chain.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 1a50e7337..9e868fbaa 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -65,7 +65,7 @@ Altair is the first beacon chain hard fork. Its main features are:
 
 | Name | SSZ equivalent | Description |
 | - | - | - |
-| `ParticipationFlags` | `Bitvector[PARTICIPATION_FLAGS_LENGTH]` | a succinct representation of up to 8 boolean participation flags |
+| `ParticipationFlags` | `BitVector[PARTICIPATION_FLAGS_LENGTH]` | a succinct representation of up to 8 boolean participation flags |
 
 ## Constants
 

From 77524036f56c71d4c8199c1393af524b7841290f Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 22:02:37 +0100
Subject: [PATCH 11/43] Revert "Flags to BitVector"

This reverts commit 786e611c71d5c62bf30c988c692ab88d1a54d8f3.

# Conflicts:
#	specs/altair/beacon-chain.md
---
 specs/altair/beacon-chain.md | 32 +++++++++++++++++++++++++++++---
 1 file changed, 29 insertions(+), 3 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 9e868fbaa..5bce9ba4e 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -27,6 +27,9 @@
 - [Helper functions](#helper-functions)
   - [`Predicates`](#predicates)
     - [`eth2_fast_aggregate_verify`](#eth2_fast_aggregate_verify)
+  - [Misc](#misc-2)
+    - [`add_flag`](#add_flag)
+    - [`has_flag`](#has_flag)
   - [Beacon state accessors](#beacon-state-accessors)
     - [`get_sync_committee_indices`](#get_sync_committee_indices)
     - [`get_sync_committee`](#get_sync_committee)
@@ -65,7 +68,7 @@ Altair is the first beacon chain hard fork. Its main features are:
 
 | Name | SSZ equivalent | Description |
 | - | - | - |
-| `ParticipationFlags` | `BitVector[PARTICIPATION_FLAGS_LENGTH]` | a succinct representation of up to 8 boolean participation flags |
+| `ParticipationFlags` | `uint8` | a succinct representation of 8 boolean participation flags |
 
 ## Constants
 
@@ -95,7 +98,6 @@ Altair is the first beacon chain hard fork. Its main features are:
 | Name | Value |
 | - | - |
 | `G2_POINT_AT_INFINITY` | `BLSSignature(b'\xc0' + b'\x00' * 95)` |
-| `PARTICIPATION_FLAGS_LENGTH` | `8` |
 | `PARTICIPATION_FLAGS` | `3` |
 | `PARTICIPATION_FLAG_WEIGHTS` | `[TIMELY_HEAD_WEIGHT, TIMELY_SOURCE_WEIGHT, TIMELY_TARGET_WEIGHT]` |
 
@@ -231,6 +233,30 @@ def eth2_fast_aggregate_verify(pubkeys: Sequence[BLSPubkey], message: Bytes32, s
     return bls.FastAggregateVerify(pubkeys, message, signature)
 ```
 
+### Misc
+
+#### `add_flag`
+
+```python
+def add_flag(flags: ParticipationFlags, flag_index: int) -> ParticipationFlags:
+    """
+    Return a new ``ParticipationFlags`` adding ``flag_index`` to ``flags``.
+    """
+    flag = ParticipationFlags(2**flag_index)
+    return flags | flag
+```
+
+#### `has_flag`
+
+```python
+def has_flag(flags: ParticipationFlags, flag_index: int) -> bool:
+    """
+    Return whether ``flags`` has ``flag_index`` set.
+    """
+    flag = ParticipationFlags(2**flag_index)
+    return flags & flag == flag
+```
+
 ### Beacon state accessors
 
 #### `get_sync_committee_indices`
@@ -311,7 +337,7 @@ def get_unslashed_participating_indices(state: BeaconState, flag_index: int, epo
     else:
         epoch_participation = state.previous_epoch_participation
     active_validator_indices = get_active_validator_indices(state, epoch)
-    participating_indices = [i for i in active_validator_indices if epoch_participation[i][flag_index]]
+    participating_indices = [i for i in active_validator_indices if has_flag(epoch_participation[i], flag_index)]
     return set(filter(lambda index: not state.validators[index].slashed, participating_indices))
 ```
 

From b041a9b0d68cdee2de0d0d36590f07b49ea12dff Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Wed, 5 May 2021 22:22:32 +0100
Subject: [PATCH 12/43] Further flag_index revert

---
 specs/altair/beacon-chain.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 5bce9ba4e..5a8dcce24 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -481,8 +481,8 @@ def process_attestation(state: BeaconState, attestation: Attestation) -> None:
     proposer_reward_numerator = 0
     for index in get_attesting_indices(state, data, attestation.aggregation_bits):
         for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
-            if flag_index in participation_flag_indices and not epoch_participation[index][flag_index]:
-                epoch_participation[index][flag_index] = True
+            if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
+                epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
                 proposer_reward_numerator += get_base_reward(state, index) * weight
 
     # Reward proposer

From cbf9f85537c3c91c38ac51b1e3ac4efd2d5f240c Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Thu, 6 May 2021 12:28:18 +0100
Subject: [PATCH 13/43] Remove duplicate inactivity leak

---
 specs/altair/beacon-chain.md | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 5a8dcce24..9ad2c0089 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -357,10 +357,7 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
     for index in get_eligible_validator_indices(state):
         base_reward = get_base_reward(state, index)
         if index in unslashed_participating_indices:
-            if is_in_inactivity_leak(state):
-                # This flag reward cancels the inactivity penalty corresponding to the flag index
-                rewards[index] += Gwei(base_reward * weight // WEIGHT_DENOMINATOR)
-            else:
+            if not is_in_inactivity_leak(state):
                 reward_numerator = base_reward * weight * unslashed_participating_increments
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
         else:
@@ -384,9 +381,6 @@ def get_inactivity_penalty_deltas(state: BeaconState) -> Tuple[Sequence[Gwei], S
         previous_epoch = get_previous_epoch(state)
         matching_target_indices = get_unslashed_participating_indices(state, TIMELY_TARGET_FLAG_INDEX, previous_epoch)
         for index in get_eligible_validator_indices(state):
-            for weight in PARTICIPATION_FLAG_WEIGHTS:
-                # This inactivity penalty cancels the flag reward corresponding to the flag index
-                penalties[index] += Gwei(get_base_reward(state, index) * weight // WEIGHT_DENOMINATOR)
             if index not in matching_target_indices:
                 penalty_numerator = state.validators[index].effective_balance * state.inactivity_scores[index]
                 penalty_denominator = INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR

From cf724daa7a07092a02522879a0b1cb088db7c3b5 Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Thu, 6 May 2021 12:42:05 +0100
Subject: [PATCH 14/43] No inactivity penalty for untimely head

---
 specs/altair/beacon-chain.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 9ad2c0089..e90c587be 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -354,13 +354,14 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
     weight = PARTICIPATION_FLAG_WEIGHTS[flag_index]
     unslashed_participating_increments = get_total_balance(state, unslashed_participating_indices) // EFFECTIVE_BALANCE_INCREMENT
     active_increments = get_total_active_balance(state) // EFFECTIVE_BALANCE_INCREMENT
+    in_inactivity_leak = is_in_inactivity_leak(state)
     for index in get_eligible_validator_indices(state):
         base_reward = get_base_reward(state, index)
         if index in unslashed_participating_indices:
-            if not is_in_inactivity_leak(state):
+            if not in_inactivity_leak:
                 reward_numerator = base_reward * weight * unslashed_participating_increments
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
-        else:
+        elif not (in_inactivity_leak and flag_index == TIMELY_HEAD_FLAG_INDEX):
             penalties[index] += Gwei(base_reward * weight // WEIGHT_DENOMINATOR)
     return rewards, penalties
 ```

From 81a8c2748fed22b6b5753840f228f00b212c8072 Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Thu, 6 May 2021 13:03:26 +0100
Subject: [PATCH 15/43] Integrate get_inactivity_penalty_deltas into reward
 computation for better readability

---
 specs/altair/beacon-chain.md | 34 ++++++++--------------------------
 1 file changed, 8 insertions(+), 26 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index e90c587be..f464bd640 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -350,7 +350,8 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
     """
     rewards = [Gwei(0)] * len(state.validators)
     penalties = [Gwei(0)] * len(state.validators)
-    unslashed_participating_indices = get_unslashed_participating_indices(state, flag_index, get_previous_epoch(state))
+    previous_epoch = get_previous_epoch(state)
+    unslashed_participating_indices = get_unslashed_participating_indices(state, flag_index, previous_epoch)
     weight = PARTICIPATION_FLAG_WEIGHTS[flag_index]
     unslashed_participating_increments = get_total_balance(state, unslashed_participating_indices) // EFFECTIVE_BALANCE_INCREMENT
     active_increments = get_total_active_balance(state) // EFFECTIVE_BALANCE_INCREMENT
@@ -363,29 +364,11 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
         elif not (in_inactivity_leak and flag_index == TIMELY_HEAD_FLAG_INDEX):
             penalties[index] += Gwei(base_reward * weight // WEIGHT_DENOMINATOR)
-    return rewards, penalties
-```
-
-#### Modified `get_inactivity_penalty_deltas`
-
-*Note*: The function `get_inactivity_penalty_deltas` is modified in the selection of matching target indices
-and the removal of `BASE_REWARDS_PER_EPOCH`.
-
-```python
-def get_inactivity_penalty_deltas(state: BeaconState) -> Tuple[Sequence[Gwei], Sequence[Gwei]]:
-    """
-    Return the inactivity penalty deltas by considering timely target participation flags and inactivity scores.
-    """
-    rewards = [Gwei(0) for _ in range(len(state.validators))]
-    penalties = [Gwei(0) for _ in range(len(state.validators))]
-    if is_in_inactivity_leak(state):
-        previous_epoch = get_previous_epoch(state)
-        matching_target_indices = get_unslashed_participating_indices(state, TIMELY_TARGET_FLAG_INDEX, previous_epoch)
-        for index in get_eligible_validator_indices(state):
-            if index not in matching_target_indices:
-                penalty_numerator = state.validators[index].effective_balance * state.inactivity_scores[index]
-                penalty_denominator = INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR
-                penalties[index] += Gwei(penalty_numerator // penalty_denominator)
+        # Quadratic inactivity leak
+        if flag_index == TIMELY_TARGET_FLAG_INDEX and in_inactivity_leak and index not in unslashed_participating_indices:
+            penalty_numerator = state.validators[index].effective_balance * state.inactivity_scores[index]
+            penalty_denominator = INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR
+            penalties[index] += Gwei(penalty_numerator // penalty_denominator)
     return rewards, penalties
 ```
 
@@ -617,8 +600,7 @@ def process_rewards_and_penalties(state: BeaconState) -> None:
         return
 
     flag_deltas = [get_flag_index_deltas(state, flag_index) for flag_index in range(PARTICIPATION_FLAGS)]
-    deltas = flag_deltas + [get_inactivity_penalty_deltas(state)]
-    for (rewards, penalties) in deltas:
+    for (rewards, penalties) in flag_deltas:
         for index in range(len(state.validators)):
             increase_balance(state, ValidatorIndex(index), rewards[index])
             decrease_balance(state, ValidatorIndex(index), penalties[index])

From ba2c717bf112bb496afc80cedbd1aeac7d59049a Mon Sep 17 00:00:00 2001
From: Dankrad Feist <mail@dankradfeist.de>
Date: Thu, 6 May 2021 22:55:17 +0100
Subject: [PATCH 16/43] Remove PARTICIPATION_FLAGS

---
 specs/altair/beacon-chain.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index f464bd640..f559a55ef 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -98,7 +98,6 @@ Altair is the first beacon chain hard fork. Its main features are:
 | Name | Value |
 | - | - |
 | `G2_POINT_AT_INFINITY` | `BLSSignature(b'\xc0' + b'\x00' * 95)` |
-| `PARTICIPATION_FLAGS` | `3` |
 | `PARTICIPATION_FLAG_WEIGHTS` | `[TIMELY_HEAD_WEIGHT, TIMELY_SOURCE_WEIGHT, TIMELY_TARGET_WEIGHT]` |
 
 ## Configuration
@@ -599,7 +598,7 @@ def process_rewards_and_penalties(state: BeaconState) -> None:
     if get_current_epoch(state) == GENESIS_EPOCH:
         return
 
-    flag_deltas = [get_flag_index_deltas(state, flag_index) for flag_index in range(PARTICIPATION_FLAGS)]
+    flag_deltas = [get_flag_index_deltas(state, flag_index) for flag_index in range(len(PARTICIPATION_FLAG_WEIGHTS))]
     for (rewards, penalties) in flag_deltas:
         for index in range(len(state.validators)):
             increase_balance(state, ValidatorIndex(index), rewards[index])

From 2fc68c451e8168b2c2cc85182e77e41550c15302 Mon Sep 17 00:00:00 2001
From: dankrad <dankrad@ethereum.org>
Date: Thu, 6 May 2021 22:55:55 +0100
Subject: [PATCH 17/43] Update specs/altair/beacon-chain.md

Co-authored-by: Alex Stokes <r.alex.stokes@gmail.com>
---
 specs/altair/beacon-chain.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index f559a55ef..f21584f30 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -263,8 +263,7 @@ def has_flag(flags: ParticipationFlags, flag_index: int) -> bool:
 ```python
 def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[ValidatorIndex]:
     """
-    Return the sequence of sync committee indices
-    for a given ``state`` and ``epoch``.
+    Return the sequence of sync committee indices for a given ``state`` and ``epoch``.
     Can contain duplicate indices for small validator sets (< 2 * SYNC_COMMITTEE_SIZE)
     """
     MAX_RANDOM_BYTE = 2**8 - 1

From cd7842557054845462e2f209751c8f61d14c0111 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 May 2021 10:30:47 -0600
Subject: [PATCH 18/43] lint

---
 specs/altair/beacon-chain.md | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 5c21573fb..5a4b37a83 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -362,19 +362,22 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
     previous_epoch = get_previous_epoch(state)
     unslashed_participating_indices = get_unslashed_participating_indices(state, flag_index, previous_epoch)
     weight = PARTICIPATION_FLAG_WEIGHTS[flag_index]
-    unslashed_participating_increments = get_total_balance(state, unslashed_participating_indices) // EFFECTIVE_BALANCE_INCREMENT
+    unslashed_participating_balance = get_total_balance(state, unslashed_participating_indices)
+    unslashed_participating_increments = unslashed_participating_balance // EFFECTIVE_BALANCE_INCREMENT
     active_increments = get_total_active_balance(state) // EFFECTIVE_BALANCE_INCREMENT
     in_inactivity_leak = is_in_inactivity_leak(state)
     for index in get_eligible_validator_indices(state):
         base_reward = get_base_reward(state, index)
-        if index in unslashed_participating_indices:
+        index_participated = index in unslashed_participating_indices
+        if index_participated:
             if not in_inactivity_leak:
                 reward_numerator = base_reward * weight * unslashed_participating_increments
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
         elif not (in_inactivity_leak and flag_index == TIMELY_HEAD_FLAG_INDEX):
             penalties[index] += Gwei(base_reward * weight // WEIGHT_DENOMINATOR)
+
         # Quadratic inactivity leak
-        if flag_index == TIMELY_TARGET_FLAG_INDEX and in_inactivity_leak and index not in unslashed_participating_indices:
+        if flag_index == TIMELY_TARGET_FLAG_INDEX and in_inactivity_leak and index_participated:
             penalty_numerator = state.validators[index].effective_balance * state.inactivity_scores[index]
             penalty_denominator = INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR
             penalties[index] += Gwei(penalty_numerator // penalty_denominator)

From 1494fe6ace0c54231d8e7d080da7eb5134a829df Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 May 2021 10:59:33 -0600
Subject: [PATCH 19/43] add get_inactivity_penalty_deltas back in

---
 specs/altair/beacon-chain.md | 33 ++++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 5a4b37a83..265bbfa53 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -37,6 +37,7 @@
     - [`get_base_reward`](#get_base_reward)
     - [`get_unslashed_participating_indices`](#get_unslashed_participating_indices)
     - [`get_flag_index_deltas`](#get_flag_index_deltas)
+    - [Modified `get_inactivity_penalty_deltas`](#modified-get_inactivity_penalty_deltas)
   - [Beacon state mutators](#beacon-state-mutators)
     - [Modified `slash_validator`](#modified-slash_validator)
   - [Block processing](#block-processing)
@@ -368,19 +369,32 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
     in_inactivity_leak = is_in_inactivity_leak(state)
     for index in get_eligible_validator_indices(state):
         base_reward = get_base_reward(state, index)
-        index_participated = index in unslashed_participating_indices
-        if index_participated:
+        if index in unslashed_participating_indices:
             if not in_inactivity_leak:
                 reward_numerator = base_reward * weight * unslashed_participating_increments
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
-        elif not (in_inactivity_leak and flag_index == TIMELY_HEAD_FLAG_INDEX):
+        else:
             penalties[index] += Gwei(base_reward * weight // WEIGHT_DENOMINATOR)
+    return rewards, penalties
+```
 
-        # Quadratic inactivity leak
-        if flag_index == TIMELY_TARGET_FLAG_INDEX and in_inactivity_leak and index_participated:
-            penalty_numerator = state.validators[index].effective_balance * state.inactivity_scores[index]
-            penalty_denominator = INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR
-            penalties[index] += Gwei(penalty_numerator // penalty_denominator)
+#### Modified `get_inactivity_penalty_deltas`
+
+```python
+def get_inactivity_penalty_deltas(state: BeaconState) -> Tuple[Sequence[Gwei], Sequence[Gwei]]:
+    """
+    Return the inactivity penalty deltas by considering timely target participation flags and inactivity scores.
+    """
+    rewards = [Gwei(0) for _ in range(len(state.validators))]
+    penalties = [Gwei(0) for _ in range(len(state.validators))]
+    if is_in_inactivity_leak(state):
+        previous_epoch = get_previous_epoch(state)
+        matching_target_indices = get_unslashed_participating_indices(state, TIMELY_TARGET_FLAG_INDEX, previous_epoch)
+        for index in get_eligible_validator_indices(state):
+            if index not in matching_target_indices:
+                penalty_numerator = state.validators[index].effective_balance * state.inactivity_scores[index]
+                penalty_denominator = INACTIVITY_SCORE_BIAS * INACTIVITY_PENALTY_QUOTIENT_ALTAIR
+                penalties[index] += Gwei(penalty_numerator // penalty_denominator)
     return rewards, penalties
 ```
 
@@ -613,7 +627,8 @@ def process_rewards_and_penalties(state: BeaconState) -> None:
         return
 
     flag_deltas = [get_flag_index_deltas(state, flag_index) for flag_index in range(len(PARTICIPATION_FLAG_WEIGHTS))]
-    for (rewards, penalties) in flag_deltas:
+    deltas = flag_deltas + [get_inactivity_penalty_deltas(state)]
+    for (rewards, penalties) in deltas:
         for index in range(len(state.validators)):
             increase_balance(state, ValidatorIndex(index), rewards[index])
             decrease_balance(state, ValidatorIndex(index), penalties[index])

From ff706e5c7a8bc68422595e7d3c2c55c9ca2183db Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 May 2021 12:57:11 -0600
Subject: [PATCH 20/43] add logic for handling sync committee off by one issue

---
 specs/altair/p2p-interface.md | 11 ++++++++++-
 specs/altair/validator.md     |  6 +++++-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/specs/altair/p2p-interface.md b/specs/altair/p2p-interface.md
index 85e859191..02a159f7a 100644
--- a/specs/altair/p2p-interface.md
+++ b/specs/altair/p2p-interface.md
@@ -106,9 +106,18 @@ The following validations MUST pass before forwarding the `signed_contribution_a
 
 ```python
 def get_sync_subcommittee_pubkeys(state: BeaconState, subcommittee_index: uint64) -> Sequence[BLSPubkey]:
+    # Committees assigned to `slot` sign for `slot - 1`
+    # This creates the exceptional logic below when transitioning between sync comittee periods
+    next_slot_epoch = compute_epoch_at_slot(state.slot + 1)
+    if compute_sync_committee_period(get_current_epoch(state)) == compute_sync_committee_period(next_slot_epoch):
+        sync_committee = state.current_sync_committee
+    else:
+        sync_committee = state.next_sync_committee
+
+    # Return pubkeys for the subcommittee index
     sync_subcommittee_size = SYNC_COMMITTEE_SIZE // SYNC_COMMITTEE_SUBNET_COUNT
     i = subcommittee_index * sync_subcommittee_size
-    return state.current_sync_committee.pubkeys[i:i + sync_subcommittee_size]
+    return sync_committee.pubkeys[i:i + sync_subcommittee_size]
 ```
 
 - _[IGNORE]_ The contribution's slot is for the current slot, i.e. `contribution.slot == current_slot`.
diff --git a/specs/altair/validator.md b/specs/altair/validator.md
index dbcc73486..3a96adb46 100644
--- a/specs/altair/validator.md
+++ b/specs/altair/validator.md
@@ -143,6 +143,10 @@ A validator determines beacon committee assignments and beacon block proposal du
 To determine sync committee assignments, a validator can run the following function: `is_assigned_to_sync_committee(state, epoch, validator_index)` where `epoch` is an epoch number within the current or next sync committee period.
 This function is a predicate indicating the presence or absence of the validator in the corresponding sync committee for the queried sync committee period.
 
+*Note*: Being assigned to a sync committee for a given `slot` means that the validator produces and broadcasts signatures for `slot - 1` for inclusion in `slot`.
+This means that when assigned to an `epoch` sync committee signatures must be produced and broadcast for slots on range `[compute_start_slot_at_epoch(epoch) - 1, compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH - 1)`
+rather than for the range `[compute_start_slot_at_epoch(epoch), compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH)`.
+
 ```python
 def compute_sync_committee_period(epoch: Epoch) -> uint64:
     return epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD
@@ -261,7 +265,7 @@ This process occurs each slot.
 
 ##### Prepare sync committee signature
 
-If a validator is in the current sync committee (i.e. `is_assigned_to_sync_committee()` above returns `True`), then for every slot in the current sync committee period, the validator should prepare a `SyncCommitteeSignature` according to the logic in `get_sync_committee_signature` as soon as they have determined the head block of the current slot.
+If a validator is in the current sync committee (i.e. `is_assigned_to_sync_committee()` above returns `True`), then for every `slot` in the current sync committee period, the validator should prepare a `SyncCommitteeSignature` for the previous slot (`slot - 1`) according to the logic in `get_sync_committee_signature` as soon as they have determined the head block of `slot - 1`.
 
 This logic is triggered upon the same conditions as when producing an attestation.
 Meaning, a sync committee member should produce and broadcast a `SyncCommitteeSignature` either when (a) the validator has received a valid block from the expected block proposer for the current `slot` or (b) one-third of the slot has transpired (`SECONDS_PER_SLOT / 3` seconds after the start of the slot) -- whichever comes first.

From d8e2d19ecc510df32ba3e86471e8c760f14dcb68 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 May 2021 13:01:31 -0600
Subject: [PATCH 21/43] spelling

---
 specs/altair/p2p-interface.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/altair/p2p-interface.md b/specs/altair/p2p-interface.md
index 02a159f7a..df2955f13 100644
--- a/specs/altair/p2p-interface.md
+++ b/specs/altair/p2p-interface.md
@@ -107,7 +107,7 @@ The following validations MUST pass before forwarding the `signed_contribution_a
 ```python
 def get_sync_subcommittee_pubkeys(state: BeaconState, subcommittee_index: uint64) -> Sequence[BLSPubkey]:
     # Committees assigned to `slot` sign for `slot - 1`
-    # This creates the exceptional logic below when transitioning between sync comittee periods
+    # This creates the exceptional logic below when transitioning between sync committee periods
     next_slot_epoch = compute_epoch_at_slot(state.slot + 1)
     if compute_sync_committee_period(get_current_epoch(state)) == compute_sync_committee_period(next_slot_epoch):
         sync_committee = state.current_sync_committee

From 77d607a760865d9dd621da5b1f3e39dfe0e7161e Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 May 2021 13:24:14 -0600
Subject: [PATCH 22/43] fix test

---
 tests/core/pyspec/eth2spec/test/helpers/rewards.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/core/pyspec/eth2spec/test/helpers/rewards.py b/tests/core/pyspec/eth2spec/test/helpers/rewards.py
index f81c1fc2a..7cf0206b3 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/rewards.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/rewards.py
@@ -62,13 +62,13 @@ def run_deltas(spec, state):
 
     if is_post_altair(spec):
         def get_source_deltas(state):
-            return spec.get_flag_index_deltas(state, spec.TIMELY_SOURCE_FLAG_INDEX, spec.TIMELY_SOURCE_WEIGHT)
+            return spec.get_flag_index_deltas(state, spec.TIMELY_SOURCE_FLAG_INDEX)
 
         def get_head_deltas(state):
-            return spec.get_flag_index_deltas(state, spec.TIMELY_HEAD_FLAG_INDEX, spec.TIMELY_HEAD_WEIGHT)
+            return spec.get_flag_index_deltas(state, spec.TIMELY_HEAD_FLAG_INDEX)
 
         def get_target_deltas(state):
-            return spec.get_flag_index_deltas(state, spec.TIMELY_TARGET_FLAG_INDEX, spec.TIMELY_TARGET_WEIGHT)
+            return spec.get_flag_index_deltas(state, spec.TIMELY_TARGET_FLAG_INDEX)
 
     yield from run_attestation_component_deltas(
         spec,
@@ -228,7 +228,7 @@ def run_get_inactivity_penalty_deltas(spec, state):
             else:
                 base_penalty = sum(
                     base_reward * numerator // spec.WEIGHT_DENOMINATOR
-                    for (_, numerator) in spec.get_flag_indices_and_weights()
+                    for (_, numerator) in spec.PARTICIPATION_FLAG_WEIGHTS
                 )
 
             if not has_enough_for_reward(spec, state, index):

From 85198fabfa15d01832484a8e5f4386bbe2964967 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 May 2021 13:26:43 -0600
Subject: [PATCH 23/43] lint

---
 specs/altair/p2p-interface.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/altair/p2p-interface.md b/specs/altair/p2p-interface.md
index df2955f13..6f250b57e 100644
--- a/specs/altair/p2p-interface.md
+++ b/specs/altair/p2p-interface.md
@@ -108,7 +108,7 @@ The following validations MUST pass before forwarding the `signed_contribution_a
 def get_sync_subcommittee_pubkeys(state: BeaconState, subcommittee_index: uint64) -> Sequence[BLSPubkey]:
     # Committees assigned to `slot` sign for `slot - 1`
     # This creates the exceptional logic below when transitioning between sync committee periods
-    next_slot_epoch = compute_epoch_at_slot(state.slot + 1)
+    next_slot_epoch = compute_epoch_at_slot(Slot(state.slot + 1))
     if compute_sync_committee_period(get_current_epoch(state)) == compute_sync_committee_period(next_slot_epoch):
         sync_committee = state.current_sync_committee
     else:

From a6b8574962dc03f6f36b56a744f3542e97ffeed8 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Mon, 10 May 2021 13:38:45 -0600
Subject: [PATCH 24/43] test

---
 specs/altair/beacon-chain.md                  |  3 +-
 .../pyspec/eth2spec/test/helpers/rewards.py   | 28 ++++++++++++-------
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 265bbfa53..90b878cc1 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -366,11 +366,10 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
     unslashed_participating_balance = get_total_balance(state, unslashed_participating_indices)
     unslashed_participating_increments = unslashed_participating_balance // EFFECTIVE_BALANCE_INCREMENT
     active_increments = get_total_active_balance(state) // EFFECTIVE_BALANCE_INCREMENT
-    in_inactivity_leak = is_in_inactivity_leak(state)
     for index in get_eligible_validator_indices(state):
         base_reward = get_base_reward(state, index)
         if index in unslashed_participating_indices:
-            if not in_inactivity_leak:
+            if not is_in_inactivity_leak(state):
                 reward_numerator = base_reward * weight * unslashed_participating_increments
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
         else:
diff --git a/tests/core/pyspec/eth2spec/test/helpers/rewards.py b/tests/core/pyspec/eth2spec/test/helpers/rewards.py
index 7cf0206b3..eb47dac98 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/rewards.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/rewards.py
@@ -133,10 +133,17 @@ def run_attestation_component_deltas(spec, state, component_delta_fn, matching_a
         validator = state.validators[index]
         enough_for_reward = has_enough_for_reward(spec, state, index)
         if index in matching_indices and not validator.slashed:
-            if enough_for_reward:
-                assert rewards[index] > 0
+            if is_post_altair(spec):
+                if not spec.is_in_inactivity_leak(state) and enough_for_reward:
+                    assert rewards[index] > 0
+                else:
+                    assert rewards[index] == 0
             else:
-                assert rewards[index] == 0
+                if enough_for_reward:
+                    assert rewards[index] > 0
+                else:
+                    assert rewards[index] == 0
+
             assert penalties[index] == 0
         else:
             assert rewards[index] == 0
@@ -225,18 +232,19 @@ def run_get_inactivity_penalty_deltas(spec, state):
             if not is_post_altair(spec):
                 cancel_base_rewards_per_epoch = spec.BASE_REWARDS_PER_EPOCH
                 base_penalty = cancel_base_rewards_per_epoch * base_reward - spec.get_proposer_reward(state, index)
-            else:
-                base_penalty = sum(
-                    base_reward * numerator // spec.WEIGHT_DENOMINATOR
-                    for (_, numerator) in spec.PARTICIPATION_FLAG_WEIGHTS
-                )
 
             if not has_enough_for_reward(spec, state, index):
                 assert penalties[index] == 0
             elif index in matching_attesting_indices or not has_enough_for_leak_penalty(spec, state, index):
-                assert penalties[index] == base_penalty
+                if is_post_altair(spec):
+                    assert penalties[index] == 0
+                else:
+                    assert penalties[index] == base_penalty
             else:
-                assert penalties[index] > base_penalty
+                if is_post_altair(spec):
+                    assert penalties[index] > 0
+                else:
+                    assert penalties[index] > base_penalty
         else:
             assert penalties[index] == 0
 

From 3c609e02eac16e060ec3934cbe1807c5a2b7e5cf Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 May 2021 07:28:24 -0600
Subject: [PATCH 25/43] pr feedback

---
 specs/altair/validator.md | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/specs/altair/validator.md b/specs/altair/validator.md
index 3a96adb46..92e3a75c0 100644
--- a/specs/altair/validator.md
+++ b/specs/altair/validator.md
@@ -146,6 +146,7 @@ This function is a predicate indicating the presence or absence of the validator
 *Note*: Being assigned to a sync committee for a given `slot` means that the validator produces and broadcasts signatures for `slot - 1` for inclusion in `slot`.
 This means that when assigned to an `epoch` sync committee signatures must be produced and broadcast for slots on range `[compute_start_slot_at_epoch(epoch) - 1, compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH - 1)`
 rather than for the range `[compute_start_slot_at_epoch(epoch), compute_start_slot_at_epoch(epoch) + SLOTS_PER_EPOCH)`.
+To reduce complexity during the Altair fork, sync committees are not expected to produce signatures for `compute_epoch_at_slot(ALTAIR_FORK_EPOCH) - 1`.
 
 ```python
 def compute_sync_committee_period(epoch: Epoch) -> uint64:
@@ -296,11 +297,14 @@ The `subnet_id` is derived from the position in the sync committee such that the
 
 ```python
 def compute_subnets_for_sync_committee(state: BeaconState, validator_index: ValidatorIndex) -> Sequence[uint64]:
+    next_slot_epoch = compute_epoch_at_slot(Slot(state.slot + 1))
+    if compute_sync_committee_period(get_current_epoch(state)) == compute_sync_committee_period(next_slot_epoch):
+        sync_committee = state.current_sync_committee
+    else:
+        sync_committee = state.next_sync_committee
+
     target_pubkey = state.validators[validator_index].pubkey
-    sync_committee_indices = [
-        index for index, pubkey in enumerate(state.current_sync_committee.pubkeys)
-        if pubkey == target_pubkey
-    ]
+    sync_committee_indices = [index for index, pubkey in enumerate(sync_committee.pubkeys) if pubkey == target_pubkey]
     return [
         uint64(index // (SYNC_COMMITTEE_SIZE // SYNC_COMMITTEE_SUBNET_COUNT))
         for index in sync_committee_indices

From 488ceed4f9de63898d8ebc490d6b044b5a27fec4 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 May 2021 11:29:37 -0600
Subject: [PATCH 26/43] add notes about repeatedly failing tos erve blocks as
 being disconncetable

---
 specs/phase0/p2p-interface.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index a0bd2d4e2..f2c7d8610 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -752,18 +752,20 @@ Clients MUST keep a record of signed blocks seen on the epoch range
 where `current_epoch` is defined by the current wall-clock time,
 and clients MUST support serving requests of blocks on this range.
 
-Synced clients unable to reply to Block requests within the
+Peers are *repeatedly* unable to reply to Block requests within the
 `MIN_EPOCHS_FOR_BLOCK_REQUESTS` epoch range MAY get descored or disconnected at any time.
-Note, due to this it is risky behaviour to begin participating as a full node at the head if having
-not yet backfilled on this range.
 
 *Note*: The above requirement implies that nodes that start from a recent weak subjectivity checkpoint
 MUST backfill the local block database to at least epoch `current_epoch - MIN_EPOCHS_FOR_BLOCK_REQUESTS`
-to be compliant with `BlocksByRange` requests. To safely perform such a
+to be fully compliant with `BlocksByRange` requests. To safely perform such a
 backfill of blocks to the recent state, the node MUST validate both (1) the
 proposer signatures and (2) that the blocks form a valid chain up to the most
 recent block referenced in the weak subjectivity state.
 
+*Note*: Although clients that bootstrap from a weak subjectivity checkpoint can begin
+participating in the networking immediately, other peers that are actively block syncing MAY
+disconnect and/or temporarily ban such an un-synced or semi-synced client.
+
 Clients MUST respond with at least the first block that exists in the range, if they have it,
 and no more than `MAX_REQUEST_BLOCKS` blocks.
 

From a9cc036184dedde472e22a3ae9ba45db7a094695 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 May 2021 11:48:26 -0600
Subject: [PATCH 27/43] remove timely_head penalty

---
 specs/altair/beacon-chain.md                       | 2 +-
 tests/core/pyspec/eth2spec/test/helpers/rewards.py | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 90b878cc1..57fec33df 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -372,7 +372,7 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
             if not is_in_inactivity_leak(state):
                 reward_numerator = base_reward * weight * unslashed_participating_increments
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
-        else:
+        elif not flag_index == TIMELY_HEAD_FLAG_INDEX:
             penalties[index] += Gwei(base_reward * weight // WEIGHT_DENOMINATOR)
     return rewards, penalties
 ```
diff --git a/tests/core/pyspec/eth2spec/test/helpers/rewards.py b/tests/core/pyspec/eth2spec/test/helpers/rewards.py
index eb47dac98..f563c70a2 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/rewards.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/rewards.py
@@ -147,7 +147,9 @@ def run_attestation_component_deltas(spec, state, component_delta_fn, matching_a
             assert penalties[index] == 0
         else:
             assert rewards[index] == 0
-            if enough_for_reward:
+            if is_post_altair(spec) and 'head' in deltas_name:
+                assert penalties[index] == 0
+            elif enough_for_reward:
                 assert penalties[index] > 0
             else:
                 assert penalties[index] == 0

From f328f77e653ad95b552e59517fa7990106044677 Mon Sep 17 00:00:00 2001
From: Alex Stokes <r.alex.stokes@gmail.com>
Date: Tue, 11 May 2021 10:58:45 -0700
Subject: [PATCH 28/43] clarify fork upgrade conditions

---
 specs/altair/fork.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/specs/altair/fork.md b/specs/altair/fork.md
index be562b82b..d789e7a8e 100644
--- a/specs/altair/fork.md
+++ b/specs/altair/fork.md
@@ -38,7 +38,11 @@ Note that for the pure Altair networks, we don't apply `upgrade_to_altair` since
 
 ### Upgrading the state
 
-After `process_slots` of Phase 0 finishes, if `state.slot % SLOTS_PER_EPOCH == 0` and `compute_epoch_at_slot(state.slot) == ALTAIR_FORK_EPOCH`, an irregular state change is made to upgrade to Altair.
+If `state.slot % SLOTS_PER_EPOCH == 0` and `compute_epoch_at_slot(state.slot) == ALTAIR_FORK_EPOCH`, an irregular state change is made to upgrade to Altair.
+
+The upgrade occurs after the inner loop of `process_slots` that sets `state.slot` equal to `ALTAIR_FORK_EPOCH * SLOTS_PER_EPOCH` finishes.
+Care must be taken when transitioning through the fork boundary as implementations will need a modified state transition function that deviates from the Phase 0 spec.
+In particular, the `state_transition` function defined in the Phase 0 spec will not expose the correct time to execute the upgrade in the presence of skipped slots at the fork boundary.
 
 ```python
 def upgrade_to_altair(pre: phase0.BeaconState) -> BeaconState:

From 859a7d743e48b2ac24b43f084af847801fc4e1ce Mon Sep 17 00:00:00 2001
From: Alex Stokes <r.alex.stokes@gmail.com>
Date: Tue, 11 May 2021 11:18:03 -0700
Subject: [PATCH 29/43] Only allow sync committee period calculation at period
 boundaries

---
 specs/altair/beacon-chain.md                  | 12 +++---
 specs/altair/fork.md                          |  6 ++-
 .../test_process_sync_committee.py            | 41 -------------------
 .../test_process_sync_committee_updates.py    |  3 +-
 .../test/altair/sanity/test_blocks.py         |  3 +-
 .../altair/unittests/test_sync_protocol.py    |  9 ++--
 6 files changed, 18 insertions(+), 56 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 34a33469e..fac8b3064 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -276,16 +276,14 @@ def has_flag(flags: ParticipationFlags, flag_index: int) -> bool:
 def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[ValidatorIndex]:
     """
     Return the sequence of sync committee indices (which may include duplicate indices)
-    for a given ``state`` and ``epoch``.
-
-    Note: This function is not stable during a sync committee period as
-    a validator's effective balance may change enough to affect the sampling.
+    for a given ``state`` and ``epoch`` at a sync committee period boundary.
     """
+    assert epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0
+
     MAX_RANDOM_BYTE = 2**8 - 1
-    base_epoch = Epoch((max(epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD, 1) - 1) * EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
-    active_validator_indices = get_active_validator_indices(state, base_epoch)
+    active_validator_indices = get_active_validator_indices(state, epoch)
     active_validator_count = uint64(len(active_validator_indices))
-    seed = get_seed(state, base_epoch, DOMAIN_SYNC_COMMITTEE)
+    seed = get_seed(state, epoch, DOMAIN_SYNC_COMMITTEE)
     i = 0
     sync_committee_indices: List[ValidatorIndex] = []
     while len(sync_committee_indices) < SYNC_COMMITTEE_SIZE:
diff --git a/specs/altair/fork.md b/specs/altair/fork.md
index be562b82b..4498749d3 100644
--- a/specs/altair/fork.md
+++ b/specs/altair/fork.md
@@ -81,7 +81,9 @@ def upgrade_to_altair(pre: phase0.BeaconState) -> BeaconState:
         inactivity_scores=[uint64(0) for _ in range(len(pre.validators))],
     )
     # Fill in sync committees
-    post.current_sync_committee = get_sync_committee(post, get_current_epoch(post))
-    post.next_sync_committee = get_sync_committee(post, get_current_epoch(post) + EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
+    current_period = epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+    base_epoch = current_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+    post.current_sync_committee = get_sync_committee(post, base_epoch)
+    post.next_sync_committee = get_sync_committee(post, base_epoch + EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
     return post
 ```
diff --git a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
index 2e5d62d11..834f51956 100644
--- a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
+++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
@@ -7,7 +7,6 @@ from eth2spec.test.helpers.block_processing import run_block_processing_to
 from eth2spec.test.helpers.state import (
     state_transition_and_sign_block,
     transition_to,
-    next_epoch,
 )
 from eth2spec.test.helpers.constants import (
     MAINNET, MINIMAL,
@@ -367,43 +366,3 @@ def test_valid_signature_future_committee(spec, state):
     )
 
     yield from run_sync_committee_processing(spec, state, block)
-
-
-@with_altair_and_later
-@spec_state_test
-def test_sync_committee_is_only_computed_at_epoch_boundary(spec, state):
-    """
-    Sync committees can only be computed at sync committee period boundaries.
-    Ensure a client respects the committee in the state (assumed to be derived
-    in the correct way).
-    """
-    current_epoch = spec.get_current_epoch(state)
-
-    # use a "synthetic" committee to simulate the situation
-    # where ``spec.get_sync_committee`` at the sync committee
-    # period epoch boundary would have diverged some epochs into the
-    # period; ``aggregate_pubkey`` is not relevant to this test
-    pubkeys = []
-    committee_indices = []
-    i = 0
-    active_validator_count = len(spec.get_active_validator_indices(state, current_epoch))
-    while len(pubkeys) < spec.SYNC_COMMITTEE_SIZE:
-        v = state.validators[i % active_validator_count]
-        if spec.is_active_validator(v, current_epoch):
-            pubkeys.append(v.pubkey)
-            committee_indices.append(i)
-        i += 1
-
-    synthetic_committee = spec.SyncCommittee(pubkeys=pubkeys, aggregate_pubkey=spec.BLSPubkey())
-    state.current_sync_committee = synthetic_committee
-
-    assert spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD > 3
-    for _ in range(3):
-        next_epoch(spec, state)
-
-    committee = get_committee_indices(spec, state)
-    assert committee != committee_indices
-    committee_size = len(committee_indices)
-    committee_bits = [True] * committee_size
-
-    yield from run_successful_sync_committee_test(spec, state, committee_indices, committee_bits)
diff --git a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
index c909c791c..2910145c9 100644
--- a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
+++ b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
@@ -39,8 +39,7 @@ def run_sync_committees_progress_test(spec, state):
 
     # Can compute the third committee having computed final balances in the last epoch
     # of this `EPOCHS_PER_SYNC_COMMITTEE_PERIOD`
-    current_epoch = spec.get_current_epoch(state)
-    third_sync_committee = spec.get_sync_committee(state, current_epoch + 2 * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
+    third_sync_committee = spec.get_sync_committee(state, (next_period + 1) * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
 
     assert state.current_sync_committee == second_sync_committee
     assert state.next_sync_committee == third_sync_committee
diff --git a/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py b/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py
index ffe743531..407455a0a 100644
--- a/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py
+++ b/tests/core/pyspec/eth2spec/test/altair/sanity/test_blocks.py
@@ -18,7 +18,8 @@ from eth2spec.test.context import (
 
 
 def run_sync_committee_sanity_test(spec, state, fraction_full=1.0):
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    all_pubkeys = [v.pubkey for v in state.validators]
+    committee = [all_pubkeys.index(pubkey) for pubkey in state.current_sync_committee.pubkeys]
     participants = random.sample(committee, int(len(committee) * fraction_full))
 
     yield 'pre', state
diff --git a/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py b/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py
index 932a46ca5..554cebda8 100644
--- a/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py
+++ b/tests/core/pyspec/eth2spec/test/altair/unittests/test_sync_protocol.py
@@ -46,7 +46,8 @@ def test_process_light_client_update_not_updated(spec, state):
         body_root=signed_block.message.body.hash_tree_root(),
     )
     # Sync committee signing the header
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    all_pubkeys = [v.pubkey for v in state.validators]
+    committee = [all_pubkeys.index(pubkey) for pubkey in state.current_sync_committee.pubkeys]
     sync_committee_bits = [True] * len(committee)
     sync_committee_signature = compute_aggregate_sync_committee_signature(
         spec,
@@ -111,7 +112,8 @@ def test_process_light_client_update_timeout(spec, state):
     )
 
     # Sync committee signing the finalized_block_header
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    all_pubkeys = [v.pubkey for v in state.validators]
+    committee = [all_pubkeys.index(pubkey) for pubkey in state.current_sync_committee.pubkeys]
     sync_committee_bits = [True] * len(committee)
     sync_committee_signature = compute_aggregate_sync_committee_signature(
         spec,
@@ -190,7 +192,8 @@ def test_process_light_client_update_finality_updated(spec, state):
     )
 
     # Sync committee signing the finalized_block_header
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    all_pubkeys = [v.pubkey for v in state.validators]
+    committee = [all_pubkeys.index(pubkey) for pubkey in state.current_sync_committee.pubkeys]
     sync_committee_bits = [True] * len(committee)
     sync_committee_signature = compute_aggregate_sync_committee_signature(
         spec,

From 43ba615b7579ff1ac2e616ed1dd12cccec14118f Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 May 2021 14:13:22 -0600
Subject: [PATCH 30/43] Apply suggestions from code review

---
 specs/altair/fork.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/specs/altair/fork.md b/specs/altair/fork.md
index d789e7a8e..ac2258def 100644
--- a/specs/altair/fork.md
+++ b/specs/altair/fork.md
@@ -40,9 +40,9 @@ Note that for the pure Altair networks, we don't apply `upgrade_to_altair` since
 
 If `state.slot % SLOTS_PER_EPOCH == 0` and `compute_epoch_at_slot(state.slot) == ALTAIR_FORK_EPOCH`, an irregular state change is made to upgrade to Altair.
 
-The upgrade occurs after the inner loop of `process_slots` that sets `state.slot` equal to `ALTAIR_FORK_EPOCH * SLOTS_PER_EPOCH` finishes.
+The upgrade occurs after the completion of the inner loop of `process_slots` that sets `state.slot` equal to `ALTAIR_FORK_EPOCH * SLOTS_PER_EPOCH`.
 Care must be taken when transitioning through the fork boundary as implementations will need a modified state transition function that deviates from the Phase 0 spec.
-In particular, the `state_transition` function defined in the Phase 0 spec will not expose the correct time to execute the upgrade in the presence of skipped slots at the fork boundary.
+In particular, the outer `state_transition` function defined in the Phase 0 spec will not expose the precise fork slot to execute the upgrade in the presence of skipped slots at the fork boundary. Instead the logic must be within `process_slots`.
 
 ```python
 def upgrade_to_altair(pre: phase0.BeaconState) -> BeaconState:

From 274788277636b0e0e319dcacbcd9a03bad21a1ca Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 May 2021 15:18:18 -0600
Subject: [PATCH 31/43] use current_Epoch seed when calculating
 next_sync_committee

---
 specs/altair/beacon-chain.md |  4 ++--
 specs/altair/fork.md         | 10 ++++++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 34a33469e..aa1509460 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -304,7 +304,7 @@ def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[Val
 ```python
 def get_sync_committee(state: BeaconState, epoch: Epoch) -> SyncCommittee:
     """
-    Return the sync committee for a given ``state`` and ``epoch``.
+    Return the *next* sync committee for a given ``state`` and ``epoch``.
 
     ``SyncCommittee`` contains an aggregate pubkey that enables
     resource-constrained clients to save some computation when verifying
@@ -690,7 +690,7 @@ def process_sync_committee_updates(state: BeaconState) -> None:
     next_epoch = get_current_epoch(state) + Epoch(1)
     if next_epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0:
         state.current_sync_committee = state.next_sync_committee
-        state.next_sync_committee = get_sync_committee(state, next_epoch + EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
+        state.next_sync_committee = get_sync_committee(state, next_epoch)
 ```
 
 ## Initialize state for pure Altair testnets and test vectors
diff --git a/specs/altair/fork.md b/specs/altair/fork.md
index be562b82b..dcd319745 100644
--- a/specs/altair/fork.md
+++ b/specs/altair/fork.md
@@ -80,8 +80,14 @@ def upgrade_to_altair(pre: phase0.BeaconState) -> BeaconState:
         # Inactivity
         inactivity_scores=[uint64(0) for _ in range(len(pre.validators))],
     )
+
     # Fill in sync committees
-    post.current_sync_committee = get_sync_committee(post, get_current_epoch(post))
-    post.next_sync_committee = get_sync_committee(post, get_current_epoch(post) + EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
+    current_period = epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+    previous_period = current_period - min(1, current_period)
+    current_base_epoch = current_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+    previous_base_epoch = previous_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+
+    post.current_sync_committee = get_sync_committee(post, previous_base_epoch)
+    post.next_sync_committee = get_sync_committee(post, current_base_epoch)
     return post
 ```

From 200c049778ade1d28064cb837c8ebdd6ca2356fa Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 May 2021 15:55:33 -0600
Subject: [PATCH 32/43] fix seed calc issue

---
 specs/altair/beacon-chain.md                    | 17 ++++++++++++-----
 .../test_process_sync_committee.py              |  6 +++---
 .../test_process_sync_committee_updates.py      |  2 +-
 .../pyspec/eth2spec/test/helpers/genesis.py     | 11 +++++++----
 4 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index aa1509460..a69412c31 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -281,11 +281,12 @@ def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[Val
     Note: This function is not stable during a sync committee period as
     a validator's effective balance may change enough to affect the sampling.
     """
+    assert epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0
+
     MAX_RANDOM_BYTE = 2**8 - 1
-    base_epoch = Epoch((max(epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD, 1) - 1) * EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
-    active_validator_indices = get_active_validator_indices(state, base_epoch)
+    active_validator_indices = get_active_validator_indices(state, epoch)
     active_validator_count = uint64(len(active_validator_indices))
-    seed = get_seed(state, base_epoch, DOMAIN_SYNC_COMMITTEE)
+    seed = get_seed(state, epoch, DOMAIN_SYNC_COMMITTEE)
     i = 0
     sync_committee_indices: List[ValidatorIndex] = []
     while len(sync_committee_indices) < SYNC_COMMITTEE_SIZE:
@@ -689,6 +690,7 @@ def process_participation_flag_updates(state: BeaconState) -> None:
 def process_sync_committee_updates(state: BeaconState) -> None:
     next_epoch = get_current_epoch(state) + Epoch(1)
     if next_epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0:
+        print("HEEEREEE")
         state.current_sync_committee = state.next_sync_committee
         state.next_sync_committee = get_sync_committee(state, next_epoch)
 ```
@@ -735,8 +737,13 @@ def initialize_beacon_state_from_eth1(eth1_block_hash: Bytes32,
     state.genesis_validators_root = hash_tree_root(state.validators)
 
     # [New in Altair] Fill in sync committees
-    state.current_sync_committee = get_sync_committee(state, get_current_epoch(state))
-    state.next_sync_committee = get_sync_committee(state, get_current_epoch(state) + EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
+    current_period = get_current_epoch(state) // EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+    previous_period = current_period - min(1, current_period)
+    current_base_epoch = current_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+    previous_base_epoch = previous_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+
+    state.current_sync_committee = get_sync_committee(state, previous_base_epoch)
+    state.next_sync_committee = get_sync_committee(state, current_base_epoch)
 
     return state
 ```
diff --git a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
index 2e5d62d11..48e556f50 100644
--- a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
+++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
@@ -345,10 +345,10 @@ def test_valid_signature_future_committee(spec, state):
     transition_to(spec, state, slot_in_future_sync_committee_period)
 
     sync_committee = state.current_sync_committee
+    next_sync_committee = state.next_sync_committee
+    expected_next_sync_committee = spec.get_sync_committee(state, epoch_in_future_sync_committee_period)
 
-    expected_sync_committee = spec.get_sync_committee(state, epoch_in_future_sync_committee_period)
-
-    assert sync_committee == expected_sync_committee
+    assert next_sync_committee == expected_next_sync_committee
     assert sync_committee != old_current_sync_committee
     assert sync_committee != old_next_sync_committee
 
diff --git a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
index c909c791c..ca25797c4 100644
--- a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
+++ b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
@@ -40,7 +40,7 @@ def run_sync_committees_progress_test(spec, state):
     # Can compute the third committee having computed final balances in the last epoch
     # of this `EPOCHS_PER_SYNC_COMMITTEE_PERIOD`
     current_epoch = spec.get_current_epoch(state)
-    third_sync_committee = spec.get_sync_committee(state, current_epoch + 2 * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
+    third_sync_committee = spec.get_sync_committee(state, current_epoch + 1)
 
     assert state.current_sync_committee == second_sync_committee
     assert state.next_sync_committee == third_sync_committee
diff --git a/tests/core/pyspec/eth2spec/test/helpers/genesis.py b/tests/core/pyspec/eth2spec/test/helpers/genesis.py
index 4a34a5eb3..23cd04c93 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/genesis.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/genesis.py
@@ -69,9 +69,12 @@ def create_genesis_state(spec, validator_balances, activation_threshold):
 
     if spec.fork not in FORKS_BEFORE_ALTAIR:
         # Fill in sync committees
-        state.current_sync_committee = spec.get_sync_committee(state, spec.get_current_epoch(state))
-        state.next_sync_committee = (
-            spec.get_sync_committee(state, spec.get_current_epoch(state) + spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
-        )
+        current_period = spec.get_current_epoch(state) // spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+        previous_period = current_period - min(1, current_period)
+        current_base_epoch = current_period * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+        previous_base_epoch = previous_period * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD
+
+        state.current_sync_committee = spec.get_sync_committee(state, previous_base_epoch)
+        state.next_sync_committee = spec.get_sync_committee(state, current_base_epoch)
 
     return state

From 09cefa03f3895c2a319ee03bc06c66a6b8d5e11b Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Tue, 11 May 2021 16:07:24 -0600
Subject: [PATCH 33/43] remov sync signature todo

---
 specs/altair/beacon-chain.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 57fec33df..6d97c14b5 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -203,7 +203,6 @@ class BeaconState(Container):
 ```python
 class SyncAggregate(Container):
     sync_committee_bits: Bitvector[SYNC_COMMITTEE_SIZE]
-    # TODO! Need multiple signatures as discussed between Justin and Vitalik May 3 2021 (see Telegram)
     sync_committee_signature: BLSSignature
 ```
 

From dad698f97aec8f6e80ecc74d093e050b9ae72163 Mon Sep 17 00:00:00 2001
From: Hsiao-Wei Wang <hsiaowei.eth@gmail.com>
Date: Wed, 12 May 2021 12:35:47 +0800
Subject: [PATCH 34/43] Update unit tests: add
 `test_compute_subnets_for_sync_committee_slot_period_boundary`

---
 .../unittests/validator/test_validator.py     | 49 +++++++++++++++++--
 1 file changed, 45 insertions(+), 4 deletions(-)

diff --git a/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py b/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py
index c8a894da6..fd1b82c4b 100644
--- a/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py
+++ b/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py
@@ -143,20 +143,61 @@ def _subnet_for_sync_committee_index(spec, i):
     return i // (spec.SYNC_COMMITTEE_SIZE // spec.SYNC_COMMITTEE_SUBNET_COUNT)
 
 
+def _get_expected_subnets_by_pubkey(sync_committee_members):
+    expected_subnets_by_pubkey = defaultdict(list)
+    for (subnet, pubkey) in sync_committee_members:
+        expected_subnets_by_pubkey[pubkey].append(subnet)
+    return expected_subnets_by_pubkey
+
+
 @with_altair_and_later
 @with_state
 def test_compute_subnets_for_sync_committee(state, spec, phases):
+    # Transition to the head of the next period
+    transition_to(spec, state, spec.SLOTS_PER_EPOCH * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD)
+
+    next_slot_epoch = spec.compute_epoch_at_slot(state.slot + 1)
+    assert (
+        spec.compute_sync_committee_period(spec.get_current_epoch(state))
+        == spec.compute_sync_committee_period(next_slot_epoch)
+    )
     some_sync_committee_members = list(
         (
             _subnet_for_sync_committee_index(spec, i),
             pubkey,
         )
+        # use current_sync_committee
         for i, pubkey in enumerate(state.current_sync_committee.pubkeys)
     )
-
-    expected_subnets_by_pubkey = defaultdict(list)
-    for (subnet, pubkey) in some_sync_committee_members:
-        expected_subnets_by_pubkey[pubkey].append(subnet)
+    expected_subnets_by_pubkey = _get_expected_subnets_by_pubkey(some_sync_committee_members)
+
+    for _, pubkey in some_sync_committee_members:
+        validator_index = _validator_index_for_pubkey(state, pubkey)
+        subnets = spec.compute_subnets_for_sync_committee(state, validator_index)
+        expected_subnets = expected_subnets_by_pubkey[pubkey]
+        assert subnets == expected_subnets
+
+
+@with_altair_and_later
+@with_state
+def test_compute_subnets_for_sync_committee_slot_period_boundary(state, spec, phases):
+    # Transition to the end of the period
+    transition_to(spec, state, spec.SLOTS_PER_EPOCH * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD - 1)
+
+    next_slot_epoch = spec.compute_epoch_at_slot(state.slot + 1)
+    assert (
+        spec.compute_sync_committee_period(spec.get_current_epoch(state))
+        != spec.compute_sync_committee_period(next_slot_epoch)
+    )
+    some_sync_committee_members = list(
+        (
+            _subnet_for_sync_committee_index(spec, i),
+            pubkey,
+        )
+        # use next_sync_committee
+        for i, pubkey in enumerate(state.next_sync_committee.pubkeys)
+    )
+    expected_subnets_by_pubkey = _get_expected_subnets_by_pubkey(some_sync_committee_members)
 
     for _, pubkey in some_sync_committee_members:
         validator_index = _validator_index_for_pubkey(state, pubkey)

From 17820e371165c4f6ee56163e20cff7da36ba1033 Mon Sep 17 00:00:00 2001
From: Hsiao-Wei Wang <hsiaowei.eth@gmail.com>
Date: Wed, 12 May 2021 13:02:15 +0800
Subject: [PATCH 35/43] Skip the mainnet config slow tests

---
 .../test/altair/unittests/validator/test_validator.py      | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py b/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py
index fd1b82c4b..cefaaf694 100644
--- a/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py
+++ b/tests/core/pyspec/eth2spec/test/altair/unittests/validator/test_validator.py
@@ -8,8 +8,12 @@ from eth2spec.utils import bls
 from eth2spec.utils.bls import only_with_bls
 from eth2spec.test.context import (
     with_altair_and_later,
+    with_configs,
     with_state,
 )
+from eth2spec.test.helpers.constants import (
+    MINIMAL,
+)
 
 rng = random.Random(1337)
 
@@ -91,6 +95,7 @@ def _get_sync_committee_signature(
 
 @only_with_bls()
 @with_altair_and_later
+@with_configs([MINIMAL], reason="too slow")
 @with_state
 def test_process_sync_committee_contributions(phases, spec, state):
     # skip over slots at genesis
@@ -151,6 +156,7 @@ def _get_expected_subnets_by_pubkey(sync_committee_members):
 
 
 @with_altair_and_later
+@with_configs([MINIMAL], reason="too slow")
 @with_state
 def test_compute_subnets_for_sync_committee(state, spec, phases):
     # Transition to the head of the next period
@@ -179,6 +185,7 @@ def test_compute_subnets_for_sync_committee(state, spec, phases):
 
 
 @with_altair_and_later
+@with_configs([MINIMAL], reason="too slow")
 @with_state
 def test_compute_subnets_for_sync_committee_slot_period_boundary(state, spec, phases):
     # Transition to the end of the period

From 8e07ece4927bbc3d7965b92b656abd7e09a73fc1 Mon Sep 17 00:00:00 2001
From: Hsiao-Wei Wang <hsiaowei.eth@gmail.com>
Date: Wed, 12 May 2021 14:04:49 +0800
Subject: [PATCH 36/43] Minor rephrase

---
 specs/altair/validator.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/specs/altair/validator.md b/specs/altair/validator.md
index 92e3a75c0..67e5914d1 100644
--- a/specs/altair/validator.md
+++ b/specs/altair/validator.md
@@ -271,7 +271,7 @@ If a validator is in the current sync committee (i.e. `is_assigned_to_sync_commi
 This logic is triggered upon the same conditions as when producing an attestation.
 Meaning, a sync committee member should produce and broadcast a `SyncCommitteeSignature` either when (a) the validator has received a valid block from the expected block proposer for the current `slot` or (b) one-third of the slot has transpired (`SECONDS_PER_SLOT / 3` seconds after the start of the slot) -- whichever comes first.
 
-`get_sync_committee_signature()` assumes `state` is the head state corresponding to processing the block up to the current slot as determined by the fork choice (including any empty slots up to the current slot processed with `process_slots` on top of the latest block), `block_root` is the root of the head block, `validator_index` is the index of the validator in the registry `state.validators` controlled by `privkey`, and `privkey` is the BLS private key for the validator.
+`get_sync_committee_signature(state, block_root, validator_index, privkey)` assumes the parameter `state` is the head state corresponding to processing the block up to the current slot as determined by the fork choice (including any empty slots up to the current slot processed with `process_slots` on top of the latest block), `block_root` is the root of the head block, `validator_index` is the index of the validator in the registry `state.validators` controlled by `privkey`, and `privkey` is the BLS private key for the validator.
 
 ```python
 def get_sync_committee_signature(state: BeaconState,
@@ -291,7 +291,7 @@ def get_sync_committee_signature(state: BeaconState,
 The validator broadcasts the assembled signature to the assigned subnet, the `sync_committee_{subnet_id}` pubsub topic.
 
 The `subnet_id` is derived from the position in the sync committee such that the sync committee is divided into "subcommittees".
-`subnet_id` can be computed via `compute_subnets_for_sync_committee()` where `state` is a `BeaconState` during the matching sync committee period.
+`subnet_id` can be computed via `compute_subnets_for_sync_committee(state, validator_index)` where `state` is a `BeaconState` during the matching sync committee period.
 
 *Note*: This function returns multiple subnets if a given validator index is included multiple times in a given sync committee across multiple subcommittees.
 

From 82b7a7be3b5cf6046ad046d4c499bb2721931bf2 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 May 2021 08:29:42 -0600
Subject: [PATCH 37/43] Apply suggestions from code review

Co-authored-by: Alex Stokes <r.alex.stokes@gmail.com>
Co-authored-by: Jacek Sieka <jacek@status.im>
---
 README.md                     | 2 +-
 specs/phase0/p2p-interface.md | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 8a340e9ad..b74102c30 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@ The current features are:
 * [Deposit Contract](specs/phase0/deposit-contract.md)
 * [Honest Validator](specs/phase0/validator.md)
 * [P2P Networking](specs/phase0/p2p-interface.md)
-* [Weak Subjectivity](specs/phase0/weak-subjectivity.md.md)
+* [Weak Subjectivity](specs/phase0/weak-subjectivity.md)
 
 ### Altair
 
diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index f2c7d8610..69ff7e120 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -752,7 +752,7 @@ Clients MUST keep a record of signed blocks seen on the epoch range
 where `current_epoch` is defined by the current wall-clock time,
 and clients MUST support serving requests of blocks on this range.
 
-Peers are *repeatedly* unable to reply to Block requests within the
+Peers that are unable to reply to block requests within the
 `MIN_EPOCHS_FOR_BLOCK_REQUESTS` epoch range MAY get descored or disconnected at any time.
 
 *Note*: The above requirement implies that nodes that start from a recent weak subjectivity checkpoint
@@ -763,7 +763,7 @@ proposer signatures and (2) that the blocks form a valid chain up to the most
 recent block referenced in the weak subjectivity state.
 
 *Note*: Although clients that bootstrap from a weak subjectivity checkpoint can begin
-participating in the networking immediately, other peers that are actively block syncing MAY
+participating in the networking immediately, other peers MAY
 disconnect and/or temporarily ban such an un-synced or semi-synced client.
 
 Clients MUST respond with at least the first block that exists in the range, if they have it,

From f52f067b8ea3f8adbebc936207b06459d1956e72 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 May 2021 08:36:27 -0600
Subject: [PATCH 38/43] add resourceunavailable error code

---
 specs/phase0/p2p-interface.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/specs/phase0/p2p-interface.md b/specs/phase0/p2p-interface.md
index 69ff7e120..297d93948 100644
--- a/specs/phase0/p2p-interface.md
+++ b/specs/phase0/p2p-interface.md
@@ -567,6 +567,8 @@ The response code can have one of the following values, encoded as a single unsi
   The response payload adheres to the `ErrorMessage` schema (described below).
 -  2: **ServerError** -- the responder encountered an error while processing the request.
   The response payload adheres to the `ErrorMessage` schema (described below).
+-  3: **ResourceUnavailable** -- the responder does not have requested resource.
+  The response payload adheres to the `ErrorMessage` schema (described below).
 
 Clients MAY use response codes above `128` to indicate alternative, erroneous request-specific responses.
 

From 6371707779791a687886f6f7c3b2d1ebd45ae345 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 May 2021 08:40:34 -0600
Subject: [PATCH 39/43] Apply suggestions from code review

Co-authored-by: Hsiao-Wei Wang <hsiaowei.eth@gmail.com>
---
 specs/altair/beacon-chain.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 6d97c14b5..9593d13a9 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -371,7 +371,7 @@ def get_flag_index_deltas(state: BeaconState, flag_index: int) -> Tuple[Sequence
             if not is_in_inactivity_leak(state):
                 reward_numerator = base_reward * weight * unslashed_participating_increments
                 rewards[index] += Gwei(reward_numerator // (active_increments * WEIGHT_DENOMINATOR))
-        elif not flag_index == TIMELY_HEAD_FLAG_INDEX:
+        elif flag_index != TIMELY_HEAD_FLAG_INDEX:
             penalties[index] += Gwei(base_reward * weight // WEIGHT_DENOMINATOR)
     return rewards, penalties
 ```

From a8791f04c7016fdbc6a577826ab193296392e2ad Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 May 2021 09:44:13 -0600
Subject: [PATCH 40/43] 'get_sync_committee -> get_next_sync_committee

---
 specs/altair/beacon-chain.md                  |  36 +++---
 specs/altair/fork.md                          |  10 +-
 .../test_process_sync_committee.py            | 119 ++++++++++--------
 .../pyspec/eth2spec/test/helpers/genesis.py   |  10 +-
 4 files changed, 88 insertions(+), 87 deletions(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 39e4a2371..367858340 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -32,8 +32,8 @@
     - [`add_flag`](#add_flag)
     - [`has_flag`](#has_flag)
   - [Beacon state accessors](#beacon-state-accessors)
-    - [`get_sync_committee_indices`](#get_sync_committee_indices)
-    - [`get_sync_committee`](#get_sync_committee)
+    - [`get_next_sync_committee_indices`](#get_next_sync_committee_indices)
+    - [`get_next_sync_committee`](#get_next_sync_committee)
     - [`get_base_reward_per_increment`](#get_base_reward_per_increment)
     - [`get_base_reward`](#get_base_reward)
     - [`get_unslashed_participating_indices`](#get_unslashed_participating_indices)
@@ -270,15 +270,15 @@ def has_flag(flags: ParticipationFlags, flag_index: int) -> bool:
 
 ### Beacon state accessors
 
-#### `get_sync_committee_indices`
+#### `get_next_sync_committee_indices`
 
 ```python
-def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[ValidatorIndex]:
+def get_next_sync_committee_indices(state: BeaconState) -> Sequence[ValidatorIndex]:
     """
     Return the sequence of sync committee indices (which may include duplicate indices)
-    for a given ``state`` and ``epoch`` at a sync committee period boundary.
+    for the next sync committee, given a ``state`` at a sync committee period boundary.
     """
-    assert epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0
+    epoch = Epoch(get_current_epoch(state) + 1)
 
     MAX_RANDOM_BYTE = 2**8 - 1
     active_validator_indices = get_active_validator_indices(state, epoch)
@@ -297,25 +297,25 @@ def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[Val
     return sync_committee_indices
 ```
 
-#### `get_sync_committee`
+#### `get_next_sync_committee`
 
 ```python
-def get_sync_committee(state: BeaconState, epoch: Epoch) -> SyncCommittee:
+def get_next_sync_committee(state: BeaconState) -> SyncCommittee:
     """
-    Return the *next* sync committee for a given ``state`` and ``epoch``.
+    Return the *next* sync committee for a given ``state``.
 
     ``SyncCommittee`` contains an aggregate pubkey that enables
     resource-constrained clients to save some computation when verifying
     the sync committee's signature.
 
-    ``SyncCommittee`` can also contain duplicate pubkeys, when ``get_sync_committee_indices``
+    ``SyncCommittee`` can also contain duplicate pubkeys, when ``get_next_sync_committee_indices``
     returns duplicate indices. Implementations must take care when handling
     optimizations relating to aggregation and verification in the presence of duplicates.
 
     Note: This function should only be called at sync committee period boundaries, as
-    ``get_sync_committee_indices`` is not stable within a given period.
+    ``get_next_sync_committee_indices`` is not stable within a given period.
     """
-    indices = get_sync_committee_indices(state, epoch)
+    indices = get_next_sync_committee_indices(state)
     pubkeys = [state.validators[index].pubkey for index in indices]
     aggregate_pubkey = bls.AggregatePKs(pubkeys)
     return SyncCommittee(pubkeys=pubkeys, aggregate_pubkey=aggregate_pubkey)
@@ -688,7 +688,7 @@ def process_sync_committee_updates(state: BeaconState) -> None:
     next_epoch = get_current_epoch(state) + Epoch(1)
     if next_epoch % EPOCHS_PER_SYNC_COMMITTEE_PERIOD == 0:
         state.current_sync_committee = state.next_sync_committee
-        state.next_sync_committee = get_sync_committee(state, next_epoch)
+        state.next_sync_committee = get_next_sync_committee(state)
 ```
 
 ## Initialize state for pure Altair testnets and test vectors
@@ -733,13 +733,9 @@ def initialize_beacon_state_from_eth1(eth1_block_hash: Bytes32,
     state.genesis_validators_root = hash_tree_root(state.validators)
 
     # [New in Altair] Fill in sync committees
-    current_period = get_current_epoch(state) // EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-    previous_period = current_period - min(1, current_period)
-    current_base_epoch = current_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-    previous_base_epoch = previous_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-
-    state.current_sync_committee = get_sync_committee(state, previous_base_epoch)
-    state.next_sync_committee = get_sync_committee(state, current_base_epoch)
+    # Note: A duplicate committee is assigned for the current and next committee at genesis
+    state.current_sync_committee = get_next_sync_committee(state)
+    state.next_sync_committee = get_next_sync_committee(state)
 
     return state
 ```
diff --git a/specs/altair/fork.md b/specs/altair/fork.md
index ea7af898f..2c8b9f855 100644
--- a/specs/altair/fork.md
+++ b/specs/altair/fork.md
@@ -86,12 +86,8 @@ def upgrade_to_altair(pre: phase0.BeaconState) -> BeaconState:
     )
 
     # Fill in sync committees
-    current_period = epoch // EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-    previous_period = current_period - min(1, current_period)
-    current_base_epoch = current_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-    previous_base_epoch = previous_period * EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-
-    post.current_sync_committee = get_sync_committee(post, previous_base_epoch)
-    post.next_sync_committee = get_sync_committee(post, current_base_epoch)
+    # Note: A duplicate committee is assigned for the current and next committee at the fork boundary
+    post.current_sync_committee = get_next_sync_committee(post)
+    post.next_sync_committee = get_next_sync_committee(post)
     return post
 ```
diff --git a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
index d80e650af..e3ee32a93 100644
--- a/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
+++ b/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_sync_committee.py
@@ -49,9 +49,9 @@ def get_committee_indices(spec, state, duplicates=False):
     """
     state = state.copy()
     current_epoch = spec.get_current_epoch(state)
-    randao_index = current_epoch % spec.EPOCHS_PER_HISTORICAL_VECTOR
+    randao_index = (current_epoch + 1) % spec.EPOCHS_PER_HISTORICAL_VECTOR
     while True:
-        committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+        committee = spec.get_next_sync_committee_indices(state)
         if duplicates:
             if len(committee) != len(set(committee)):
                 return committee
@@ -61,23 +61,32 @@ def get_committee_indices(spec, state, duplicates=False):
         state.randao_mixes[randao_index] = hash(state.randao_mixes[randao_index])
 
 
+def compute_committee_indices(spec, state, committee):
+    """
+    Given a ``committee``, calculate and return the related indices
+    """
+    all_pubkeys = [v.pubkey for v in state.validators]
+    committee_indices = [all_pubkeys.index(pubkey) for pubkey in committee.pubkeys]
+    return committee_indices
+
+
 @with_altair_and_later
 @spec_state_test
 @always_bls
 def test_invalid_signature_missing_participant(spec, state):
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    committee_indices = compute_committee_indices(spec, state, state.current_sync_committee)
     rng = random.Random(2020)
-    random_participant = rng.choice(committee)
+    random_participant = rng.choice(committee_indices)
 
     block = build_empty_block_for_next_slot(spec, state)
     # Exclude one participant whose signature was included.
     block.body.sync_aggregate = spec.SyncAggregate(
-        sync_committee_bits=[index != random_participant for index in committee],
+        sync_committee_bits=[index != random_participant for index in committee_indices],
         sync_committee_signature=compute_aggregate_sync_committee_signature(
             spec,
             state,
             block.slot - 1,
-            committee,  # full committee signs
+            committee_indices,  # full committee signs
         )
     )
     yield from run_sync_committee_processing(spec, state, block, expect_exception=True)
@@ -87,31 +96,38 @@ def test_invalid_signature_missing_participant(spec, state):
 @spec_state_test
 @always_bls
 def test_invalid_signature_extra_participant(spec, state):
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    committee_indices = compute_committee_indices(spec, state, state.current_sync_committee)
     rng = random.Random(3030)
-    random_participant = rng.choice(committee)
+    random_participant = rng.choice(committee_indices)
 
     block = build_empty_block_for_next_slot(spec, state)
     # Exclude one signature even though the block claims the entire committee participated.
     block.body.sync_aggregate = spec.SyncAggregate(
-        sync_committee_bits=[True] * len(committee),
+        sync_committee_bits=[True] * len(committee_indices),
         sync_committee_signature=compute_aggregate_sync_committee_signature(
             spec,
             state,
             block.slot - 1,
-            [index for index in committee if index != random_participant],
+            [index for index in committee_indices if index != random_participant],
         )
     )
 
     yield from run_sync_committee_processing(spec, state, block, expect_exception=True)
 
 
-def compute_sync_committee_inclusion_reward(spec, state, participant_index, committee, committee_bits):
+def compute_sync_committee_inclusion_reward(spec,
+                                            state,
+                                            participant_index,
+                                            committee_indices,
+                                            committee_bits):
     total_active_increments = spec.get_total_active_balance(state) // spec.EFFECTIVE_BALANCE_INCREMENT
     total_base_rewards = spec.Gwei(spec.get_base_reward_per_increment(state) * total_active_increments)
     max_epoch_rewards = spec.Gwei(total_base_rewards * spec.SYNC_REWARD_WEIGHT // spec.WEIGHT_DENOMINATOR)
-    included_indices = [index for index, bit in zip(committee, committee_bits) if bit]
-    max_slot_rewards = spec.Gwei(max_epoch_rewards * len(included_indices) // len(committee) // spec.SLOTS_PER_EPOCH)
+    included_indices = [index for index, bit in zip(committee_indices, committee_bits) if bit]
+    max_slot_rewards = spec.Gwei(
+        max_epoch_rewards * len(included_indices)
+        // len(committee_indices) // spec.SLOTS_PER_EPOCH
+    )
 
     # Compute the participant and proposer sync rewards
     committee_effective_balance = sum([state.validators[index].effective_balance for index in included_indices])
@@ -120,23 +136,23 @@ def compute_sync_committee_inclusion_reward(spec, state, participant_index, comm
     return spec.Gwei(max_slot_rewards * effective_balance // committee_effective_balance)
 
 
-def compute_sync_committee_participant_reward(spec, state, participant_index, committee, committee_bits):
-    included_indices = [index for index, bit in zip(committee, committee_bits) if bit]
+def compute_sync_committee_participant_reward(spec, state, participant_index, committee_indices, committee_bits):
+    included_indices = [index for index, bit in zip(committee_indices, committee_bits) if bit]
     multiplicities = Counter(included_indices)
 
     inclusion_reward = compute_sync_committee_inclusion_reward(
-        spec, state, participant_index, committee, committee_bits,
+        spec, state, participant_index, committee_indices, committee_bits,
     )
     return spec.Gwei(inclusion_reward * multiplicities[participant_index])
 
 
-def compute_sync_committee_proposer_reward(spec, state, committee, committee_bits):
+def compute_sync_committee_proposer_reward(spec, state, committee_indices, committee_bits):
     proposer_reward = 0
-    for index, bit in zip(committee, committee_bits):
+    for index, bit in zip(committee_indices, committee_bits):
         if not bit:
             continue
         inclusion_reward = compute_sync_committee_inclusion_reward(
-            spec, state, index, committee, committee_bits,
+            spec, state, index, committee_indices, committee_bits,
         )
         proposer_reward_denominator = (
             (spec.WEIGHT_DENOMINATOR - spec.PROPOSER_WEIGHT)
@@ -147,15 +163,15 @@ def compute_sync_committee_proposer_reward(spec, state, committee, committee_bit
     return proposer_reward
 
 
-def validate_sync_committee_rewards(spec, pre_state, post_state, committee, committee_bits, proposer_index):
+def validate_sync_committee_rewards(spec, pre_state, post_state, committee_indices, committee_bits, proposer_index):
     for index in range(len(post_state.validators)):
         reward = 0
-        if index in committee:
+        if index in committee_indices:
             reward += compute_sync_committee_participant_reward(
                 spec,
                 pre_state,
                 index,
-                committee,
+                committee_indices,
                 committee_bits,
             )
 
@@ -163,14 +179,14 @@ def validate_sync_committee_rewards(spec, pre_state, post_state, committee, comm
             reward += compute_sync_committee_proposer_reward(
                 spec,
                 pre_state,
-                committee,
+                committee_indices,
                 committee_bits,
             )
 
         assert post_state.balances[index] == pre_state.balances[index] + reward
 
 
-def run_successful_sync_committee_test(spec, state, committee, committee_bits):
+def run_successful_sync_committee_test(spec, state, committee_indices, committee_bits):
     pre_state = state.copy()
 
     block = build_empty_block_for_next_slot(spec, state)
@@ -180,7 +196,7 @@ def run_successful_sync_committee_test(spec, state, committee, committee_bits):
             spec,
             state,
             block.slot - 1,
-            [index for index, bit in zip(committee, committee_bits) if bit],
+            [index for index, bit in zip(committee_indices, committee_bits) if bit],
         )
     )
 
@@ -190,7 +206,7 @@ def run_successful_sync_committee_test(spec, state, committee, committee_bits):
         spec,
         pre_state,
         state,
-        committee,
+        committee_indices,
         committee_bits,
         block.proposer_index,
     )
@@ -200,60 +216,60 @@ def run_successful_sync_committee_test(spec, state, committee, committee_bits):
 @with_configs([MINIMAL], reason="to create nonduplicate committee")
 @spec_state_test
 def test_sync_committee_rewards_nonduplicate_committee(spec, state):
-    committee = get_committee_indices(spec, state, duplicates=False)
-    committee_size = len(committee)
+    committee_indices = get_committee_indices(spec, state, duplicates=False)
+    committee_size = len(committee_indices)
     committee_bits = [True] * committee_size
     active_validator_count = len(spec.get_active_validator_indices(state, spec.get_current_epoch(state)))
 
     # Preconditions of this test case
     assert active_validator_count >= spec.SYNC_COMMITTEE_SIZE
-    assert committee_size == len(set(committee))
+    assert committee_size == len(set(committee_indices))
 
-    yield from run_successful_sync_committee_test(spec, state, committee, committee_bits)
+    yield from run_successful_sync_committee_test(spec, state, committee_indices, committee_bits)
 
 
 @with_altair_and_later
 @with_configs([MAINNET], reason="to create duplicate committee")
 @spec_state_test
 def test_sync_committee_rewards_duplicate_committee(spec, state):
-    committee = get_committee_indices(spec, state, duplicates=True)
-    committee_size = len(committee)
+    committee_indices = get_committee_indices(spec, state, duplicates=True)
+    committee_size = len(committee_indices)
     committee_bits = [True] * committee_size
     active_validator_count = len(spec.get_active_validator_indices(state, spec.get_current_epoch(state)))
 
     # Preconditions of this test case
     assert active_validator_count < spec.SYNC_COMMITTEE_SIZE
-    assert committee_size > len(set(committee))
+    assert committee_size > len(set(committee_indices))
 
-    yield from run_successful_sync_committee_test(spec, state, committee, committee_bits)
+    yield from run_successful_sync_committee_test(spec, state, committee_indices, committee_bits)
 
 
 @with_altair_and_later
 @spec_state_test
 @always_bls
 def test_sync_committee_rewards_not_full_participants(spec, state):
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    committee_indices = compute_committee_indices(spec, state, state.current_sync_committee)
     rng = random.Random(1010)
-    committee_bits = [rng.choice([True, False]) for _ in committee]
+    committee_bits = [rng.choice([True, False]) for _ in committee_indices]
 
-    yield from run_successful_sync_committee_test(spec, state, committee, committee_bits)
+    yield from run_successful_sync_committee_test(spec, state, committee_indices, committee_bits)
 
 
 @with_altair_and_later
 @spec_state_test
 @always_bls
 def test_sync_committee_rewards_empty_participants(spec, state):
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
-    committee_bits = [False for _ in committee]
+    committee_indices = compute_committee_indices(spec, state, state.current_sync_committee)
+    committee_bits = [False for _ in committee_indices]
 
-    yield from run_successful_sync_committee_test(spec, state, committee, committee_bits)
+    yield from run_successful_sync_committee_test(spec, state, committee_indices, committee_bits)
 
 
 @with_altair_and_later
 @spec_state_test
 @always_bls
 def test_invalid_signature_past_block(spec, state):
-    committee = spec.get_sync_committee_indices(state, spec.get_current_epoch(state))
+    committee_indices = compute_committee_indices(spec, state, state.current_sync_committee)
 
     blocks = []
     for _ in range(2):
@@ -261,12 +277,12 @@ def test_invalid_signature_past_block(spec, state):
         block = build_empty_block_for_next_slot(spec, state)
         # Valid sync committee signature here...
         block.body.sync_aggregate = spec.SyncAggregate(
-            sync_committee_bits=[True] * len(committee),
+            sync_committee_bits=[True] * len(committee_indices),
             sync_committee_signature=compute_aggregate_sync_committee_signature(
                 spec,
                 state,
                 block.slot - 1,
-                committee,
+                committee_indices,
             )
         )
 
@@ -276,12 +292,12 @@ def test_invalid_signature_past_block(spec, state):
     invalid_block = build_empty_block_for_next_slot(spec, state)
     # Invalid signature from a slot other than the previous
     invalid_block.body.sync_aggregate = spec.SyncAggregate(
-        sync_committee_bits=[True] * len(committee),
+        sync_committee_bits=[True] * len(committee_indices),
         sync_committee_signature=compute_aggregate_sync_committee_signature(
             spec,
             state,
             invalid_block.slot - 2,
-            committee,
+            committee_indices,
         )
     )
 
@@ -306,19 +322,18 @@ def test_invalid_signature_previous_committee(spec, state):
     transition_to(spec, state, slot_in_future_sync_committee_period)
 
     # Use the previous sync committee to produce the signature.
-    pubkeys = [validator.pubkey for validator in state.validators]
     # Ensure that the pubkey sets are different.
     assert set(old_sync_committee.pubkeys) != set(state.current_sync_committee.pubkeys)
-    committee = [pubkeys.index(pubkey) for pubkey in old_sync_committee.pubkeys]
+    committee_indices = compute_committee_indices(spec, state, old_sync_committee)
 
     block = build_empty_block_for_next_slot(spec, state)
     block.body.sync_aggregate = spec.SyncAggregate(
-        sync_committee_bits=[True] * len(committee),
+        sync_committee_bits=[True] * len(committee_indices),
         sync_committee_signature=compute_aggregate_sync_committee_signature(
             spec,
             state,
             block.slot - 1,
-            committee,
+            committee_indices,
         )
     )
 
@@ -345,14 +360,12 @@ def test_valid_signature_future_committee(spec, state):
 
     sync_committee = state.current_sync_committee
     next_sync_committee = state.next_sync_committee
-    expected_next_sync_committee = spec.get_sync_committee(state, epoch_in_future_sync_committee_period)
 
-    assert next_sync_committee == expected_next_sync_committee
+    assert next_sync_committee != sync_committee
     assert sync_committee != old_current_sync_committee
     assert sync_committee != old_next_sync_committee
 
-    pubkeys = [validator.pubkey for validator in state.validators]
-    committee_indices = [pubkeys.index(pubkey) for pubkey in sync_committee.pubkeys]
+    committee_indices = compute_committee_indices(spec, state, sync_committee)
 
     block = build_empty_block_for_next_slot(spec, state)
     block.body.sync_aggregate = spec.SyncAggregate(
diff --git a/tests/core/pyspec/eth2spec/test/helpers/genesis.py b/tests/core/pyspec/eth2spec/test/helpers/genesis.py
index 23cd04c93..c57442766 100644
--- a/tests/core/pyspec/eth2spec/test/helpers/genesis.py
+++ b/tests/core/pyspec/eth2spec/test/helpers/genesis.py
@@ -69,12 +69,8 @@ def create_genesis_state(spec, validator_balances, activation_threshold):
 
     if spec.fork not in FORKS_BEFORE_ALTAIR:
         # Fill in sync committees
-        current_period = spec.get_current_epoch(state) // spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-        previous_period = current_period - min(1, current_period)
-        current_base_epoch = current_period * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-        previous_base_epoch = previous_period * spec.EPOCHS_PER_SYNC_COMMITTEE_PERIOD
-
-        state.current_sync_committee = spec.get_sync_committee(state, previous_base_epoch)
-        state.next_sync_committee = spec.get_sync_committee(state, current_base_epoch)
+        # Note: A duplicate committee is assigned for the current and next committee at genesis
+        state.current_sync_committee = spec.get_next_sync_committee(state)
+        state.next_sync_committee = spec.get_next_sync_committee(state)
 
     return state

From 133875a6d6ce5a0e085e310cca3ca254db8d0dd1 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 May 2021 09:56:13 -0600
Subject: [PATCH 41/43] fix sync_committe_update tests

---
 .../epoch_processing/test_process_sync_committee_updates.py    | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
index ca25797c4..6af16287c 100644
--- a/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
+++ b/tests/core/pyspec/eth2spec/test/altair/epoch_processing/test_process_sync_committee_updates.py
@@ -39,8 +39,7 @@ def run_sync_committees_progress_test(spec, state):
 
     # Can compute the third committee having computed final balances in the last epoch
     # of this `EPOCHS_PER_SYNC_COMMITTEE_PERIOD`
-    current_epoch = spec.get_current_epoch(state)
-    third_sync_committee = spec.get_sync_committee(state, current_epoch + 1)
+    third_sync_committee = spec.get_next_sync_committee(state)
 
     assert state.current_sync_committee == second_sync_committee
     assert state.next_sync_committee == third_sync_committee

From 4286f85a68a7b2abdca249cd02482616840e5f86 Mon Sep 17 00:00:00 2001
From: Alex Stokes <r.alex.stokes@gmail.com>
Date: Wed, 12 May 2021 11:05:41 -0700
Subject: [PATCH 42/43] Update validator guide with restricted sync committee
 computation

---
 specs/altair/validator.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/specs/altair/validator.md b/specs/altair/validator.md
index 67e5914d1..4aee98ad4 100644
--- a/specs/altair/validator.md
+++ b/specs/altair/validator.md
@@ -177,7 +177,6 @@ At any given `epoch`, the `BeaconState` contains the current `SyncCommittee` and
 Once every `EPOCHS_PER_SYNC_COMMITTEE_PERIOD` epochs, the next `SyncCommittee` becomes the current `SyncCommittee` and the next committee is computed and stored.
 
 *Note*: The data required to compute a given committee is not cached in the `BeaconState` after committees are calculated at the period boundaries.
-This means that calling `get_sync_commitee()` in a given `epoch` can return a different result than what was computed during the relevant epoch transition.
 For this reason, *always* get committee assignments via the fields of the `BeaconState` (`current_sync_committee` and `next_sync_committee`) or use the above reference code.
 
 A validator should plan for future sync committee assignments by noting which sync committee periods they are selected for participation.
@@ -229,12 +228,12 @@ def process_sync_committee_contributions(block: BeaconBlock,
                                          contributions: Set[SyncCommitteeContribution]) -> None:
     sync_aggregate = SyncAggregate()
     signatures = []
+    sync_subcommittee_size = SYNC_COMMITTEE_SIZE // SYNC_COMMITTEE_SUBNET_COUNT
 
     for contribution in contributions:
         subcommittee_index = contribution.subcommittee_index
         for index, participated in enumerate(contribution.aggregation_bits):
             if participated:
-                sync_subcommittee_size = SYNC_COMMITTEE_SIZE // SYNC_COMMITTEE_SUBNET_COUNT
                 participant_index = sync_subcommittee_size * subcommittee_index + index
                 sync_aggregate.sync_committee_bits[participant_index] = True
         signatures.append(contribution.signature)
@@ -367,7 +366,7 @@ Set `contribution.subcommittee_index` to the index for the subcommittee index co
 ###### Aggregation bits
 
 Let `contribution.aggregation_bits` be a `Bitvector[SYNC_COMMITTEE_SIZE // SYNC_COMMITTEE_SUBNET_COUNT]`, where the `index`th bit is set in the `Bitvector` for each corresponding validator included in this aggregate from the corresponding subcommittee.
-An aggregator finds the index in the sync committee (as returned by `get_sync_committee_indices()`) for a given validator referenced by `sync_committee_signature.validator_index` and maps the sync committee index to an index in the subcommittee (along with the prior `subcommittee_index`). This index within the subcommittee is set in `contribution.aggegration_bits`.
+An aggregator finds the index in the sync committee (as determined by a reverse pubkey lookup on `state.current_sync_committee.pubkeys`) for a given validator referenced by `sync_committee_signature.validator_index` and maps the sync committee index to an index in the subcommittee (along with the prior `subcommittee_index`). This index within the subcommittee is set in `contribution.aggegration_bits`.
 
 For example, if a validator with index `2044` is pseudo-randomly sampled to sync committee index `135`. This sync committee index maps to `subcommittee_index` `1` with position `7` in the `Bitvector` for the contribution.
 

From 5188671816b3a846b1fa5ea781d3321f0e2c5f04 Mon Sep 17 00:00:00 2001
From: Danny Ryan <dannyjryan@gmail.com>
Date: Wed, 12 May 2021 12:18:35 -0600
Subject: [PATCH 43/43] Update specs/altair/beacon-chain.md

Co-authored-by: dankrad <dankrad@ethereum.org>
---
 specs/altair/beacon-chain.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/specs/altair/beacon-chain.md b/specs/altair/beacon-chain.md
index 9593d13a9..492a146ea 100644
--- a/specs/altair/beacon-chain.md
+++ b/specs/altair/beacon-chain.md
@@ -262,7 +262,7 @@ def has_flag(flags: ParticipationFlags, flag_index: int) -> bool:
 def get_sync_committee_indices(state: BeaconState, epoch: Epoch) -> Sequence[ValidatorIndex]:
     """
     Return the sequence of sync committee indices for a given ``state`` and ``epoch``.
-    Note: Committee can contain duplicate indices for small validator sets (< 2 * SYNC_COMMITTEE_SIZE)
+    Note: Committee can contain duplicate indices for small validator sets (< SYNC_COMMITTEE_SIZE + 128)
 
     Note: This function is not stable during a sync committee period as
     a validator's effective balance may change enough to affect the sampling.