Implement PeerDAS related helper methods

Author: 0x00101010

beacon-chain/core/peerdas/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "p2p_interface.go",
         "peer_sampling.go",
         "reconstruction.go",
+        "util.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas",
     visibility = ["//visibility:public"],
@@ -24,6 +25,7 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",

beacon-chain/core/peerdas/das_core.go

@@ -1,7 +1,6 @@
 package peerdas
 
 import (
-	"context"
 	"encoding/binary"
 	"math"
 	"slices"
@@ -20,7 +19,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"golang.org/x/sync/errgroup"
 )
 
 var (
@@ -107,57 +105,34 @@ func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 
 // DataColumnSidecars computes the data column sidecars from the signed block and blobs.
 // https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/das-core.md#get_data_column_sidecars
-func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs []kzg.Blob) ([]*ethpb.DataColumnSidecar, error) {
-	startTime := time.Now()
-	blobsCount := len(blobs)
-	if blobsCount == 0 {
+func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsAndProofs []kzg.CellsAndProofs) ([]*ethpb.DataColumnSidecar, error) {
+	if signedBlock == nil || len(cellsAndProofs) == 0 {
 		return nil, nil
 	}
 
-	// Get the signed block header.
-	signedBlockHeader, err := signedBlock.Header()
-	if err != nil {
-		return nil, errors.Wrap(err, "signed block header")
-	}
-
-	// Get the block body.
+	start := time.Now()
 	block := signedBlock.Block()
 	blockBody := block.Body()
-
-	// Get the blob KZG commitments.
 	blobKzgCommitments, err := blockBody.BlobKzgCommitments()
 	if err != nil {
 		return nil, errors.Wrap(err, "blob KZG commitments")
 	}
 
-	// Compute the KZG commitments inclusion proof.
-	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
-	if err != nil {
-		return nil, errors.Wrap(err, "merkle proof ZKG commitments")
+	if len(blobKzgCommitments) != len(cellsAndProofs) {
+		return nil, errors.New("mismatch in the number of blob KZG commitments and cellsAndProofs")
 	}
 
-	// Compute cells and proofs.
-	cellsAndProofs := make([]kzg.CellsAndProofs, blobsCount)
-
-	eg, _ := errgroup.WithContext(context.Background())
-	for i := range blobs {
-		blobIndex := i
-		eg.Go(func() error {
-			blob := &blobs[blobIndex]
-			blobCellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(blob)
-			if err != nil {
-				return errors.Wrap(err, "compute cells and KZG proofs")
-			}
-
-			cellsAndProofs[blobIndex] = blobCellsAndProofs
-			return nil
-		})
+	signedBlockHeader, err := signedBlock.Header()
+	if err != nil {
+		return nil, errors.Wrap(err, "signed block header")
 	}
-	if err := eg.Wait(); err != nil {
-		return nil, err
+
+	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
+	if err != nil {
+		return nil, errors.Wrap(err, "merkle proof ZKG commitments")
 	}
 
-	// Get the column sidecars.
+	blobsCount := len(cellsAndProofs)
 	sidecars := make([]*ethpb.DataColumnSidecar, 0, fieldparams.NumberOfColumns)
 	for columnIndex := uint64(0); columnIndex < fieldparams.NumberOfColumns; columnIndex++ {
 		column := make([]kzg.Cell, 0, blobsCount)
@@ -196,7 +171,8 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs
 
 		sidecars = append(sidecars, sidecar)
 	}
-	dataColumnComputationTime.Observe(float64(time.Since(startTime).Milliseconds()))
+
+	dataColumnComputationTime.Observe(float64(time.Since(start).Milliseconds()))
 	return sidecars, nil
 }
 

beacon-chain/core/peerdas/das_core_test.go

@@ -17,7 +17,7 @@ import (
 
 func TestDataColumnSidecars(t *testing.T) {
 	var expected []*ethpb.DataColumnSidecar = nil
-	actual, err := peerdas.DataColumnSidecars(nil, []kzg.Blob{})
+	actual, err := peerdas.DataColumnSidecars(nil, []kzg.CellsAndProofs{})
 	require.NoError(t, err)
 
 	require.DeepSSZEqual(t, expected, actual)
@@ -139,7 +139,8 @@ func TestDataColumnsSidecarsBlobsRoundtrip(t *testing.T) {
 	}
 
 	// Compute data columns sidecars from the signed beacon block and from the blobs.
-	dataColumnsSidecar, err := peerdas.DataColumnSidecars(signedBeaconBlock, blobs)
+	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
+	dataColumnsSidecar, err := peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
 	require.NoError(t, err)
 
 	// Compute the blobs from the data columns sidecar.

beacon-chain/core/peerdas/p2p_interface_test.go

@@ -31,7 +31,8 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 	dbBlock.Block.Body.BlobKzgCommitments = comms
 	sBlock, err := blocks.NewSignedBeaconBlock(dbBlock)
 	require.NoError(t, err)
-	sCars, err := peerdas.DataColumnSidecars(sBlock, blobs)
+	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
+	sCars, err := peerdas.DataColumnSidecars(sBlock, cellsAndProofs)
 	require.NoError(t, err)
 
 	for i, sidecar := range sCars {

beacon-chain/core/peerdas/reconstruction_test.go

@@ -95,7 +95,8 @@ func TestReconstructionRoundTrip(t *testing.T) {
 	require.NoError(t, err)
 
 	// Convert data columns sidecars from signed block and blobs.
-	dataColumnSidecars, err := peerdas.DataColumnSidecars(signedBeaconBlock, blobs)
+	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
+	dataColumnSidecars, err := peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
 	require.NoError(t, err)
 
 	// Create verified RO data columns.

beacon-chain/core/peerdas/util.go

@@ -0,0 +1,49 @@
+package peerdas
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+// Helper function to unblind data column sidecars from a block and a blobs bundle v2.
+func ConstructDataColumnSidecars(block interfaces.SignedBeaconBlock, blobs [][]byte, proofs [][]byte) ([]*ethpb.DataColumnSidecar, error) {
+	// Check if the block is at least a Fulu block.
+	if block.Version() < version.Fulu {
+		return nil, nil
+	}
+
+	cellsAndProofs, err := ConstructCellsAndProofs(blobs, proofs)
+	if err != nil {
+		return nil, err
+	}
+
+	return DataColumnSidecars(block, cellsAndProofs)
+}
+
+func ConstructCellsAndProofs(blobs [][]byte, cellProofs [][]byte) ([]kzg.CellsAndProofs, error) {
+	cellsAndProofs := make([]kzg.CellsAndProofs, 0, len(blobs))
+	numColumns := int(params.BeaconConfig().NumberOfColumns)
+
+	for i, blob := range blobs {
+		var b kzg.Blob
+		copy(b[:], blob)
+		cells, err := kzg.ComputeCells(&b)
+		if err != nil {
+			return nil, err
+		}
+
+		var proofs []kzg.Proof
+		for idx := i * numColumns; idx < (i+1)*numColumns; idx++ {
+			proofs = append(proofs, kzg.Proof(cellProofs[idx]))
+		}
+		cellsAndProofs[i] = kzg.CellsAndProofs{
+			Cells:  cells,
+			Proofs: proofs,
+		}
+	}
+
+	return cellsAndProofs, nil
+}