status-im/eth2.0-specs
2
0
Fork 0
mirror of https://github.com/status-im/eth2.0-specs.git synced 2025-01-19 23:19:28 +00:00
Code Issues Projects Releases Wiki Activity

Apply suggestions from code review

Browse Source 
Co-Authored-By: terence tsao <terence@prysmaticlabs.com>
This commit is contained in:
Justin 2019-09-03 21:56:12 +01:00 committed by GitHub
parent a0bbc940ce
commit 225c740107
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 16 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
specs/core/1_shard-data-chains.md
View File

@ -229,7 +229,7 @@ def process_delta(state: BeaconState, shard_state: ShardState, index: ValidatorI
### `get_genesis_shard_state`
```python
def get_genesis_shard_state(state: BeaconState, shard: Shard) -> ShardState:
def get_genesis_shard_state(shard: Shard) -> ShardState:
return ShardState(
shard=shard,
slot=ShardSlot(SHARD_GENESIS_EPOCH * SHARD_SLOTS_PER_EPOCH),
@ -295,8 +295,8 @@ def process_shard_slot(state: BeaconState, shard_state: ShardState) -> None:
```python
def process_shard_period(state: BeaconState, shard_state: ShardState) -> None:
# Rotate rewards and fees
state.older_committee_deltas = state.newer_committee_deltas
state.newer_committee_deltas = [GweiDelta(0) for _ in range(MAX_PERIOD_COMMITTEE_SIZE)]
shard_state.older_committee_deltas = shard_state.newer_committee_deltas
shard_state.newer_committee_deltas = [GweiDelta(0) for _ in range(MAX_PERIOD_COMMITTEE_SIZE)]
```
### Block processing
@ -313,16 +313,16 @@ def process_shard_block(state: BeaconState, shard_state: ShardState, block: Shar
```python
def process_shard_block_header(state: BeaconState, shard_state: ShardState, block: ShardBlock) -> None:
# Verify the shard number
assert block.shard == state.shard
assert block.shard == shard_state.shard
# Verify the slot number
assert block.slot == state.slot
assert block.slot == shard_state.slot
# Verify the beacon chain root
parent_epoch = compute_epoch_of_shard_slot(state.latest_block_header.slot)
parent_epoch = compute_epoch_of_shard_slot(shard_state.latest_block_header.slot)
assert block.beacon_block_root == get_block_root(state, parent_epoch)
# Verify the parent root
assert block.parent_root == hash_tree_root(state.latest_block_header)
assert block.parent_root == hash_tree_root(shard_state.latest_block_header)
# Save current block as the new latest block
state.latest_block_header = ShardBlockHeader(
shard_state.latest_block_header = ShardBlockHeader(
shard=block.shard,
slot=block.slot,
beacon_block_root=block.beacon_block_root,
@ -335,10 +335,10 @@ def process_shard_block_header(state: BeaconState, shard_state: ShardState, bloc
# `signature` is zeroed
)
# Verify the sum of the block sizes since genesis
state.block_size_sum += SHARD_HEADER_SIZE + len(block.body)
shard_state.block_size_sum += SHARD_HEADER_SIZE + len(block.body)
assert block.block_size_sum == state.block_size_sum
# Verify proposer signature
proposer_index = get_shard_proposer_index(state, state.shard, block.slot)
proposer_index = get_shard_proposer_index(state, shard_state.shard, block.slot)
pubkey = state.validators[proposer_index].pubkey
domain = get_domain(state, DOMAIN_SHARD_PROPOSER, compute_epoch_of_shard_slot(block.slot))
assert bls_verify(pubkey, hash_tree_root(block.block), block.proposer, domain)
@ -350,7 +350,7 @@ def process_shard_block_header(state: BeaconState, shard_state: ShardState, bloc
def process_shard_attestations(state: BeaconState, shard_state: ShardState, block: ShardBlock) -> None:
pubkeys = []
attestation_count = 0
shard_committee = get_shard_committee(state, state.shard, block.slot)
shard_committee = get_shard_committee(state, shard_state.shard, block.slot)
for i, validator_index in enumerate(shard_committee):
if block.aggregation_bits[i]:
pubkeys.append(state.validators[validator_index].pubkey)
@ -364,7 +364,7 @@ def process_shard_attestations(state: BeaconState, shard_state: ShardState, bloc
message = hash_tree_root(ShardCheckpoint(shard_state.slot, block.parent_root))
assert bls_verify(bls_aggregate_pubkeys(pubkeys), message, block.attestations, domain)
# Proposer micro-reward
proposer_index = get_shard_proposer_index(state, state.shard, block.slot)
proposer_index = get_shard_proposer_index(state, shard_state.shard, block.slot)
reward = attestation_count * get_base_reward(state, proposer_index) // PROPOSER_REWARD_QUOTIENT
process_delta(state, shard_state, proposer_index, reward)
```
@ -376,20 +376,20 @@ def process_shard_block_body(state: BeaconState, shard_state: ShardState, block:
# Verify block body size is a multiple of the header size
assert len(block.body) % SHARD_HEADER_SIZE == 0
# Apply proposer block body fee
proposer_index = get_shard_proposer_index(state, state.shard, block.slot)
proposer_index = get_shard_proposer_index(state, shard_state.shard, block.slot)
block_body_fee = state.block_body_price * len(block.body) // MAX_SHARD_BLOCK_SIZE
process_delta(state, shard_state, proposer_index, -block_body_fee) # Burn
process_delta(state, shard_state, proposer_index, block_body_fee // PROPOSER_REWARD_QUOTIENT) # Reward
# Calculate new block body price
block_size = SHARD_HEADER_SIZE + len(block.body)
QUOTIENT = MAX_SHARD_BLOCK_SIZE * BLOCK_BODY_PRICE_QUOTIENT
price_delta = GweiDelta(state.block_body_price * (block_size - SHARD_BLOCK_SIZE_TARGET) // QUOTIENT)
price_delta = GweiDelta(shard_state.block_body_price * (block_size - SHARD_BLOCK_SIZE_TARGET) // QUOTIENT)
if price_delta > 0:
# The maximum block body price caps the amount burnt on fees within a period
MAX_BLOCK_BODY_PRICE = MAX_EFFECTIVE_BALANCE // EPOCHS_PER_SHARD_PERIOD // SHARD_SLOTS_PER_EPOCH
state.block_body_price = Gwei(min(MAX_BLOCK_BODY_PRICE, state.block_body_price + price_delta))
shard_state.block_body_price = Gwei(min(MAX_BLOCK_BODY_PRICE, shard_state.block_body_price + price_delta))
else:
state.block_body_price = Gwei(max(MIN_BLOCK_BODY_PRICE, state.block_body_price + price_delta))
shard_state.block_body_price = Gwei(max(MIN_BLOCK_BODY_PRICE, shard_state.block_body_price + price_delta))
```
## Shard fork choice rule