Merge pull request #1451 from ethereum/master-to-dev

backport master to dev

specs/networking/p2p-interface.md

@@ -113,9 +113,8 @@ This section outlines constants that are used in this spec.
 
 | Name | Value | Description |
 |---|---|---|
-| `REQ_RESP_MAX_SIZE` | `TODO` | The maximum size of uncompressed req/resp messages that clients will allow. |
+| `GOSSIP_MAX_SIZE` | `2**20` (= 1048576, 1 MiB) | The maximum allowed size of uncompressed gossip messages. |
-| `SSZ_MAX_LIST_SIZE` | `TODO` | The maximum size of SSZ-encoded variable lists. |
+| `MAX_CHUNK_SIZE` | `2**20` (1048576, 1 MiB) | The maximum allowed size of uncompressed req/resp chunked responses. |
-| `GOSSIP_MAX_SIZE` | `2**20` (= 1048576, 1 MiB) | The maximum size of uncompressed gossip messages. |
 | `SHARD_SUBNET_COUNT` | `TODO` | The number of shard subnets used in the gossipsub protocol. |
 | `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. |
@@ -231,23 +230,24 @@ Request/response messages MUST adhere to the encoding specified in the protocol
 
 ```
 request   ::= <encoding-dependent-header> | <encoded-payload>
-response  ::= <result> | <encoding-dependent-header> | <encoded-payload>
+response  ::= <response_chunk>+
+response_chunk  ::= <result> | <encoding-dependent-header> | <encoded-payload>
 result    ::= “0” | “1” | “2” | [“128” ... ”255”]
 ```
 
 The encoding-dependent header may carry metadata or assertions such as the encoded payload length, for integrity and attack proofing purposes. Because req/resp streams are single-use and stream closures implicitly delimit the boundaries, it is not strictly necessary to length-prefix payloads; however, certain encodings like SSZ do, for added security.
 
-`encoded-payload` has a maximum byte size of `REQ_RESP_MAX_SIZE`.
+A `response` is formed by one or more `response_chunk`s. The exact request determines whether a response consists of a single `response_chunk` or possibly many. Responses that consist of a single SSZ-list (such as `BlocksByRange` and `BlocksByRoot`) send each list item as a `response_chunk`. All other response types (non-Lists) send a single `response_chunk`. The encoded-payload of a `response_chunk` has a maximum uncompressed byte size of `MAX_CHUNK_SIZE`.
 
-Clients MUST ensure the payload size is less than or equal to `REQ_RESP_MAX_SIZE`; if not, they SHOULD reset the stream immediately. Clients tracking peer reputation MAY decrement the score of the misbehaving peer under this circumstance.
+Clients MUST ensure the each encoded payload of a `response_chunk` is less than or equal to `MAX_CHUNK_SIZE`; if not, they SHOULD reset the stream immediately. Clients tracking peer reputation MAY decrement the score of the misbehaving peer under this circumstance.
 
 #### Requesting side
 
-Once a new stream with the protocol ID for the request type has been negotiated, the full request message should be sent immediately. It should be encoded according to the encoding strategy.
+Once a new stream with the protocol ID for the request type has been negotiated, the full request message SHOULD be sent immediately. The request MUST be encoded according to the encoding strategy.
 
-The requester MUST close the write side of the stream once it finishes writing the request message—at this point, the stream will be half-closed.
+The requester MUST close the write side of the stream once it finishes writing the request message. At this point, the stream will be half-closed.
 
-The requester MUST wait a maximum of `TTFB_TIMEOUT` for the first response byte to arrive (time to first byte—or TTFB—timeout). On that happening, the requester will allow further `RESP_TIMEOUT` to receive the full response.
+The requester MUST wait a maximum of `TTFB_TIMEOUT` for the first response byte to arrive (time to first byte—or TTFB—timeout). On that happening, the requester allows a further `RESP_TIMEOUT` for each subsequent `response_chunk` received. For responses consisting of potentially many `response_chunk`s (an SSZ-list) the requester SHOULD read from the stream until either; a) An error result is received in one of the chunks, b) The responder closes the stream,  c) More than `MAX_CHUNK_SIZE` bytes have been read for a single `response_chunk` payload or d) More than the maximum number of requested chunks are read. For requests consisting of a single `response_chunk` and a length-prefix, the requester should read the exact number of bytes defined by the length-prefix before closing the stream.
 
 If any of these timeouts fire, the requester SHOULD reset the stream and deem the req/resp operation to have failed.
 
@@ -260,16 +260,16 @@ The responder MUST:
 1. Use the encoding strategy to read the optional header.
 2. If there are any length assertions for length `N`, it should read exactly `N` bytes from the stream, at which point an EOF should arise (no more bytes). Should this not be the case, it should be treated as a failure.
 3. Deserialize the expected type, and process the request.
-4. Write the response (result, optional header, payload).
+4. Write the response which may consist of one or more `response_chunk`s (result, optional header, payload).
 5. Close their write side of the stream. At this point, the stream will be fully closed.
 
 If steps (1), (2), or (3) fail due to invalid, malformed, or inconsistent data, the responder MUST respond in error. Clients tracking peer reputation MAY record such failures, as well as unexpected events, e.g. early stream resets.
 
 The entire request should be read in no more than `RESP_TIMEOUT`. Upon a timeout, the responder SHOULD reset the stream.
 
-The responder SHOULD send a response promptly, starting with a **single-byte** response code which determines the contents of the response (`result` particle in the BNF grammar above).
+The responder SHOULD send a `response_chunk` promptly. Chunks start with a **single-byte** response code which determines the contents of the `response_chunk` (`result` particle in the BNF grammar above). For multiple chunks, only the last chunk is allowed to have a non-zero error code (i.e. The chunk stream is terminated once an error occurs).
 
-It can have one of the following values, encoded as a single unsigned byte:
+The response code can have one of the following values, encoded as a single unsigned byte:
 
 -  0: **Success** -- a normal response follows, with contents matching the expected message schema and encoding specified in the request.
 -  1: **InvalidRequest** -- the contents of the request are semantically invalid, or the payload is malformed, or could not be understood. The response payload adheres to the `ErrorMessage` schema (described below).
@@ -289,7 +289,7 @@ The `ErrorMessage` schema is:
 
 *Note*: The String type is encoded as UTF-8 bytes without NULL terminator when SSZ-encoded. As the `ErrorMessage` is not an SSZ-container, only the UTF-8 bytes will be sent when SSZ-encoded.
 
-A response therefore has the form:
+A response therefore has the form of one or more `response_chunk`s, each structured as follows:
 ```
   +--------+--------+--------+--------+--------+--------+
   | result |   header (opt)  |     encoded_response     |
