blocks

package
v1.3.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 19, 2021 License: GPL-3.0 Imports: 27 Imported by: 79

Documentation

Overview

Package blocks contains block processing libraries according to the eth2spec.

Index

Constants

This section is empty.

Variables

View Source 
var ValidatorAlreadyExitedMsg = "has already submitted an exit, which will take place at epoch"

ValidatorAlreadyExitedMsg defines a message saying that a validator has already exited.

View Source 
var ValidatorCannotExitYetMsg = "validator has not been active long enough to exit"

ValidatorCannotExitYetMsg defines a message saying that a validator cannot exit because it has not been active long enough.

Functions

func AreEth1DataEqual added in v1.0.0 

func AreEth1DataEqual(a, b *ethpb.Eth1Data) bool

AreEth1DataEqual checks equality between two eth1 data objects.

func AttestationSignatureSet added in v1.0.0 

func AttestationSignatureSet(ctx context.Context, beaconState iface.ReadOnlyBeaconState, atts []*ethpb.Attestation) (*bls.SignatureSet, error)

AttestationSignatureSet retrieves all the related attestation signature data such as the relevant public keys, signatures and attestation signing data and collate it into a signature set object.

func BlockSignatureSet added in v1.0.0 

func BlockSignatureSet(beaconState iface.ReadOnlyBeaconState, block *ethpb.SignedBeaconBlock) (*bls.SignatureSet, error)

BlockSignatureSet retrieves the block signature set from the provided block and its corresponding state.

func Eth1DataHasEnoughSupport 

func Eth1DataHasEnoughSupport(beaconState iface.ReadOnlyBeaconState, data *ethpb.Eth1Data) (bool, error)

Eth1DataHasEnoughSupport returns true when the given eth1data has more than 50% votes in the eth1 voting period. A vote is cast by including eth1data in a block and part of state processing appends eth1data to the state in the Eth1DataVotes list. Iterating through this list checks the votes to see if they match the eth1data.

func IsSlashableAttestationData 

func IsSlashableAttestationData(data1, data2 *ethpb.AttestationData) bool

IsSlashableAttestationData verifies a slashing against the Casper Proof of Stake FFG rules.

Spec pseudocode definition: 

def is_slashable_attestation_data(data_1: AttestationData, data_2: AttestationData) -> bool:
 """
 Check if ``data_1`` and ``data_2`` are slashable according to Casper FFG rules.
 """
 return (
     # Double vote
     (data_1 != data_2 and data_1.target.epoch == data_2.target.epoch) or
     # Surround vote
     (data_1.source.epoch < data_2.source.epoch and data_2.target.epoch < data_1.target.epoch)
 )

func NewGenesisBlock 

func NewGenesisBlock(stateRoot []byte) *ethpb.SignedBeaconBlock

NewGenesisBlock returns the canonical, genesis block for the beacon chain protocol.

func ProcessAttestation 

func ProcessAttestation(
	ctx context.Context,
	beaconState iface.BeaconState,
	att *ethpb.Attestation,
) (iface.BeaconState, error)

ProcessAttestation verifies an input attestation can pass through processing using the given beacon state.

Spec pseudocode definition: 

def process_attestation(state: BeaconState, attestation: Attestation) -> None:
  data = attestation.data
  assert data.target.epoch in (get_previous_epoch(state), get_current_epoch(state))
  assert data.target.epoch == compute_epoch_at_slot(data.slot)
  assert data.slot + MIN_ATTESTATION_INCLUSION_DELAY <= state.slot <= data.slot + SLOTS_PER_EPOCH
  assert data.index < get_committee_count_per_slot(state, data.target.epoch)

  committee = get_beacon_committee(state, data.slot, data.index)
  assert len(attestation.aggregation_bits) == len(committee)

  pending_attestation = PendingAttestation(
      data=data,
      aggregation_bits=attestation.aggregation_bits,
      inclusion_delay=state.slot - data.slot,
      proposer_index=get_beacon_proposer_index(state),
  )

  if data.target.epoch == get_current_epoch(state):
      assert data.source == state.current_justified_checkpoint
      state.current_epoch_attestations.append(pending_attestation)
  else:
      assert data.source == state.previous_justified_checkpoint
      state.previous_epoch_attestations.append(pending_attestation)

  # Check signature
  assert is_valid_indexed_attestation(state, get_indexed_attestation(state, attestation))

