feat: Support DENEB (#235)

* feat: Support DENEB

* chore: linting

pkg/cannon/deriver/beacon/eth/v2/attester_slashing.go

@@ -230,7 +230,12 @@ func (a *AttesterSlashingDeriver) processSlot(ctx context.Context, slot phase0.S
 
  events := []*xatu.DecoratedEvent{}
 
- for _, slashing := range a.getAttesterSlashings(ctx, block) {
+ slashings, err := a.getAttesterSlashings(ctx, block)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get attester slashings for slot %d", slot)
+ }
+
+ for _, slashing := range slashings {
  event, err := a.createEvent(ctx, slashing, blockIdentifier)
  if err != nil {
  a.log.WithError(err).Error("Failed to create event")
@@ -244,12 +249,12 @@ func (a *AttesterSlashingDeriver) processSlot(ctx context.Context, slot phase0.S
  return events, nil
 }
 
-func (a *AttesterSlashingDeriver) getAttesterSlashings(ctx context.Context, block *spec.VersionedSignedBeaconBlock) []*xatuethv1.AttesterSlashingV2 {
+func (a *AttesterSlashingDeriver) getAttesterSlashings(ctx context.Context, block *spec.VersionedSignedBeaconBlock) ([]*xatuethv1.AttesterSlashingV2, error) {
  slashings := []*xatuethv1.AttesterSlashingV2{}
 
  attesterSlashings, err := block.AttesterSlashings()
  if err != nil {
- a.log.WithError(err).Error("Failed to obtain attester slashings")
+ return nil, errors.Wrap(err, "failed to obtain attester slashings")
  }
 
  for _, slashing := range attesterSlashings {
@@ -259,7 +264,7 @@ func (a *AttesterSlashingDeriver) getAttesterSlashings(ctx context.Context, bloc
  })
  }
 
- return slashings
+ return slashings, nil
 }
 
 func convertIndexedAttestation(attestation *phase0.IndexedAttestation) *xatuethv1.IndexedAttestationV2 {

pkg/cannon/deriver/beacon/eth/v2/beacon_block.go

@@ -369,6 +369,13 @@ func (b *BeaconBlockDeriver) getAdditionalData(_ context.Context, block *spec.Ve
  }
 
  addTxData(capellaTxs)
+ case spec.DataVersionDeneb:
+ denebTxs := make([][]byte, len(block.Deneb.Message.Body.ExecutionPayload.Transactions))
+ for i, tx := range block.Deneb.Message.Body.ExecutionPayload.Transactions {
+ denebTxs[i] = tx
+ }
+
+ addTxData(denebTxs)
  }
 
  compressedTransactions := snappy.Encode(nil, transactionsBytes)

pkg/cannon/deriver/beacon/eth/v2/bls_to_execution_change.go

@@ -253,26 +253,20 @@ func (b *BLSToExecutionChangeDeriver) processSlot(ctx context.Context, slot phas
 func (b *BLSToExecutionChangeDeriver) getBLSToExecutionChanges(ctx context.Context, block *spec.VersionedSignedBeaconBlock) ([]*xatuethv2.SignedBLSToExecutionChangeV2, error) {
  changes := []*xatuethv2.SignedBLSToExecutionChangeV2{}
 
- switch block.Version {
- case spec.DataVersionPhase0:
- return changes, nil
- case spec.DataVersionAltair:
- return changes, nil
- case spec.DataVersionBellatrix:
- return changes, nil
- case spec.DataVersionCapella:
- for _, change := range block.Capella.Message.Body.BLSToExecutionChanges {
- changes = append(changes, &xatuethv2.SignedBLSToExecutionChangeV2{
- Message: &xatuethv2.BLSToExecutionChangeV2{
- ValidatorIndex: wrapperspb.UInt64(uint64(change.Message.ValidatorIndex)),
- FromBlsPubkey: change.Message.FromBLSPubkey.String(),
- ToExecutionAddress: change.Message.ToExecutionAddress.String(),
- },
- Signature: change.Signature.String(),
- })
- }
- default:
- return nil, fmt.Errorf("unsupported block version: %s", block.Version.String())
+ chs, err := block.BLSToExecutionChanges()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to obtain BLS to execution changes")
+ }
+
+ for _, change := range chs {
+ changes = append(changes, &xatuethv2.SignedBLSToExecutionChangeV2{
+ Message: &xatuethv2.BLSToExecutionChangeV2{
+ ValidatorIndex: wrapperspb.UInt64(uint64(change.Message.ValidatorIndex)),
+ FromBlsPubkey: change.Message.FromBLSPubkey.String(),
+ ToExecutionAddress: change.Message.ToExecutionAddress.String(),
+ },
+ Signature: change.Signature.String(),
+ })
  }
 
  return changes, nil

pkg/cannon/deriver/beacon/eth/v2/deposit.go

@@ -249,30 +249,20 @@ func (b *DepositDeriver) processSlot(ctx context.Context, slot phase0.Slot) ([]*
 }
 
 func (b *DepositDeriver) getDeposits(ctx context.Context, block *spec.VersionedSignedBeaconBlock) ([]*xatuethv1.DepositV2, error) {
- exits := []*xatuethv1.DepositV2{}
-
- var deposits []*phase0.Deposit
-
- switch block.Version {
- case spec.DataVersionPhase0:
- deposits = block.Phase0.Message.Body.Deposits
- case spec.DataVersionAltair:
- deposits = block.Altair.Message.Body.Deposits
- case spec.DataVersionBellatrix:
- deposits = block.Bellatrix.Message.Body.Deposits
- case spec.DataVersionCapella:
- deposits = block.Capella.Message.Body.Deposits
- default:
- return nil, fmt.Errorf("unsupported block version: %s", block.Version.String())
+ deposits := []*xatuethv1.DepositV2{}
+
+ dps, err := block.Deposits()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to obtain deposits")
  }
 
- for _, deposit := range deposits {
+ for _, deposit := range dps {
  proof := []string{}
  for _, p := range deposit.Proof {
  proof = append(proof, fmt.Sprintf("0x%x", p))
  }
 
- exits = append(exits, &xatuethv1.DepositV2{
+ deposits = append(deposits, &xatuethv1.DepositV2{
  Proof: proof,
  Data: &xatuethv1.DepositV2_Data{
  Pubkey: deposit.Data.PublicKey.String(),
@@ -283,7 +273,7 @@ func (b *DepositDeriver) getDeposits(ctx context.Context, block *spec.VersionedS
  })
  }
 
- return exits, nil
+ return deposits, nil
 }
 
 func (b *DepositDeriver) createEvent(ctx context.Context, deposit *xatuethv1.DepositV2, identifier *xatu.BlockIdentifier) (*xatu.DecoratedEvent, error) {

pkg/cannon/deriver/beacon/eth/v2/execution_transaction.go

@@ -289,31 +289,16 @@ func (b *ExecutionTransactionDeriver) processSlot(ctx context.Context, slot phas
 func (b *ExecutionTransactionDeriver) getExecutionTransactions(ctx context.Context, block *spec.VersionedSignedBeaconBlock) ([]*types.Transaction, error) {
  transactions := []*types.Transaction{}
 
- switch block.Version {
- case spec.DataVersionPhase0:
- return transactions, nil
- case spec.DataVersionAltair:
- return transactions, nil
- case spec.DataVersionBellatrix:
- for _, transaction := range block.Bellatrix.Message.Body.ExecutionPayload.Transactions {
- ethTransaction := new(types.Transaction)
- if err := ethTransaction.UnmarshalBinary(transaction); err != nil {
- return nil, fmt.Errorf("failed to unmarshal transaction: %v", err)
- }
-
- transactions = append(transactions, ethTransaction)
- }
- case spec.DataVersionCapella:
- for _, transaction := range block.Capella.Message.Body.ExecutionPayload.Transactions {
- ethTransaction := new(types.Transaction)
- if err := ethTransaction.UnmarshalBinary(transaction); err != nil {
- return nil, fmt.Errorf("failed to unmarshal transaction: %v", err)
- }
+ txs, err := block.ExecutionTransactions()
+ if err != nil {
+ return nil, fmt.Errorf("failed to get execution transactions: %v", err)
+ }
 
- transactions = append(transactions, ethTransaction)
+ for _, transaction := range txs {
+ ethTransaction := new(types.Transaction)
+ if err := ethTransaction.UnmarshalBinary(transaction); err != nil {
+ return nil, fmt.Errorf("failed to unmarshal transaction: %v", err)
  }
- default:
- return nil, fmt.Errorf("unsupported block version: %s", block.Version.String())
  }
 
  return transactions, nil

pkg/cannon/deriver/beacon/eth/v2/voluntary_exit.go

@@ -251,19 +251,9 @@ func (b *VoluntaryExitDeriver) processSlot(ctx context.Context, slot phase0.Slot
 func (b *VoluntaryExitDeriver) getVoluntaryExits(ctx context.Context, block *spec.VersionedSignedBeaconBlock) ([]*xatuethv1.SignedVoluntaryExitV2, error) {
  exits := []*xatuethv1.SignedVoluntaryExitV2{}
 
- var voluntaryExits []*phase0.SignedVoluntaryExit
-
- switch block.Version {
- case spec.DataVersionPhase0:
- voluntaryExits = block.Phase0.Message.Body.VoluntaryExits
- case spec.DataVersionAltair:
- voluntaryExits = block.Altair.Message.Body.VoluntaryExits
- case spec.DataVersionBellatrix:
- voluntaryExits = block.Bellatrix.Message.Body.VoluntaryExits
- case spec.DataVersionCapella:
- voluntaryExits = block.Capella.Message.Body.VoluntaryExits
- default:
- return nil, fmt.Errorf("unsupported block version: %s", block.Version.String())
+ voluntaryExits, err := block.VoluntaryExits()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to obtain voluntary exits")
  }
 
  for _, exit := range voluntaryExits {

pkg/cannon/deriver/beacon/eth/v2/withdrawal.go

@@ -248,12 +248,12 @@ func (b *WithdrawalDeriver) lookAheadAtLocation(ctx context.Context, locations [
 func (b *WithdrawalDeriver) getWithdrawals(ctx context.Context, block *spec.VersionedSignedBeaconBlock) ([]*xatuethv1.WithdrawalV2, error) {
  withdrawals := []*xatuethv1.WithdrawalV2{}
 
- switch block.Version {
- case spec.DataVersionPhase0, spec.DataVersionAltair, spec.DataVersionBellatrix:
- return withdrawals, nil
+ withd, err := block.Withdrawals()
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to obtain withdrawals")
  }
 
- for _, withdrawal := range block.Capella.Message.Body.ExecutionPayload.Withdrawals {
+ for _, withdrawal := range withd {
  withdrawals = append(withdrawals, &xatuethv1.WithdrawalV2{
  Index: &wrapperspb.UInt64Value{Value: uint64(withdrawal.Index)},
  ValidatorIndex: &wrapperspb.UInt64Value{Value: uint64(withdrawal.ValidatorIndex)},

pkg/proto/eth/block.go

@@ -22,6 +22,8 @@ func NewEventBlockV2FromVersionSignedBeaconBlock(block *spec.VersionedSignedBeac
  data = NewEventBlockFromBellatrix(block)
  case spec.DataVersionCapella:
  data = NewEventBlockFromCapella(block)
+ case spec.DataVersionDeneb:
+ data = NewEventBlockFromDeneb(block)
  default:
  return nil, fmt.Errorf("unsupported block version: %v", block.Version)
  }
@@ -200,3 +202,63 @@ func NewEventBlockFromCapella(block *spec.VersionedSignedBeaconBlock) *v2.EventB
  Signature: block.Capella.Signature.String(),
  }
 }
+
+func NewEventBlockFromDeneb(block *spec.VersionedSignedBeaconBlock) *v2.EventBlockV2 {
+ kzgCommitments := []string{}
+
+ for _, commitment := range block.Deneb.Message.Body.BlobKzgCommitments {
+ kzgCommitments = append(kzgCommitments, commitment.String())
+ }
+
+ return &v2.EventBlockV2{
+ Version: v2.BlockVersion_DENEB,
+ Message: &v2.EventBlockV2_DenebBlock{
+ DenebBlock: &v2.BeaconBlockDeneb{
+ Slot: &wrapperspb.UInt64Value{Value: uint64(block.Deneb.Message.Slot)},
+ ProposerIndex: &wrapperspb.UInt64Value{Value: uint64(block.Deneb.Message.ProposerIndex)},
+ ParentRoot: block.Deneb.Message.ParentRoot.String(),
+ StateRoot: block.Deneb.Message.StateRoot.String(),
+ Body: &v2.BeaconBlockBodyDeneb{
+ RandaoReveal: block.Deneb.Message.Body.RANDAOReveal.String(),
+ Eth1Data: &v1.Eth1Data{
+ DepositRoot: block.Deneb.Message.Body.ETH1Data.DepositRoot.String(),
+ DepositCount: block.Deneb.Message.Body.ETH1Data.DepositCount,
+ BlockHash: fmt.Sprintf("0x%x", block.Deneb.Message.Body.ETH1Data.BlockHash),
+ },
+ Graffiti: fmt.Sprintf("0x%x", block.Deneb.Message.Body.Graffiti[:]),
+ ProposerSlashings: v1.NewProposerSlashingsFromPhase0(block.Deneb.Message.Body.ProposerSlashings),
+ AttesterSlashings: v1.NewAttesterSlashingsFromPhase0(block.Deneb.Message.Body.AttesterSlashings),
+ Attestations: v1.NewAttestationsFromPhase0(block.Deneb.Message.Body.Attestations),
+ Deposits: v1.NewDepositsFromPhase0(block.Deneb.Message.Body.Deposits),
+ VoluntaryExits: v1.NewSignedVoluntaryExitsFromPhase0(block.Deneb.Message.Body.VoluntaryExits),
+ SyncAggregate: &v1.SyncAggregate{
+ SyncCommitteeBits: fmt.Sprintf("0x%x", block.Deneb.Message.Body.SyncAggregate.SyncCommitteeBits),
+ SyncCommitteeSignature: block.Deneb.Message.Body.SyncAggregate.SyncCommitteeSignature.String(),
+ },
+ ExecutionPayload: &v1.ExecutionPayloadDeneb{
+ ParentHash: block.Deneb.Message.Body.ExecutionPayload.ParentHash.String(),
+ FeeRecipient: block.Deneb.Message.Body.ExecutionPayload.FeeRecipient.String(),
+ StateRoot: fmt.Sprintf("0x%x", block.Deneb.Message.Body.ExecutionPayload.StateRoot[:]),
+ ReceiptsRoot: fmt.Sprintf("0x%x", block.Deneb.Message.Body.ExecutionPayload.ReceiptsRoot[:]),
+ LogsBloom: fmt.Sprintf("0x%x", block.Deneb.Message.Body.ExecutionPayload.LogsBloom[:]),
+ PrevRandao: fmt.Sprintf("0x%x", block.Deneb.Message.Body.ExecutionPayload.PrevRandao[:]),
+ BlockNumber: &wrapperspb.UInt64Value{Value: block.Deneb.Message.Body.ExecutionPayload.BlockNumber},
+ GasLimit: &wrapperspb.UInt64Value{Value: block.Deneb.Message.Body.ExecutionPayload.GasLimit},
+ GasUsed: &wrapperspb.UInt64Value{Value: block.Deneb.Message.Body.ExecutionPayload.GasUsed},
+ Timestamp: &wrapperspb.UInt64Value{Value: block.Deneb.Message.Body.ExecutionPayload.Timestamp},
+ ExtraData: fmt.Sprintf("0x%x", block.Deneb.Message.Body.ExecutionPayload.ExtraData),
+ BaseFeePerGas: fmt.Sprintf("0x%x", block.Deneb.Message.Body.ExecutionPayload.BaseFeePerGas[:]),
+ BlockHash: block.Deneb.Message.Body.ExecutionPayload.BlockHash.String(),
+ Transactions: getTransactions(block.Deneb.Message.Body.ExecutionPayload.Transactions),
+ Withdrawals: v1.NewWithdrawalsFromCapella(block.Deneb.Message.Body.ExecutionPayload.Withdrawals),
+ BlobGasUsed: &wrapperspb.UInt64Value{Value: block.Deneb.Message.Body.ExecutionPayload.BlobGasUsed},
+ ExcessBlobGas: &wrapperspb.UInt64Value{Value: block.Deneb.Message.Body.ExecutionPayload.ExcessBlobGas},
+ },
+ BlsToExecutionChanges: v2.NewBLSToExecutionChangesFromCapella(block.Deneb.Message.Body.BLSToExecutionChanges),
+ BlobKzgCommitments: kzgCommitments,
+ },
+ },
+ },
+ Signature: block.Deneb.Signature.String(),
+ }
+}