attestationutil

Documentation

Overview

Package attestationutil contains useful helpers for converting attestations into indexed form.

Index

• func AttestingIndices(bf bitfield.Bitfield, committee []uint64) []uint64
• func ConvertToIndexed(ctx context.Context, attestation *ethpb.Attestation, committee []uint64) *ethpb.IndexedAttestation
• func IsValidAttestationIndices(ctx context.Context, indexedAttestation *ethpb.IndexedAttestation) error
• func VerifyIndexedAttestationSig(ctx context.Context, indexedAtt *ethpb.IndexedAttestation, ...) error

Functions

func AttestingIndices

func AttestingIndices(bf bitfield.Bitfield, committee []uint64) []uint64

AttestingIndices returns the attesting participants indices from the attestation data. The committee is provided as an argument rather than a direct implementation from the spec definition. Having the committee as an argument allows for re-use of beacon committees when possible.

Spec pseudocode definition:

def get_attesting_indices(state: BeaconState,
                       data: AttestationData,
                       bits: Bitlist[MAX_VALIDATORS_PER_COMMITTEE]) -> Set[ValidatorIndex]:
 """
 Return the set of attesting indices corresponding to ``data`` and ``bits``.
 """
 committee = get_beacon_committee(state, data.slot, data.index)
 return set(index for i, index in enumerate(committee) if bits[i])

func ConvertToIndexed

func ConvertToIndexed(ctx context.Context, attestation *ethpb.Attestation, committee []uint64) *ethpb.IndexedAttestation

ConvertToIndexed converts attestation to (almost) indexed-verifiable form.

Note about spec pseudocode definition. The state was used by get_attesting_indices to determine the attestation committee. Now that we provide this as an argument, we no longer need to provide a state.

Spec pseudocode definition:

def get_indexed_attestation(state: BeaconState, attestation: Attestation) -> IndexedAttestation:
 """
 Return the indexed attestation corresponding to ``attestation``.
 """
 attesting_indices = get_attesting_indices(state, attestation.data, attestation.aggregation_bits)

 return IndexedAttestation(
     attesting_indices=sorted(attesting_indices),
     data=attestation.data,
     signature=attestation.signature,
 )

func IsValidAttestationIndices

func IsValidAttestationIndices(ctx context.Context, indexedAttestation *ethpb.IndexedAttestation) error

IsValidAttestationIndices this helper function performs the first part of the spec indexed attestation validation starting at Check if “indexed_attestation“ comment and ends at Verify aggregate signature comment.

Spec pseudocode definition:

def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: IndexedAttestation) -> bool:
  """
  Check if ``indexed_attestation`` has valid indices and signature.
  """
  indices = indexed_attestation.attesting_indices

  # Verify max number of indices
  if not len(indices) <= MAX_VALIDATORS_PER_COMMITTEE:
      return False
  # Verify indices are sorted and unique
      if not indices == sorted(set(indices)):
  # Verify aggregate signature
  if not bls_verify(
      pubkey=bls_aggregate_pubkeys([state.validators[i].pubkey for i in indices]),
      message_hash=hash_tree_root(indexed_attestation.data),
      signature=indexed_attestation.signature,
      domain=get_domain(state, DOMAIN_BEACON_ATTESTER, indexed_attestation.data.target.epoch),
  ):
      return False
  return True

func VerifyIndexedAttestationSig

func VerifyIndexedAttestationSig(ctx context.Context, indexedAtt *ethpb.IndexedAttestation, pubKeys []*bls.PublicKey, domain []byte) error

VerifyIndexedAttestationSig this helper function performs the last part of the spec indexed attestation validation starting at Verify aggregate signature comment.

Spec pseudocode definition:

def is_valid_indexed_attestation(state: BeaconState, indexed_attestation: IndexedAttestation) -> bool:
   """
   Check if ``indexed_attestation`` has sorted and unique indices and a valid aggregate signature.
   """
   # Verify indices are sorted and unique
   indices = indexed_attestation.attesting_indices
   if 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)