@@ -301,7 +301,7 @@ Here, `result` represents the 1-byte response code.
 
 The token of the negotiated protocol ID specifies the type of encoding to be used for the req/resp interaction. Two values are possible at this time:
 
--  `ssz`: the contents are [SSZ-encoded](#ssz-encoding). This encoding type MUST be supported by all clients. For objects containing a single field, only the field is SSZ-encoded not a container with a single field. For example, the `BeaconBlocks` response would be an SSZ-encoded list of `BeaconBlock`s. All SSZ-Lists in the Req/Resp domain will have a maximum list size of `SSZ_MAX_LIST_SIZE`.
+-  `ssz`: the contents are [SSZ-encoded](../simple-serialize.md). This encoding type MUST be supported by all clients. For objects containing a single field, only the field is SSZ-encoded not a container with a single field. For example, the `BeaconBlocksByRoot` request is an SSZ-encoded list of `HashTreeRoots`'s.
 -  `ssz_snappy`: The contents are SSZ-encoded and then compressed with [Snappy](https://github.com/google/snappy). MAY be supported in the interoperability testnet; MUST be supported in mainnet.
 
 #### SSZ-encoding strategy (with or without Snappy)
@@ -310,18 +310,22 @@ The [SimpleSerialize (SSZ) specification](../simple-serialize.md) outlines how o
 
 **Encoding-dependent header:** Req/Resp protocols using the `ssz` or `ssz_snappy` encoding strategies MUST prefix all encoded and compressed (if applicable) payloads with an unsigned [protobuf varint](https://developers.google.com/protocol-buffers/docs/encoding#varints).
 
-*Note*: Parameters defined as `[]VariableName` are SSZ-encoded containerless vectors.
+All messages that contain only a single field MUST be encoded directly as the type of that field and MUST NOT be encoded as an SSZ container.
+
+Responses that are SSZ-lists (for example `[]BeaconBlocks`) send their
+constituents individually as `response_chunk`s. For example, the
+`[]BeaconBlocks` response type sends one or more `response_chunk`s. Each _successful_ `response_chunk` contains a single `BeaconBlock` payload.
 
 ### Messages
 
-#### Hello
+#### Status
 
-**Protocol ID:** ``/eth2/beacon_chain/req/hello/1/``
+**Protocol ID:** ``/eth2/beacon_chain/req/status/1/``
 
-**Content**:
+Request, Response Content:
 ```
 (
-  fork_version: bytes4
+  head_fork_version: bytes4
   finalized_root: bytes32
   finalized_epoch: uint64
   head_root: bytes32
@@ -330,29 +334,33 @@ The [SimpleSerialize (SSZ) specification](../simple-serialize.md) outlines how o
 ```
 The fields are:
 
-- `fork_version`: The beacon_state `Fork` version.
+- `head_fork_version`: The beacon_state `Fork` version.
 - `finalized_root`: The latest finalized root the node knows about.
 - `finalized_epoch`: The latest finalized epoch the node knows about.
 - `head_root`: The block hash tree root corresponding to the head of the chain as seen by the sending node.
 - `head_slot`: The slot corresponding to the `head_root`.
 
-Clients exchange hello messages upon connection, forming a two-phase handshake. The first message the initiating client sends MUST be the hello message. In response, the receiving client MUST respond with its own hello message.
+The dialing client MUST send a `Status` request upon connection.
+
+The request/response MUST be encoded as an SSZ-container.
+
+The response MUST consist of a single `response_chunk`.
 
 Clients SHOULD immediately disconnect from one another following the handshake above under the following conditions:
 
-1. If `fork_version` doesn’t match the local fork version, since the client’s chain is on another fork. `fork_version` can also be used to segregate testnets.
+1. If `head_fork_version` does not match the expected fork version at the epoch of the `head_slot`, since the client’s chain is on another fork. `head_fork_version` can also be used to segregate testnets.
 2. If the (`finalized_root`, `finalized_epoch`) shared by the peer is not in the client's chain at the expected epoch. For example, if Peer 1 sends (root, epoch) of (A, 5) and Peer 2 sends (B, 3) but Peer 1 has root C at epoch 3, then Peer 1 would disconnect because it knows that their chains are irreparably disjoint.
 
-Once the handshake completes, the client with the lower `finalized_epoch` or `head_slot` (if the clients have equal `finalized_epoch`s) SHOULD request beacon blocks from its counterparty via the `BeaconBlocks` request.
+Once the handshake completes, the client with the lower `finalized_epoch` or `head_slot` (if the clients have equal `finalized_epoch`s) SHOULD request beacon blocks from its counterparty via the `BeaconBlocksByRange` request.
 
 #### Goodbye
 
 **Protocol ID:** ``/eth2/beacon_chain/req/goodbye/1/``
 
-**Content:**
+Request, Response Content:
 ```
 (
-  reason: uint64
+  uint64
 )
 ```
 Client MAY send goodbye messages upon disconnection. The reason field MAY be one of the following values:
@@ -365,11 +373,15 @@ Clients MAY use reason codes above `128` to indicate alternative, erroneous requ
 
 The range `[4, 127]` is RESERVED for future usage.
 
-#### BeaconBlocks
+The request/response MUST be encoded as a single SSZ-field.
 
-**Protocol ID:** `/eth2/beacon_chain/req/beacon_blocks/1/`
+The response MUST consist of a single `response_chunk`.
 
-Request Content
+#### BeaconBlocksByRange
+
+**Protocol ID:** `/eth2/beacon_chain/req/beacon_blocks_by_range/1/`
+
+Request Content:
 ```
 (
   head_block_root: HashTreeRoot
@@ -382,27 +394,35 @@ Request Content
 Response Content:
 ```
 (
-  blocks: []BeaconBlock
+  []BeaconBlock
 )
 ```
 
 Requests count beacon blocks from the peer starting from `start_slot` on the chain defined by `head_block_root`. The response MUST contain no more than count blocks. `step` defines the slot increment between blocks. For example, requesting blocks starting at `start_slot` 2 with a step value of 2 would return the blocks at [2, 4, 6, …]. In cases where a slot is empty for a given slot number, no block is returned. For example, if slot 4 were empty in the previous example, the returned array would contain [2, 6, …]. A step value of 1 returns all blocks on the range `[start_slot, start_slot + count)`.
 
-`BeaconBlocks` is primarily used to sync historical blocks.
+The request MUST be encoded as an SSZ-container.
+
+The response MUST consist of at least one `response_chunk` and MAY consist of many. Each _successful_ `response_chunk` MUST contain a single `BeaconBlock` payload.
+
+`BeaconBlocksByRange` is primarily used to sync historical blocks.
 
 Clients MUST support requesting blocks since the start of the weak subjectivity period and up to the given `head_block_root`.
 
 Clients MUST support `head_block_root` values since the latest finalized epoch.
 
-#### RecentBeaconBlocks
+Clients MUST respond with at least one block, if they have it.
 
-**Protocol ID:** `/eth2/beacon_chain/req/recent_beacon_blocks/1/`
+Clients MUST order blocks by increasing slot number.
+
+#### BeaconBlocksByRoot
+
+**Protocol ID:** `/eth2/beacon_chain/req/beacon_blocks_by_root/1/`
 
 Request Content:
 
 ```
 (
-  block_roots: []HashTreeRoot
+  []HashTreeRoot
 )
 ```
 
@@ -410,16 +430,22 @@ Response Content:
 
 ```
 (
-  blocks: []BeaconBlock
+  []BeaconBlock
 )
 ```
 
-Requests blocks by their block roots. The response is a list of `BeaconBlock` with the same length as the request. Blocks are returned in order of the request and any missing/unknown blocks are left empty (SSZ null `BeaconBlock`).
+Requests blocks by their block roots. The response is a list of `BeaconBlock` whose length is less than or equal to the number of requested blocks. It may be less in the case that the responding peer is missing blocks.
 
-`RecentBeaconBlocks` is primarily used to recover recent blocks (ex. when receiving a block or attestation whose parent is unknown).
+`BeaconBlocksByRoot` is primarily used to recover recent blocks (e.g. when receiving a block or attestation whose parent is unknown).
+
+The request MUST be encoded as an SSZ-field.
+
+The response MUST consist of at least one `response_chunk` and MAY consist of many. Each _successful_ `response_chunk` MUST contain a single `BeaconBlock` payload.
 
 Clients MUST support requesting blocks since the latest finalized epoch.
 
+Clients MUST respond with at least one block, if they have it.
+
 ## The discovery domain: discv5
 
 Discovery Version 5 ([discv5](https://github.com/ethereum/devp2p/blob/master/discv5/discv5.md)) is used for peer discovery, both in the interoperability testnet and mainnet.
@@ -682,7 +708,7 @@ Disadvantages include:
 * Harder to stream as length must be known up-front
 * Additional code path required to verify length
 
-In some protocols, adding a length prefix serves as a form of DoS protection against very long messages, allowing the client to abort if an overlong message is about to be sent. In this protocol, we are globally limiting message sizes using `REQ_RESP_MAX_SIZE`, thus the length prefix does not afford any additional protection.
+In some protocols, adding a length prefix serves as a form of DoS protection against very long messages, allowing the client to abort if an overlong message is about to be sent. In this protocol, we are globally limiting message sizes using `MAX_CHUNK_SIZE`, thus the length prefix does not afford any additional protection.
 
 [Protobuf varint](https://developers.google.com/protocol-buffers/docs/encoding#varints) is an efficient technique to encode variable-length ints. Instead of reserving a fixed-size field of as many bytes as necessary to convey the maximum possible value, this field is elastic in exchange for 1-bit overhead per byte.
 

test_generators/bls/main.py

@@ -11,6 +11,12 @@ from eth_utils import (
 from gen_base import gen_runner, gen_typing
 
 from py_ecc import bls
+from hashlib import sha256
+
+
+def hash(x):
+    return sha256(x).digest()
+
 
 F2Q_COEFF_LEN = 48
 G2_COMPRESSED_Z_LEN = 48
@@ -122,7 +128,8 @@ def case04_sign_messages():
         for message in MESSAGES:
             for domain in DOMAINS:
                 sig = bls.sign(message, privkey, domain)
-                yield f'sign_msg_{int_to_hex(privkey)}_{encode_hex(message)}_{encode_hex(domain)}', {
+                full_name = f'{int_to_hex(privkey)}_{encode_hex(message)}_{encode_hex(domain)}'
+                yield f'sign_msg_case_{(hash(bytes(full_name, "utf-8"))[:8]).hex()}', {
                     'input': {
                         'privkey': int_to_hex(privkey),
                         'message': encode_hex(message),

test_generators/epoch_processing/main.py

@@ -6,6 +6,7 @@ from eth2spec.test.phase_0.epoch_processing import (
     test_process_final_updates,
     test_process_justification_and_finalization,
     test_process_registry_updates,
+    test_process_rewards_and_penalties,
     test_process_slashings
 )
 from gen_base import gen_runner, gen_typing
@@ -40,6 +41,9 @@ if __name__ == "__main__":
         create_provider('justification_and_finalization', test_process_justification_and_finalization, 'mainnet'),
         create_provider('registry_updates', test_process_registry_updates, 'minimal'),
         create_provider('registry_updates', test_process_registry_updates, 'mainnet'),
+        create_provider('rewards_and_penalties', test_process_rewards_and_penalties, 'minimal'),
+        # runs full epochs filled with data, with uncached ssz. Disabled for now.
+        # create_provider('rewards_and_penalties', test_process_rewards_and_penalties, 'mainnet'),
         create_provider('slashings', test_process_slashings, 'minimal'),
         create_provider('slashings', test_process_slashings, 'mainnet'),
     ])

test_libs/config_helpers/requirements.txt

@@ -1 +1 @@
-ruamel.yaml==0.15.96
+ruamel.yaml==0.16.5

test_libs/config_helpers/setup.py

@@ -4,6 +4,6 @@ setup(
     name='config_helpers',
     packages=['preset_loader'],
     install_requires=[
-        "ruamel.yaml==0.15.96"
+        "ruamel.yaml==0.16.5"
     ]
 )

test_libs/pyspec/eth2spec/test/context.py

@@ -6,15 +6,67 @@ from .helpers.genesis import create_genesis_state
 
 from .utils import vector_test, with_meta_tags
 
+from typing import Any, Callable, Sequence
 
-def with_state(fn):
+
+def with_custom_state(balances_fn: Callable[[Any], Sequence[int]],
+                      threshold_fn: Callable[[Any], int]):
+    def deco(fn):
         def entry(*args, **kw):
             try:
-            kw['state'] = create_genesis_state(spec=kw['spec'], num_validators=spec_phase0.SLOTS_PER_EPOCH * 10)
+                spec = kw['spec']
+
+                balances = balances_fn(spec)
+                activation_threshold = threshold_fn(spec)
+
+                kw['state'] = create_genesis_state(spec=spec, validator_balances=balances,
+                                                   activation_threshold=activation_threshold)
             except KeyError:
                 raise TypeError('Spec decorator must come within state decorator to inject spec into state.')
             return fn(*args, **kw)
         return entry
+    return deco
+
+
+def default_activation_threshold(spec):
+    """
+    Helper method to use the default balance activation threshold for state creation for tests.
+    Usage: `@with_custom_state(threshold_fn=default_activation_threshold, ...)`
+    """
+    return spec.MAX_EFFECTIVE_BALANCE
+
+
+def default_balances(spec):
+    """
+    Helper method to create a series of default balances.
+    Usage: `@with_custom_state(balances_fn=default_balances, ...)`
+    """
+    num_validators = spec.SLOTS_PER_EPOCH * 8
+    return [spec.MAX_EFFECTIVE_BALANCE] * num_validators
+
+
+with_state = with_custom_state(default_balances, default_activation_threshold)
+
+
+def low_balances(spec):
+    """
+    Helper method to create a series of low balances.
+    Usage: `@with_custom_state(balances_fn=low_balances, ...)`
+    """
+    num_validators = spec.SLOTS_PER_EPOCH * 8
+    # Technically the balances cannot be this low starting from genesis, but it is useful for testing
+    low_balance = 18 * 10 ** 9
+    return [low_balance] * num_validators
+
+
+def misc_balances(spec):
+    """
+    Helper method to create a series of balances that includes some misc. balances.
+    Usage: `@with_custom_state(balances_fn=misc_balances, ...)`
+    """
+    num_validators = spec.SLOTS_PER_EPOCH * 8
+    num_misc_validators = spec.SLOTS_PER_EPOCH
+    return [spec.MAX_EFFECTIVE_BALANCE] * num_validators + [spec.MIN_DEPOSIT_AMOUNT] * num_misc_validators
 
 
 # BLS is turned off by default *for performance purposes during TESTING*.

test_libs/pyspec/eth2spec/test/genesis/test_initialization.py

@@ -8,7 +8,7 @@ from eth2spec.test.helpers.deposits import (
 @spec_test
 def test_initialize_beacon_state_from_eth1(spec):
     deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
-    deposits, deposit_root = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
+    deposits, deposit_root, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
 
     eth1_block_hash = b'\x12' * 32
     eth1_timestamp = spec.MIN_GENESIS_TIME
@@ -25,6 +25,43 @@ def test_initialize_beacon_state_from_eth1(spec):
     assert state.eth1_data.deposit_root == deposit_root
     assert state.eth1_data.deposit_count == deposit_count
     assert state.eth1_data.block_hash == eth1_block_hash
+    assert spec.get_total_active_balance(state) == deposit_count * spec.MAX_EFFECTIVE_BALANCE
+
+    # yield state
+    yield 'state', state
+
+
+@with_phases(['phase0'])
+@spec_test
+def test_initialize_beacon_state_some_small_balances(spec):
+    main_deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
+    main_deposits, _, deposit_data_list = prepare_genesis_deposits(spec, main_deposit_count,
+                                                                   spec.MAX_EFFECTIVE_BALANCE, signed=True)
+    # For deposits above, and for another deposit_count, add a balance of EFFECTIVE_BALANCE_INCREMENT
+    small_deposit_count = main_deposit_count * 2
+    small_deposits, deposit_root, _ = prepare_genesis_deposits(spec, small_deposit_count,
+                                                               spec.MIN_DEPOSIT_AMOUNT,
+                                                               signed=True,
+                                                               deposit_data_list=deposit_data_list)
+    deposits = main_deposits + small_deposits
+
+    eth1_block_hash = b'\x12' * 32
+    eth1_timestamp = spec.MIN_GENESIS_TIME
+
+    yield 'eth1_block_hash', eth1_block_hash
+    yield 'eth1_timestamp', eth1_timestamp
+    yield 'deposits', deposits
+
+    # initialize beacon_state
+    state = spec.initialize_beacon_state_from_eth1(eth1_block_hash, eth1_timestamp, deposits)
+
+    assert state.genesis_time == eth1_timestamp - eth1_timestamp % spec.SECONDS_PER_DAY + 2 * spec.SECONDS_PER_DAY
+    assert len(state.validators) == small_deposit_count
+    assert state.eth1_data.deposit_root == deposit_root
+    assert state.eth1_data.deposit_count == len(deposits)
+    assert state.eth1_data.block_hash == eth1_block_hash
+    # only main deposits participate to the active balance
+    assert spec.get_total_active_balance(state) == main_deposit_count * spec.MAX_EFFECTIVE_BALANCE
 
     # yield state
     yield 'state', state

test_libs/pyspec/eth2spec/test/genesis/test_validity.py

@@ -6,7 +6,7 @@ from eth2spec.test.helpers.deposits import (
 
 def create_valid_beacon_state(spec):
     deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT
-    deposits, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
+    deposits, _, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
 
     eth1_block_hash = b'\x12' * 32
     eth1_timestamp = spec.MIN_GENESIS_TIME
@@ -65,7 +65,7 @@ def test_is_valid_genesis_state_true_more_balance(spec):
 @spec_test
 def test_is_valid_genesis_state_true_one_more_validator(spec):
     deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT + 1
-    deposits, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
+    deposits, _, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
 
     eth1_block_hash = b'\x12' * 32
     eth1_timestamp = spec.MIN_GENESIS_TIME
@@ -78,7 +78,7 @@ def test_is_valid_genesis_state_true_one_more_validator(spec):
 @spec_test
 def test_is_valid_genesis_state_false_not_enough_validator(spec):
     deposit_count = spec.MIN_GENESIS_ACTIVE_VALIDATOR_COUNT - 1
-    deposits, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
+    deposits, _, _ = prepare_genesis_deposits(spec, deposit_count, spec.MAX_EFFECTIVE_BALANCE, signed=True)
 
     eth1_block_hash = b'\x12' * 32
     eth1_timestamp = spec.MIN_GENESIS_TIME

test_libs/pyspec/eth2spec/test/helpers/attestations.py

@@ -114,7 +114,8 @@ def get_attestation_signature(spec, state, attestation_data, privkey, custody_bi
     )
 
 
-def fill_aggregate_attestation(spec, state, attestation):
+def fill_aggregate_attestation(spec, state, attestation, signed=False):
+
     beacon_committee = spec.get_beacon_committee(
         state,
         attestation.data.slot,
@@ -123,10 +124,14 @@ def fill_aggregate_attestation(spec, state, attestation):
     for i in range(len(beacon_committee)):
         attestation.aggregation_bits[i] = True
 
+    if signed:
+        sign_attestation(spec, state, attestation)
 
-def add_attestation_to_state(spec, state, attestation, slot):
+
+def add_attestations_to_state(spec, state, attestations, slot):
     block = build_empty_block_for_next_slot(spec, state)
     block.slot = slot
+    for attestation in attestations:
         block.body.attestations.append(attestation)
     spec.process_slots(state, block.slot)
     sign_block(spec, state, block)

test_libs/pyspec/eth2spec/test/helpers/deposits.py

@@ -55,7 +55,8 @@ def build_deposit(spec,
     return deposit, root, deposit_data_list
 
 
-def prepare_genesis_deposits(spec, genesis_validator_count, amount, signed=False):
+def prepare_genesis_deposits(spec, genesis_validator_count, amount, signed=False, deposit_data_list=None):
+    if deposit_data_list is None:
         deposit_data_list = []
     genesis_deposits = []
     for validator_index in range(genesis_validator_count):
@@ -75,7 +76,7 @@ def prepare_genesis_deposits(spec, genesis_validator_count, amount, signed=False
         )
         genesis_deposits.append(deposit)
 
-    return genesis_deposits, root
+    return genesis_deposits, root, deposit_data_list
 
 
 def prepare_state_and_deposit(spec, state, validator_index, amount, withdrawal_credentials=None, signed=False):

test_libs/pyspec/eth2spec/test/helpers/genesis.py

@@ -1,3 +1,4 @@
+import copy
 from eth2spec.test.helpers.keys import pubkeys
 
 
@@ -16,16 +17,16 @@ def build_mock_validator(spec, i: int, balance: int):
     )
 
 
-def create_genesis_state(spec, num_validators):
+def create_genesis_state(spec, validator_balances, activation_threshold):
     deposit_root = b'\x42' * 32
 
     eth1_block_hash = b'\xda' * 32
     state = spec.BeaconState(
         genesis_time=0,
-        eth1_deposit_index=num_validators,
+        eth1_deposit_index=len(validator_balances),
         eth1_data=spec.Eth1Data(
             deposit_root=deposit_root,
-            deposit_count=num_validators,
+            deposit_count=len(validator_balances),
             block_hash=eth1_block_hash,
         ),
         latest_block_header=spec.BeaconBlockHeader(body_root=spec.hash_tree_root(spec.BeaconBlockBody())),
@@ -34,12 +35,12 @@ def create_genesis_state(spec, num_validators):
 
     # We "hack" in the initial validators,
     #  as it is much faster than creating and processing genesis deposits for every single test case.
-    state.balances = [spec.MAX_EFFECTIVE_BALANCE] * num_validators
+    state.balances = copy.deepcopy(validator_balances)
-    state.validators = [build_mock_validator(spec, i, state.balances[i]) for i in range(num_validators)]
+    state.validators = [build_mock_validator(spec, i, state.balances[i]) for i in range(len(validator_balances))]
 
     # Process genesis activations
     for validator in state.validators:
-        if validator.effective_balance >= spec.MAX_EFFECTIVE_BALANCE:
+        if validator.effective_balance >= activation_threshold:
             validator.activation_eligibility_epoch = spec.GENESIS_EPOCH
             validator.activation_epoch = spec.GENESIS_EPOCH
 

test_libs/pyspec/eth2spec/test/phase_0/block_processing/test_process_attestation.py

@@ -3,6 +3,9 @@ from eth2spec.test.context import (
     expect_assertion_error,
     always_bls, never_bls,
     with_all_phases, with_phases,
+    spec_test,
+    low_balances,
+    with_custom_state,
 )
 from eth2spec.test.helpers.attestations import (
     get_valid_attestation,
@@ -60,6 +63,17 @@ def test_success(spec, state):
     yield from run_attestation_processing(spec, state, attestation)
 
 
+@with_all_phases
+@spec_test
+@with_custom_state(balances_fn=low_balances, threshold_fn=lambda spec: spec.EJECTION_BALANCE)
+def test_success_multi_proposer_index_iterations(spec, state):
+    state.slot += spec.SLOTS_PER_EPOCH * 2
+    attestation = get_valid_attestation(spec, state, signed=True)
+    state.slot += spec.MIN_ATTESTATION_INCLUSION_DELAY
+
+    yield from run_attestation_processing(spec, state, attestation)
+
+
 @with_all_phases
 @spec_state_test
 def test_success_previous_epoch(spec, state):

test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_justification_and_finalization.py

@@ -8,7 +8,7 @@ def run_process_just_and_fin(spec, state):
     yield from run_epoch_processing_with(spec, state, 'process_justification_and_finalization')
 
 
-def add_mock_attestations(spec, state, epoch, source, target, sufficient_support=False):
+def add_mock_attestations(spec, state, epoch, source, target, sufficient_support=False, messed_up_target=False):
     # we must be at the end of the epoch
     assert (state.slot + 1) % spec.SLOTS_PER_EPOCH == 0
 
@@ -61,6 +61,8 @@ def add_mock_attestations(spec, state, epoch, source, target, sufficient_support
                 ),
                 inclusion_delay=1,
             ))
+            if messed_up_target:
+                attestations[len(attestations) - 1].data.target.root = b'\x99' * 32
 
 
 def get_checkpoints(spec, epoch):
@@ -190,7 +192,7 @@ def finalize_on_123(spec, state, epoch, sufficient_support):
         assert state.finalized_checkpoint == old_finalized  # no new finalized
 
 
-def finalize_on_12(spec, state, epoch, sufficient_support):
+def finalize_on_12(spec, state, epoch, sufficient_support, messed_up_target):
     assert epoch > 2
     state.slot = (spec.SLOTS_PER_EPOCH * epoch) - 1  # skip ahead to just before epoch
 
@@ -212,13 +214,14 @@ def finalize_on_12(spec, state, epoch, sufficient_support):
                           epoch=epoch - 1,
                           source=c2,
                           target=c1,
-                          sufficient_support=sufficient_support)
+                          sufficient_support=sufficient_support,
+                          messed_up_target=messed_up_target)
 
     # process!
     yield from run_process_just_and_fin(spec, state)
 
     assert state.previous_justified_checkpoint == c2  # changed to old current
-    if sufficient_support:
+    if sufficient_support and not messed_up_target:
         assert state.current_justified_checkpoint == c1  # changed to 1st latest
         assert state.finalized_checkpoint == c2  # finalized previous justified epoch
     else:
@@ -265,10 +268,16 @@ def test_123_poor_support(spec, state):
 @with_all_phases
 @spec_state_test
 def test_12_ok_support(spec, state):
-    yield from finalize_on_12(spec, state, 3, True)
+    yield from finalize_on_12(spec, state, 3, True, False)
+
+
+@with_all_phases
+@spec_state_test
+def test_12_ok_support_messed_target(spec, state):
+    yield from finalize_on_12(spec, state, 3, True, True)
 
 
 @with_all_phases
 @spec_state_test
 def test_12_poor_support(spec, state):
-    yield from finalize_on_12(spec, state, 3, False)
+    yield from finalize_on_12(spec, state, 3, False, False)

test_libs/pyspec/eth2spec/test/phase_0/epoch_processing/test_process_rewards_and_penalties.py

@@ -0,0 +1,206 @@
+from copy import deepcopy
+
+from eth2spec.test.context import spec_state_test, with_all_phases, spec_test, \
+    misc_balances, with_custom_state, default_activation_threshold
+from eth2spec.test.helpers.state import (
+    next_epoch,
+    next_slot,
+)
+from eth2spec.test.helpers.attestations import (
+    add_attestations_to_state,
+    get_valid_attestation,
+)
+from eth2spec.test.phase_0.epoch_processing.run_epoch_process_base import run_epoch_processing_with
+
+
+def run_process_rewards_and_penalties(spec, state):
+    yield from run_epoch_processing_with(spec, state, 'process_rewards_and_penalties')
+
+
+@with_all_phases
+@spec_state_test
+def test_genesis_epoch_no_attestations_no_penalties(spec, state):
+    pre_state = deepcopy(state)
+
+    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH
+
+    yield from run_process_rewards_and_penalties(spec, state)
+
+    for index in range(len(pre_state.validators)):
+        assert state.balances[index] == pre_state.balances[index]
+
+
+@with_all_phases
+@spec_state_test
+def test_genesis_epoch_full_attestations_no_rewards(spec, state):
+    attestations = []
+    for slot in range(spec.SLOTS_PER_EPOCH - 1):
+        # create an attestation for each slot
+        if slot < spec.SLOTS_PER_EPOCH:
+            attestation = get_valid_attestation(spec, state, signed=True)
+            attestations.append(attestation)
+        # fill each created slot in state after inclusion delay
+        if slot - spec.MIN_ATTESTATION_INCLUSION_DELAY >= 0:
+            include_att = attestations[slot - spec.MIN_ATTESTATION_INCLUSION_DELAY]
+            add_attestations_to_state(spec, state, [include_att], state.slot)
+        next_slot(spec, state)
+
+    # ensure has not cross the epoch boundary
+    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH
+
+    pre_state = deepcopy(state)
+
+    yield from run_process_rewards_and_penalties(spec, state)
+
+    for index in range(len(pre_state.validators)):
+        assert state.balances[index] == pre_state.balances[index]
+
+
+def prepare_state_with_full_attestations(spec, state):
+    attestations = []
+    for slot in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
+        # create an attestation for each slot in epoch
+        if slot < spec.SLOTS_PER_EPOCH:
+            attestation = get_valid_attestation(spec, state, signed=True)
+            attestations.append(attestation)
+        # fill each created slot in state after inclusion delay
+        if slot - spec.MIN_ATTESTATION_INCLUSION_DELAY >= 0:
+            include_att = attestations[slot - spec.MIN_ATTESTATION_INCLUSION_DELAY]
+            add_attestations_to_state(spec, state, [include_att], state.slot)
+        next_slot(spec, state)
+
+    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
+    assert len(state.previous_epoch_attestations) == spec.SLOTS_PER_EPOCH
+
+    return attestations
+
+
+@with_all_phases
+@spec_state_test
+def test_full_attestations(spec, state):
+    attestations = prepare_state_with_full_attestations(spec, state)
+
+    pre_state = deepcopy(state)
+
+    yield from run_process_rewards_and_penalties(spec, state)
+
+    attesting_indices = spec.get_unslashed_attesting_indices(state, attestations)
+    assert len(attesting_indices) > 0
+    for index in range(len(pre_state.validators)):
+        if index in attesting_indices:
+            assert state.balances[index] > pre_state.balances[index]
+        else:
+            assert state.balances[index] < pre_state.balances[index]
+
+
+@with_all_phases
+@spec_test
+@with_custom_state(balances_fn=misc_balances, threshold_fn=default_activation_threshold)
+def test_full_attestations_misc_balances(spec, state):
+    attestations = prepare_state_with_full_attestations(spec, state)
+
+    pre_state = deepcopy(state)
+
+    yield from run_process_rewards_and_penalties(spec, state)
+
+    attesting_indices = spec.get_unslashed_attesting_indices(state, attestations)
+    assert len(attesting_indices) > 0
+    assert len(attesting_indices) != len(pre_state.validators)
+    for index in range(len(pre_state.validators)):
+        if index in attesting_indices:
+            assert state.balances[index] > pre_state.balances[index]
+        elif spec.is_active_validator(pre_state.validators[index], spec.compute_epoch_at_slot(state.slot)):
+            assert state.balances[index] < pre_state.balances[index]
+        else:
+            assert state.balances[index] == pre_state.balances[index]
+
+
+@with_all_phases
+@spec_state_test
+def test_no_attestations_all_penalties(spec, state):
+    next_epoch(spec, state)
+    pre_state = deepcopy(state)
+
+    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
+
+    yield from run_process_rewards_and_penalties(spec, state)
+
+    for index in range(len(pre_state.validators)):
+        assert state.balances[index] < pre_state.balances[index]
+
+
+@with_all_phases
+@spec_state_test
+def test_duplicate_attestation(spec, state):
+    """
+    Although duplicate attestations can be included on-chain, they should only
+    be rewarded for once.
+    This test addresses this issue found at Interop
+    https://github.com/djrtwo/interop-test-cases/tree/master/tests/prysm_16_duplicate_attestation_rewards
+    """
+    attestation = get_valid_attestation(spec, state, signed=True)
+
+    indexed_attestation = spec.get_indexed_attestation(state, attestation)
+    participants = indexed_attestation.custody_bit_0_indices + indexed_attestation.custody_bit_1_indices
+
+    assert len(participants) > 0
+
+    single_state = deepcopy(state)
+    dup_state = deepcopy(state)
+
+    inclusion_slot = state.slot + spec.MIN_ATTESTATION_INCLUSION_DELAY
+    add_attestations_to_state(spec, single_state, [attestation], inclusion_slot)
+    add_attestations_to_state(spec, dup_state, [attestation, attestation], inclusion_slot)
+
+    next_epoch(spec, single_state)
+    next_epoch(spec, dup_state)
+
+    # Run non-duplicate inclusion rewards for comparision. Do not yield test vectors
+    for _ in run_process_rewards_and_penalties(spec, single_state):
+        pass
+
+    # Output duplicate inclusion to test vectors
+    yield from run_process_rewards_and_penalties(spec, dup_state)
+
+    for index in participants:
+        assert state.balances[index] < single_state.balances[index]
+        assert single_state.balances[index] == dup_state.balances[index]
+
+
+@with_all_phases
+@spec_state_test
+# Case when some eligible attestations are slashed. Modifies attesting_balance and consequently rewards/penalties.
+def test_attestations_some_slashed(spec, state):
+    attestations = []
+    for slot in range(spec.SLOTS_PER_EPOCH + spec.MIN_ATTESTATION_INCLUSION_DELAY):
+        # create an attestation for each slot in epoch
+        if slot < spec.SLOTS_PER_EPOCH:
+            attestation = get_valid_attestation(spec, state, signed=True)
+            attestations.append(attestation)
+        # fill each created slot in state after inclusion delay
+        if slot - spec.MIN_ATTESTATION_INCLUSION_DELAY >= 0:
+            include_att = attestations[slot - spec.MIN_ATTESTATION_INCLUSION_DELAY]
+            add_attestations_to_state(spec, state, [include_att], state.slot)
+        next_slot(spec, state)
+
+    attesting_indices_before_slashings = list(spec.get_unslashed_attesting_indices(state, attestations))
+
+    # Slash maximum amount of validators allowed per epoch.
+    for i in range(spec.MIN_PER_EPOCH_CHURN_LIMIT):
+        spec.slash_validator(state, attesting_indices_before_slashings[i])
+
+    assert spec.compute_epoch_at_slot(state.slot) == spec.GENESIS_EPOCH + 1
+    assert len(state.previous_epoch_attestations) == spec.SLOTS_PER_EPOCH
+
+    pre_state = deepcopy(state)
+
+    yield from run_process_rewards_and_penalties(spec, state)
+
+    attesting_indices = spec.get_unslashed_attesting_indices(state, attestations)
+    assert len(attesting_indices) > 0
+    assert len(attesting_indices_before_slashings) - len(attesting_indices) == spec.MIN_PER_EPOCH_CHURN_LIMIT
+    for index in range(len(pre_state.validators)):
+        if index in attesting_indices:
+            assert state.balances[index] > pre_state.balances[index]
+        else:
+            assert state.balances[index] < pre_state.balances[index]