attestation

func AttDataIsEqual ¶

func AttDataIsEqual(attData1, attData2 *ethpb.AttestationData) bool

AttDataIsEqual this function performs an equality check between 2 attestation data, if they're unequal, it will return false.

func AttestingIndices ¶

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

AttestingIndices returns the attesting participants indices from the attestation data. The committee is provided as an argument rather than a imported 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 CheckPointIsEqual ¶

func CheckPointIsEqual(checkPt1, checkPt2 *ethpb.Checkpoint) bool

CheckPointIsEqual performs an equality check between 2 check points, returns false if unequal.

func ConvertToIndexed ¶

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

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`` 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 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`` 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)