func ProcessAttestationNoVerifySignature added in v1.0.0 

func ProcessAttestationNoVerifySignature(
	ctx context.Context,
	beaconState iface.BeaconState,
	att *ethpb.Attestation,
) (iface.BeaconState, error)

ProcessAttestationNoVerifySignature processes the attestation without verifying the attestation signature. This method is used to validate attestations whose signatures have already been verified.

func ProcessAttestations 

func ProcessAttestations(
	ctx context.Context,
	beaconState iface.BeaconState,
	b *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessAttestations applies processing operations to a block's inner attestation records.

func ProcessAttestationsNoVerifySignature added in v1.0.0 

func ProcessAttestationsNoVerifySignature(
	ctx context.Context,
	beaconState iface.BeaconState,
	b *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessAttestationsNoVerifySignature applies processing operations to a block's inner attestation records. The only difference would be that the attestation signature would not be verified.

func ProcessAttesterSlashings 

func ProcessAttesterSlashings(
	ctx context.Context,
	beaconState iface.BeaconState,
	b *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessAttesterSlashings is one of the operations performed on each processed beacon block to slash attesters based on Casper FFG slashing conditions if any slashable events occurred.

Spec pseudocode definition: 

def process_attester_slashing(state: BeaconState, attester_slashing: AttesterSlashing) -> None:
 attestation_1 = attester_slashing.attestation_1
 attestation_2 = attester_slashing.attestation_2
 assert is_slashable_attestation_data(attestation_1.data, attestation_2.data)
 assert is_valid_indexed_attestation(state, attestation_1)
 assert is_valid_indexed_attestation(state, attestation_2)

 slashed_any = False
 indices = set(attestation_1.attesting_indices).intersection(attestation_2.attesting_indices)
 for index in sorted(indices):
     if is_slashable_validator(state.validators[index], get_current_epoch(state)):
         slash_validator(state, index)
         slashed_any = True
 assert slashed_any

func ProcessBlockHeader 

func ProcessBlockHeader(
	_ context.Context,
	beaconState iface.BeaconState,
	block *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessBlockHeader validates a block by its header.

Spec pseudocode definition: 

 def process_block_header(state: BeaconState, block: BeaconBlock) -> None:
   # Verify that the slots match
   assert block.slot == state.slot
    # Verify that proposer index is the correct index
   assert block.proposer_index == get_beacon_proposer_index(state)
   # Verify that the parent matches
   assert block.parent_root == hash_tree_root(state.latest_block_header)
   # Save current block as the new latest block
   state.latest_block_header = BeaconBlockHeader(
       slot=block.slot,
       parent_root=block.parent_root,
       # state_root: zeroed, overwritten in the next `process_slot` call
       body_root=hash_tree_root(block.body),
		  # signature is always zeroed
   )
   # Verify proposer is not slashed
   proposer = state.validators[get_beacon_proposer_index(state)]
   assert not proposer.slashed
   # Verify proposer signature
   assert bls_verify(proposer.pubkey, signing_root(block), block.signature, get_domain(state, DOMAIN_BEACON_PROPOSER))

func ProcessBlockHeaderNoVerify 

func ProcessBlockHeaderNoVerify(
	beaconState iface.BeaconState,
	block *ethpb.BeaconBlock,
) (iface.BeaconState, error)

ProcessBlockHeaderNoVerify validates a block by its header but skips proposer signature verification.

WARNING: This method does not verify proposer signature. This is used for proposer to compute state root using a unsigned block.

Spec pseudocode definition: 

 def process_block_header(state: BeaconState, block: BeaconBlock) -> None:
   # Verify that the slots match
   assert block.slot == state.slot
    # Verify that proposer index is the correct index
   assert block.proposer_index == get_beacon_proposer_index(state)
   # Verify that the parent matches
   assert block.parent_root == hash_tree_root(state.latest_block_header)
   # Save current block as the new latest block
   state.latest_block_header = BeaconBlockHeader(
       slot=block.slot,
       parent_root=block.parent_root,
       # state_root: zeroed, overwritten in the next `process_slot` call
       body_root=hash_tree_root(block.body),
		  # signature is always zeroed
   )
   # Verify proposer is not slashed
   proposer = state.validators[get_beacon_proposer_index(state)]
   assert not proposer.slashed

func ProcessDeposit 

func ProcessDeposit(beaconState iface.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (iface.BeaconState, error)

ProcessDeposit takes in a deposit object and inserts it into the registry as a new validator or balance change.

Spec pseudocode definition: def process_deposit(state: BeaconState, deposit: Deposit) -> None: 

# Verify the Merkle branch
assert is_valid_merkle_branch(
    leaf=hash_tree_root(deposit.data),
    branch=deposit.proof,
    depth=DEPOSIT_CONTRACT_TREE_DEPTH + 1,  # Add 1 for the List length mix-in
    index=state.eth1_deposit_index,
    root=state.eth1_data.deposit_root,
)

# Deposits must be processed in order
state.eth1_deposit_index += 1

pubkey = deposit.data.pubkey
amount = deposit.data.amount
validator_pubkeys = [v.pubkey for v in state.validators]
if pubkey not in validator_pubkeys:
    # Verify the deposit signature (proof of possession) which is not checked by the deposit contract
    deposit_message = DepositMessage(
        pubkey=deposit.data.pubkey,
        withdrawal_credentials=deposit.data.withdrawal_credentials,
        amount=deposit.data.amount,
    )
    domain = compute_domain(DOMAIN_DEPOSIT)  # Fork-agnostic domain since deposits are valid across forks
    signing_root = compute_signing_root(deposit_message, domain)
    if not bls.Verify(pubkey, signing_root, deposit.data.signature):
        return

    # Add validator and balance entries
    state.validators.append(get_validator_from_deposit(state, deposit))
    state.balances.append(amount)
else:
    # Increase balance by deposit amount
    index = ValidatorIndex(validator_pubkeys.index(pubkey))
    increase_balance(state, index, amount)

func ProcessDeposits 

func ProcessDeposits(
	ctx context.Context,
	beaconState iface.BeaconState,
	b *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessDeposits is one of the operations performed on each processed beacon block to verify queued validators from the Ethereum 1.0 Deposit Contract into the beacon chain.

Spec pseudocode definition: 

For each deposit in block.body.deposits:
  process_deposit(state, deposit)

func ProcessEth1DataInBlock 

func ProcessEth1DataInBlock(_ context.Context, beaconState iface.BeaconState, b *ethpb.SignedBeaconBlock) (iface.BeaconState, error)

ProcessEth1DataInBlock is an operation performed on each beacon block to ensure the ETH1 data votes are processed into the beacon state.

Official spec definition: 

def process_eth1_data(state: BeaconState, body: BeaconBlockBody) -> None:
 state.eth1_data_votes.append(body.eth1_data)
 if state.eth1_data_votes.count(body.eth1_data) * 2 > EPOCHS_PER_ETH1_VOTING_PERIOD * SLOTS_PER_EPOCH:
     state.latest_eth1_data = body.eth1_data

func ProcessPreGenesisDeposits added in v1.0.0 

func ProcessPreGenesisDeposits(
	ctx context.Context,
	beaconState iface.BeaconState,
	deposits []*ethpb.Deposit,
) (iface.BeaconState, error)

ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.

func ProcessProposerSlashings 

func ProcessProposerSlashings(
	_ context.Context,
	beaconState iface.BeaconState,
	b *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessProposerSlashings is one of the operations performed on each processed beacon block to slash proposers based on slashing conditions if any slashable events occurred.

Spec pseudocode definition: 

def process_proposer_slashing(state: BeaconState, proposer_slashing: ProposerSlashing) -> None:
 """
 Process ``ProposerSlashing`` operation.
 """
 proposer = state.validator_registry[proposer_slashing.proposer_index]
 # Verify slots match
 assert proposer_slashing.header_1.slot == proposer_slashing.header_2.slot
 # But the headers are different
 assert proposer_slashing.header_1 != proposer_slashing.header_2
 # Check proposer is slashable
 assert is_slashable_validator(proposer, get_current_epoch(state))
 # Signatures are valid
 for header in (proposer_slashing.header_1, proposer_slashing.header_2):
     domain = get_domain(state, DOMAIN_BEACON_PROPOSER, slot_to_epoch(header.slot))
     assert bls_verify(proposer.pubkey, signing_root(header), header.signature, domain)

 slash_validator(state, proposer_slashing.proposer_index)

func ProcessRandao 

func ProcessRandao(
	_ context.Context,
	beaconState iface.BeaconState,
	b *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessRandao checks the block proposer's randao commitment and generates a new randao mix to update in the beacon state's latest randao mixes slice.

Spec pseudocode definition: 

def process_randao(state: BeaconState, body: BeaconBlockBody) -> None:
 epoch = get_current_epoch(state)
 # Verify RANDAO reveal
 proposer = state.validators[get_beacon_proposer_index(state)]
 signing_root = compute_signing_root(epoch, get_domain(state, DOMAIN_RANDAO))
 assert bls.Verify(proposer.pubkey, signing_root, body.randao_reveal)
 # Mix in RANDAO reveal
 mix = xor(get_randao_mix(state, epoch), hash(body.randao_reveal))
 state.randao_mixes[epoch % EPOCHS_PER_HISTORICAL_VECTOR] = mix

func ProcessRandaoNoVerify 

func ProcessRandaoNoVerify(
	beaconState iface.BeaconState,
	body *ethpb.BeaconBlockBody,
) (iface.BeaconState, error)

ProcessRandaoNoVerify generates a new randao mix to update in the beacon state's latest randao mixes slice.

Spec pseudocode definition: 

# Mix it in
state.latest_randao_mixes[get_current_epoch(state) % LATEST_RANDAO_MIXES_LENGTH] = (
    xor(get_randao_mix(state, get_current_epoch(state)),
        hash(body.randao_reveal))
)

func ProcessVoluntaryExits 

func ProcessVoluntaryExits(
	_ context.Context,
	beaconState iface.BeaconState,
	b *ethpb.SignedBeaconBlock,
) (iface.BeaconState, error)

ProcessVoluntaryExits is one of the operations performed on each processed beacon block to determine which validators should exit the state's validator registry.

Spec pseudocode definition: 

def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
 """
 Process ``VoluntaryExit`` operation.
 """
 validator = state.validator_registry[exit.validator_index]
 # Verify the validator is active
 assert is_active_validator(validator, get_current_epoch(state))
 # Verify the validator has not yet exited
 assert validator.exit_epoch == FAR_FUTURE_EPOCH
 # Exits must specify an epoch when they become valid; they are not valid before then
 assert get_current_epoch(state) >= exit.epoch
 # Verify the validator has been active long enough
 assert get_current_epoch(state) >= validator.activation_epoch + PERSISTENT_COMMITTEE_PERIOD
 # Verify signature
 domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, exit.epoch)
 assert bls_verify(validator.pubkey, signing_root(exit), exit.signature, domain)
 # Initiate exit
 initiate_validator_exit(state, exit.validator_index)

func RandaoSignatureSet added in v1.0.0 

func RandaoSignatureSet(beaconState iface.ReadOnlyBeaconState,
	body *ethpb.BeaconBlockBody,
) (*bls.SignatureSet, error)

RandaoSignatureSet retrieves the relevant randao specific signature set object from a block and its corresponding state.

func VerifyAttestationNoVerifySignature added in v1.3.3 

func VerifyAttestationNoVerifySignature(
	ctx context.Context,
	beaconState iface.ReadOnlyBeaconState,
	att *ethpb.Attestation,
) error

VerifyAttestationNoVerifySignature verifies the attestation without verifying the attestation signature. This is used before processing attestation with the beacon state.

func VerifyAttestationSignature added in v1.0.0 

func VerifyAttestationSignature(ctx context.Context, beaconState iface.ReadOnlyBeaconState, att *ethpb.Attestation) error

VerifyAttestationSignature converts and attestation into an indexed attestation and verifies the signature in that attestation.

func VerifyAttesterSlashing 

func VerifyAttesterSlashing(ctx context.Context, beaconState iface.ReadOnlyBeaconState, slashing *ethpb.AttesterSlashing) error

VerifyAttesterSlashing validates the attestation data in both attestations in the slashing object.

func VerifyBlockSignature added in v1.0.0 

func VerifyBlockSignature(beaconState iface.ReadOnlyBeaconState, block *ethpb.SignedBeaconBlock) error

VerifyBlockSignature verifies the proposer signature of a beacon block.

func VerifyExitAndSignature added in v1.0.0 

func VerifyExitAndSignature(validator iface.ReadOnlyValidator, currentSlot types.Slot, fork *pb.Fork, signed *ethpb.SignedVoluntaryExit, genesisRoot []byte) error

VerifyExitAndSignature implements the spec defined validation for voluntary exits.

Spec pseudocode definition: 

def process_voluntary_exit(state: BeaconState, exit: VoluntaryExit) -> None:
 """
 Process ``VoluntaryExit`` operation.
 """
 validator = state.validator_registry[exit.validator_index]
 # Verify the validator is active
 assert is_active_validator(validator, get_current_epoch(state))
 # Verify the validator has not yet exited
 assert validator.exit_epoch == FAR_FUTURE_EPOCH
 # Exits must specify an epoch when they become valid; they are not valid before then
 assert get_current_epoch(state) >= exit.epoch
 # Verify the validator has been active long enough
 assert get_current_epoch(state) >= validator.activation_epoch + PERSISTENT_COMMITTEE_PERIOD
 # Verify signature
 domain = get_domain(state, DOMAIN_VOLUNTARY_EXIT, exit.epoch)
 assert bls_verify(validator.pubkey, signing_root(exit), exit.signature, domain)

func VerifyIndexedAttestation 

func VerifyIndexedAttestation(ctx context.Context, beaconState iface.ReadOnlyBeaconState, indexedAtt *ethpb.IndexedAttestation) error

VerifyIndexedAttestation determines the validity of an indexed attestation.

Spec pseudocode definition: 

def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: IndexedAttestation) -> bool:
  """
  Check if ``indexed_attestation`` is not empty, has sorted and unique indices and has a valid aggregate signature.
  """
  # Verify indices are sorted and unique
  indices = indexed_attestation.attesting_indices
  if len(indices) == 0 or not indices == sorted(set(indices)):
      return False
  # Verify aggregate signature
  pubkeys = [state.validators[i].pubkey for i in indices]
  domain = get_domain(state, DOMAIN_BEACON_ATTESTER, indexed_attestation.data.target.epoch)
  signing_root = compute_signing_root(indexed_attestation.data, domain)
  return bls.FastAggregateVerify(pubkeys, signing_root, indexed_attestation.signature)

func VerifyProposerSlashing 

func VerifyProposerSlashing(
	beaconState iface.BeaconState,
	slashing *ethpb.ProposerSlashing,
) error

VerifyProposerSlashing verifies that the data provided from slashing is valid.

Types

This section is empty.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.