changes on data column sidecar and peerdas

Author: domiwei

cl/beacon/handler/block_production.go

@@ -1225,47 +1225,71 @@ func (a *ApiHandler) broadcastBlock(ctx context.Context, blk *cltypes.SignedBeac
 		}
 	}
 
-	if blk.Version() >= clparams.FuluVersion && blk.Block.Body.BlobKzgCommitments.Len() > 0 {
-		kzgCommitmentsCopy := solid.NewStaticListSSZ[*cltypes.KZGCommitment](cltypes.MaxBlobsCommittmentsPerBlock, length.Bytes48)
-		for i := 0; i < blk.Block.Body.BlobKzgCommitments.Len(); i++ {
-			kzgCommitmentsCopy.Append(blk.Block.Body.BlobKzgCommitments.Get(i))
-		}
-
-		// Assemble inclusion proof
-		inclusionProofRaw, err := blk.Block.Body.KzgCommitmentsInclusionProof()
-		if err != nil {
-			return err
-		}
-		commitmentInclusionProof := solid.NewHashVector(cltypes.CommitmentBranchSize)
-		for i, h := range inclusionProofRaw {
-			commitmentInclusionProof.Set(i, h)
-		}
-
-		cellsAndProofsPerBlob := make([]peerdasutils.CellsAndKZGProofs, 0, kzgCommitmentsCopy.Len())
-		for i := 0; i < kzgCommitmentsCopy.Len(); i++ {
-			commitment := kzgCommitmentsCopy.Get(i)
-			bundle, has := a.blobBundles.Get(common.Bytes48(*commitment))
-			if !has {
-				return fmt.Errorf("missing blob bundle for commitment %x", commitment)
-			}
-			cells, err := das.ComputeCells(bundle.Blob)
-			if err != nil {
-				return err
+	// Handle Fulu+ data column sidecars
+	if blk.Version() >= clparams.FuluVersion {
+		// Get kzgCommitments based on version
+		var kzgCommitments *solid.ListSSZ[*cltypes.KZGCommitment]
+		isGloas := blk.Version() >= clparams.GloasVersion
+
+		if isGloas {
+			// [New in Gloas:EIP7732] Get from signed_execution_payload_bid
+			if bid := blk.Block.Body.GetSignedExecutionPayloadBid(); bid != nil && bid.Message != nil {
+				kzgCommitments = &bid.Message.BlobKzgCommitments
 			}
+		} else {
+			// Fulu: Get from BlobKzgCommitments
+			kzgCommitments = blk.Block.Body.BlobKzgCommitments
+		}
+
+		if kzgCommitments != nil && kzgCommitments.Len() > 0 {
+			// Build cellsAndProofsPerBlob (common logic)
+			cellsAndProofsPerBlob := make([]peerdasutils.CellsAndKZGProofs, 0, kzgCommitments.Len())
+			for i := 0; i < kzgCommitments.Len(); i++ {
+				commitment := kzgCommitments.Get(i)
+				bundle, has := a.blobBundles.Get(common.Bytes48(*commitment))
+				if !has {
+					return fmt.Errorf("missing blob bundle for commitment %x", commitment)
+				}
+				cells, err := das.ComputeCells(bundle.Blob)
+				if err != nil {
+					return err
+				}
 
-			cellsAndProof := peerdasutils.CellsAndKZGProofs{}
-			for i := 0; i < len(cells); i++ {
-				cellsAndProof.Blobs = append(cellsAndProof.Blobs, cells[i])
+				cellsAndProof := peerdasutils.CellsAndKZGProofs{}
+				for i := 0; i < len(cells); i++ {
+					cellsAndProof.Blobs = append(cellsAndProof.Blobs, cells[i])
+				}
+				for j := 0; j < len(bundle.KzgProofs); j++ {
+					cellsAndProof.Proofs = append(cellsAndProof.Proofs, cltypes.KZGProof(bundle.KzgProofs[j]))
+				}
+				cellsAndProofsPerBlob = append(cellsAndProofsPerBlob, cellsAndProof)
 			}
 
-			for j := 0; j < len(bundle.KzgProofs); j++ {
-				cellsAndProof.Proofs = append(cellsAndProof.Proofs, cltypes.KZGProof(bundle.KzgProofs[j]))
+			// Create sidecars based on version
+			if isGloas {
+				blockRoot, err := blk.Block.HashSSZ()
+				if err != nil {
+					return fmt.Errorf("failed to compute block root: %w", err)
+				}
+				columnsSidecars, err = peerdasutils.GetDataColumnSidecarsGloas(blk.Block.Slot, blockRoot, cellsAndProofsPerBlob)
+				if err != nil {
+					return fmt.Errorf("failed to get data column sidecars: %w", err)
+				}
+			} else {
+				// Fulu needs inclusion proof
+				inclusionProofRaw, err := blk.Block.Body.KzgCommitmentsInclusionProof()
+				if err != nil {
+					return err
+				}
+				commitmentInclusionProof := solid.NewHashVector(cltypes.CommitmentBranchSize)
+				for i, h := range inclusionProofRaw {
+					commitmentInclusionProof.Set(i, h)
+				}
+				columnsSidecars, err = peerdasutils.GetDataColumnSidecars(header, kzgCommitments, commitmentInclusionProof, cellsAndProofsPerBlob)
+				if err != nil {
+					return fmt.Errorf("failed to get data column sidecars: %w", err)
+				}
 			}
-			cellsAndProofsPerBlob = append(cellsAndProofsPerBlob, cellsAndProof)
-		}
-		columnsSidecars, err = peerdasutils.GetDataColumnSidecars(header, kzgCommitmentsCopy, commitmentInclusionProof, cellsAndProofsPerBlob)
-		if err != nil {
-			return fmt.Errorf("failed to get data column sidecars: %w", err)
 		}
 	}
 

cl/cltypes/column_sidecar.go

@@ -33,13 +33,16 @@ var (
 
 type DataColumnSidecar struct {
 	BlockRoot                    common.Hash                    `json:"-"`
-	Slot                         uint64                         `json:"-"`
 	Index                        uint64                         `json:"index,string"` // index of the column
 	Column                       *solid.ListSSZ[*Cell]          `json:"column"`
-	KzgCommitments               *solid.ListSSZ[*KZGCommitment] `json:"kzg_commitments"`
 	KzgProofs                    *solid.ListSSZ[*KZGProof]      `json:"kzg_proofs"`
-	SignedBlockHeader            *SignedBeaconBlockHeader       `json:"signed_block_header"`
-	KzgCommitmentsInclusionProof solid.HashVectorSSZ            `json:"kzg_commitments_inclusion_proof"`
+	Slot                         uint64                         `json:"slot"`                                      // [New in Gloas:EIP7732]
+	BeaconBlockRoot              common.Hash                    `json:"beacon_block_root"`                         // [New in Gloas:EIP7732]
+	KzgCommitments               *solid.ListSSZ[*KZGCommitment] `json:"kzg_commitments,omitempty"`                 // [Removed in Gloas:EIP7732]
+	SignedBlockHeader            *SignedBeaconBlockHeader       `json:"signed_block_header,omitempty"`             // [Removed in Gloas:EIP7732]
+	KzgCommitmentsInclusionProof solid.HashVectorSSZ            `json:"kzg_commitments_inclusion_proof,omitempty"` // [Removed in Gloas:EIP7732]
+
+	version clparams.StateVersion // internal: tracks the version for encoding
 }
 
 func NewDataColumnSidecar() *DataColumnSidecar {
@@ -48,56 +51,102 @@ func NewDataColumnSidecar() *DataColumnSidecar {
 	return d
 }
 
+// NewDataColumnSidecarWithVersion creates a new DataColumnSidecar with a specific version.
+// Use this when you need version-aware encoding.
+func NewDataColumnSidecarWithVersion(version clparams.StateVersion) *DataColumnSidecar {
+	d := &DataColumnSidecar{version: version}
+	d.tryInitWithVersion(version)
+	return d
+}
+
+// Version returns the version used for encoding.
+func (d *DataColumnSidecar) Version() clparams.StateVersion {
+	return d.version
+}
+
 func (d *DataColumnSidecar) Clone() clonable.Clonable {
 	newSidecar := &DataColumnSidecar{
-		BlockRoot: d.BlockRoot,
-		Slot:      d.Slot,
+		BlockRoot:       d.BlockRoot,
+		Slot:            d.Slot,
+		BeaconBlockRoot: d.BeaconBlockRoot,
+		version:         d.version,
 	}
-	newSidecar.tryInit()
+	newSidecar.tryInitWithVersion(d.version)
 	return newSidecar
 }
 
 func (d *DataColumnSidecar) tryInit() {
+	d.tryInitWithVersion(d.version)
+}
+
+func (d *DataColumnSidecar) tryInitWithVersion(version clparams.StateVersion) {
 	cfg := clparams.GetBeaconConfig()
 	if d.Column == nil {
 		d.Column = solid.NewStaticListSSZ[*Cell](int(cfg.MaxBlobCommittmentsPerBlock), BytesPerCell)
 	}
-	if d.KzgCommitments == nil {
-		d.KzgCommitments = solid.NewStaticListSSZ[*KZGCommitment](int(cfg.MaxBlobCommittmentsPerBlock), 48)
-	}
 	if d.KzgProofs == nil {
 		d.KzgProofs = solid.NewStaticListSSZ[*KZGProof](int(cfg.MaxBlobCommittmentsPerBlock), 48)
 	}
-	if d.SignedBlockHeader == nil {
-		d.SignedBlockHeader = &SignedBeaconBlockHeader{}
-		d.SignedBlockHeader.Header = &BeaconBlockHeader{}
-	}
-	if d.KzgCommitmentsInclusionProof == nil {
-		d.KzgCommitmentsInclusionProof = solid.NewHashVector(KzgCommitmentsInclusionProofDepth)
+	// Pre-Gloas fields (Fulu and earlier)
+	if version < clparams.GloasVersion {
+		if d.KzgCommitments == nil {
+			d.KzgCommitments = solid.NewStaticListSSZ[*KZGCommitment](int(cfg.MaxBlobCommittmentsPerBlock), 48)
+		}
+		if d.SignedBlockHeader == nil {
+			d.SignedBlockHeader = &SignedBeaconBlockHeader{}
+			d.SignedBlockHeader.Header = &BeaconBlockHeader{}
+		}
+		if d.KzgCommitmentsInclusionProof == nil {
+			d.KzgCommitmentsInclusionProof = solid.NewHashVector(KzgCommitmentsInclusionProofDepth)
+		}
 	}
 }
 
 func (d *DataColumnSidecar) DecodeSSZ(buf []byte, version int) error {
-	return ssz2.UnmarshalSSZ(buf, version, d.getSchema()...)
+	d.version = clparams.StateVersion(version)
+	d.tryInitWithVersion(d.version)
+	return ssz2.UnmarshalSSZ(buf, version, d.getSchemaForVersion(d.version)...)
 }
 
 func (d *DataColumnSidecar) EncodeSSZ(buf []byte) ([]byte, error) {
-	return ssz2.MarshalSSZ(buf, d.getSchema()...)
+	return ssz2.MarshalSSZ(buf, d.getSchemaForVersion(d.version)...)
 }
 
-func (d *DataColumnSidecar) getSchema() []any {
-	d.tryInit()
+// getSchemaForVersion returns the SSZ schema for the given version.
+// Fulu and earlier: Index, Column, KzgCommitments, KzgProofs, SignedBlockHeader, KzgCommitmentsInclusionProof
+// Gloas and later: Index, Column, KzgProofs, Slot, BeaconBlockRoot
+func (d *DataColumnSidecar) getSchemaForVersion(version clparams.StateVersion) []any {
+	d.tryInitWithVersion(version)
+	if version >= clparams.GloasVersion {
+		return []any{&d.Index, d.Column, d.KzgProofs, &d.Slot, d.BeaconBlockRoot[:]}
+	}
+	// Fulu and earlier
 	return []any{&d.Index, d.Column, d.KzgCommitments, d.KzgProofs, d.SignedBlockHeader, d.KzgCommitmentsInclusionProof}
 }
 
+// getSchema returns the SSZ schema using the stored version.
+func (d *DataColumnSidecar) getSchema() []any {
+	return d.getSchemaForVersion(d.version)
+}
+
 func (d *DataColumnSidecar) EncodingSizeSSZ() int {
-	d.tryInit()
+	return d.EncodingSizeSSZForVersion(d.version)
+}
+
+// EncodingSizeSSZForVersion returns the encoding size for the given version.
+func (d *DataColumnSidecar) EncodingSizeSSZForVersion(version clparams.StateVersion) int {
+	d.tryInitWithVersion(version)
+	if version >= clparams.GloasVersion {
+		// Index (8) + Column (variable) + KzgProofs (variable) + Slot (8) + BeaconBlockRoot (32)
+		return 8 + d.Column.EncodingSizeSSZ() + d.KzgProofs.EncodingSizeSSZ() + 8 + 32
+	}
+	// Fulu and earlier
 	return 8 + d.Column.EncodingSizeSSZ() + d.KzgCommitments.EncodingSizeSSZ() + d.KzgProofs.EncodingSizeSSZ() +
 		d.SignedBlockHeader.EncodingSizeSSZ() + d.KzgCommitmentsInclusionProof.EncodingSizeSSZ()
 }
 
 func (d *DataColumnSidecar) HashSSZ() ([32]byte, error) {
-	return merkle_tree.HashTreeRoot(d.getSchema()...)
+	return merkle_tree.HashTreeRoot(d.getSchemaForVersion(d.version)...)
 }
 
 func (d *DataColumnSidecar) Static() bool {