Update KZG library according to latest consensus spec changes

core/beacon/types.go

@@ -43,10 +43,9 @@ type payloadAttributesMarshaling struct {
 
 // BlobsBundleV1 holds the blobs of an execution payload, to be retrieved separately
 type BlobsBundleV1 struct {
-	BlockHash       common.Hash           `json:"blockHash"     gencodec:"required"`
-	KZGs            []types.KZGCommitment `json:"kzgs"      gencodec:"required"`
-	Blobs           []types.Blob          `json:"blobs"      gencodec:"required"`
-	AggregatedProof types.KZGProof        `json:"aggregatedProof" gencodec:"required"`
+	BlockHash common.Hash           `json:"blockHash"     gencodec:"required"`
+	KZGs      []types.KZGCommitment `json:"kzgs"      gencodec:"required"`
+	Blobs     []types.Blob          `json:"blobs"      gencodec:"required"`
 }
 
 //go:generate go run github.com/fjl/gencodec -type ExecutableDataV1 -field-override executableDataMarshaling -out gen_ed.go
@@ -236,11 +235,5 @@ func BlockToBlobData(block *types.Block) (*BlobsBundleV1, error) {
 			blobsBundle.KZGs = append(blobsBundle.KZGs, kzgs...)
 		}
 	}
-
-	_, _, aggregatedProof, err := types.Blobs(blobsBundle.Blobs).ComputeCommitmentsAndAggregatedProof()
-	if err != nil {
-		return nil, err
-	}
-	blobsBundle.AggregatedProof = aggregatedProof
 	return blobsBundle, nil
 }

core/types/data_blob.go

@@ -10,7 +10,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto/kzg"
 	"github.com/ethereum/go-ethereum/params"
-	"github.com/protolambda/go-kzg/bls"
 	"github.com/protolambda/ztyp/codec"
 	"github.com/protolambda/ztyp/tree"
 )
@@ -103,6 +102,7 @@ func (p *KZGProof) UnmarshalText(text []byte) error {
 	return hexutil.UnmarshalFixedText("KZGProof", text, p[:])
 }
 
+// BLSFieldElement is the raw bytes representation of a field element
 type BLSFieldElement [32]byte
 
 func (p BLSFieldElement) MarshalText() ([]byte, error) {
@@ -120,6 +120,16 @@ func (p *BLSFieldElement) UnmarshalText(text []byte) error {
 // Blob data
 type Blob [params.FieldElementsPerBlob]BLSFieldElement
 
+// kzg.Blob interface
+func (blob Blob) Len() int {
+	return len(blob)
+}
+
+// kzg.Blob interface
+func (blob Blob) At(i int) [32]byte {
+	return [32]byte(blob[i])
+}
+
 func (blob *Blob) Deserialize(dr *codec.DecodingReader) error {
 	if blob == nil {
 		return errors.New("cannot decode ssz into nil Blob")
@@ -156,17 +166,6 @@ func (blob *Blob) HashTreeRoot(hFn tree.HashFn) tree.Root {
 	}, params.FieldElementsPerBlob)
 }
 
-// Convert a blob to kzg.Blob
-func (blob *Blob) ToKZGBlob() (kzg.Blob, bool) {
-	frs := make([]bls.Fr, len(blob))
-	for i, elem := range blob {
-		if !bls.FrFrom32(&frs[i], elem) {
-			return []bls.Fr{}, false
-		}
-	}
-	return kzg.Blob(frs), true
-}
-
 func (blob *Blob) MarshalText() ([]byte, error) {
 	out := make([]byte, 2+params.FieldElementsPerBlob*32*2)
 	copy(out[:2], "0x")
@@ -209,6 +208,15 @@ func (blob *Blob) UnmarshalText(text []byte) error {
 
 type BlobKzgs []KZGCommitment
 
+// kzg.KZGCommitmentSequence interface
+func (bk BlobKzgs) Len() int {
+	return len(bk)
+}
+
+func (bk BlobKzgs) At(i int) kzg.KZGCommitment {
+	return kzg.KZGCommitment(bk[i])
+}
+
 func (li *BlobKzgs) Deserialize(dr *codec.DecodingReader) error {
 	return dr.List(func() codec.Deserializable {
 		i := len(*li)
@@ -227,7 +235,7 @@ func (li BlobKzgs) ByteLength() uint64 {
 	return uint64(len(li)) * 48
 }
 
-func (li *BlobKzgs) FixedLength() uint64 {
+func (li BlobKzgs) FixedLength() uint64 {
 	return 0
 }
 
@@ -245,17 +253,14 @@ func (li BlobKzgs) copy() BlobKzgs {
 
 type Blobs []Blob
 
-// Extract the crypto material underlying these blobs
-func (blobs Blobs) toKZGBlobSequence() ([][]bls.Fr, bool) {
-	out := make([][]bls.Fr, len(blobs))
-	for i, b := range blobs {
-		blob, ok := b.ToKZGBlob()
-		if !ok {
-			return nil, false
-		}
-		out[i] = blob
-	}
-	return out, true
+// kzg.BlobSequence interface
+func (blobs Blobs) Len() int {
+	return len(blobs)
+}
+
+// kzg.BlobSequence interface
+func (blobs Blobs) At(i int) kzg.Blob {
+	return blobs[i]
 }
 
 func (a *Blobs) Deserialize(dr *codec.DecodingReader) error {
@@ -301,42 +306,21 @@ func (blobs Blobs) ComputeCommitmentsAndAggregatedProof() (commitments []KZGComm
 	commitments = make([]KZGCommitment, len(blobs))
 	versionedHashes = make([]common.Hash, len(blobs))
 	for i, blob := range blobs {
-		frs, ok := blob.ToKZGBlob()
+		c, ok := kzg.BlobToKZGCommitment(blob)
 		if !ok {
-			return nil, nil, KZGProof{}, errors.New("invalid blob for commitment")
+			return nil, nil, KZGProof{}, errors.New("could not convert blob to commitment")
 		}
-		commitments[i] = KZGCommitment(kzg.BlobToKZGCommitment(frs))
-		versionedHashes[i] = common.Hash(kzg.KZGToVersionedHash(kzg.KZGCommitment(commitments[i])))
+		commitments[i] = KZGCommitment(c)
+		versionedHashes[i] = common.Hash(kzg.KZGToVersionedHash(c))
 	}
 
 	var kzgProof KZGProof
 	if len(blobs) != 0 {
-		aggregatePoly, aggregateCommitmentG1, err := computeAggregateKzgCommitment(blobs, commitments)
+		proof, err := kzg.ComputeAggregateKZGProof(blobs)
 		if err != nil {
 			return nil, nil, KZGProof{}, err
 		}
-
-		var aggregateCommitment KZGCommitment
-		copy(aggregateCommitment[:], bls.ToCompressedG1(aggregateCommitmentG1))
-
-		var aggregateBlob Blob
-		for i := range aggregatePoly {
-			aggregateBlob[i] = bls.FrTo32(&aggregatePoly[i])
-		}
-		sum, err := sszHash(&PolynomialAndCommitment{aggregateBlob, aggregateCommitment})
-		if err != nil {
-			return nil, nil, KZGProof{}, err
-		}
-		z := kzg.BytesToBLSField(sum)
-
-		var y bls.Fr
-		kzg.EvaluatePolyInEvaluationForm(&y, aggregatePoly[:], z)
-
-		aggProofG1, err := kzg.ComputeProof(aggregatePoly, z)
-		if err != nil {
-			return nil, nil, KZGProof{}, err
-		}
-		copy(kzgProof[:], bls.ToCompressedG1(aggProofG1))
+		kzgProof = KZGProof(proof)
 	}
 
 	return commitments, versionedHashes, kzgProof, nil
@@ -363,27 +347,6 @@ func (b *BlobsAndCommitments) FixedLength() uint64 {
 	return 0
 }
 
-type PolynomialAndCommitment struct {
-	b Blob
-	c KZGCommitment
-}
-
-func (p *PolynomialAndCommitment) HashTreeRoot(hFn tree.HashFn) tree.Root {
-	return hFn.HashTreeRoot(&p.b, &p.c)
-}
-
-func (p *PolynomialAndCommitment) Serialize(w *codec.EncodingWriter) error {
-	return w.Container(&p.b, &p.c)
-}
-
-func (p *PolynomialAndCommitment) ByteLength() uint64 {
-	return codec.ContainerLength(&p.b, &p.c)
-}
-
-func (p *PolynomialAndCommitment) FixedLength() uint64 {
-	return 0
-}
-
 type BlobTxWrapper struct {
 	Tx                 SignedBlobTx
 	BlobKzgs           BlobKzgs
@@ -421,19 +384,30 @@ func (b *BlobTxWrapData) sizeWrapData() common.StorageSize {
 	return common.StorageSize(4 + 4 + b.BlobKzgs.ByteLength() + b.Blobs.ByteLength() + b.KzgAggregatedProof.ByteLength())
 }
 
-func (b *BlobTxWrapData) verifyVersionedHash(inner TxData) error {
+// validateBlobTransactionWrapper implements validate_blob_transaction_wrapper from EIP-4844
+func (b *BlobTxWrapData) validateBlobTransactionWrapper(inner TxData) error {
 	blobTx, ok := inner.(*SignedBlobTx)
 	if !ok {
 		return fmt.Errorf("expected signed blob tx, got %T", inner)
 	}
-	if a, b := len(blobTx.Message.BlobVersionedHashes), params.MaxBlobsPerBlock; a > b {
-		return fmt.Errorf("too many blobs in blob tx, got %d, expected no more than %d", a, b)
+	l1 := len(b.BlobKzgs)
+	l2 := len(blobTx.Message.BlobVersionedHashes)
+	l3 := len(b.Blobs)
+	if l1 != l2 || l2 != l3 {
+		return fmt.Errorf("lengths don't match %v %v %v", l1, l2, l3)
 	}
-	if a, b := len(b.BlobKzgs), len(b.Blobs); a != b {
-		return fmt.Errorf("expected equal amount but got %d kzgs and %d blobs", a, b)
+	// the following check isn't strictly necessary as it would be caught by data gas processing
+	// (and hence it is not explicitly in the spec for this function), but it doesn't hurt to fail
+	// early in case we are getting spammed with too many blobs or there is a bug somewhere:
+	if l1 > params.MaxBlobsPerBlock {
+		return fmt.Errorf("number of blobs exceeds max: %v", l1)
 	}
-	if a, b := len(b.BlobKzgs), len(blobTx.Message.BlobVersionedHashes); a != b {
-		return fmt.Errorf("expected equal amount but got %d kzgs and %d versioned hashes", a, b)
+	ok, err := kzg.VerifyAggregateKZGProof(b.Blobs, b.BlobKzgs, kzg.KZGProof(b.KzgAggregatedProof))
+	if err != nil {
+		return fmt.Errorf("error during proof verification: %v", err)
+	}
+	if !ok {
+		return errors.New("failed to verify kzg")
 	}
 	for i, h := range blobTx.Message.BlobVersionedHashes {
 		if computed := b.BlobKzgs[i].ComputeVersionedHash(); computed != h {
@@ -443,41 +417,6 @@ func (b *BlobTxWrapData) verifyVersionedHash(inner TxData) error {
 	return nil
 }
 
-// Blob verification using KZG proofs
-func (b *BlobTxWrapData) verifyBlobs(inner TxData) error {
-	if err := b.verifyVersionedHash(inner); err != nil {
-		return err
-	}
-
-	aggregatePoly, aggregateCommitmentG1, err := computeAggregateKzgCommitment(b.Blobs, b.BlobKzgs)
-	if err != nil {
-		return fmt.Errorf("failed to compute aggregate commitment: %v", err)
-	}
-	var aggregateBlob Blob
-	for i := range aggregatePoly {
-		aggregateBlob[i] = bls.FrTo32(&aggregatePoly[i])
-	}
-	var aggregateCommitment KZGCommitment
-	copy(aggregateCommitment[:], bls.ToCompressedG1(aggregateCommitmentG1))
-	sum, err := sszHash(&PolynomialAndCommitment{aggregateBlob, aggregateCommitment})
-	if err != nil {
-		return err
-	}
-	z := kzg.BytesToBLSField(sum)
-
-	var y bls.Fr
-	kzg.EvaluatePolyInEvaluationForm(&y, aggregatePoly[:], z)
-
-	aggregateProofG1, err := bls.FromCompressedG1(b.KzgAggregatedProof[:])
-	if err != nil {
-		return fmt.Errorf("aggregate proof parse error: %v", err)
-	}
-	if !kzg.VerifyKZGProofFromPoints(aggregateCommitmentG1, z, &y, aggregateProofG1) {
-		return errors.New("failed to verify kzg")
-	}
-	return nil
-}
-
 func (b *BlobTxWrapData) copy() TxWrapData {
 	return &BlobTxWrapData{
 		BlobKzgs:           b.BlobKzgs.copy(),
@@ -514,33 +453,3 @@ func (b *BlobTxWrapData) encodeTyped(w io.Writer, txdata TxData) error {
 	}
 	return EncodeSSZ(w, &wrapped)
 }
-
-func computeAggregateKzgCommitment(blobs Blobs, commitments []KZGCommitment) ([]bls.Fr, *bls.G1Point, error) {
-	// create challenges
-	sum, err := sszHash(&BlobsAndCommitments{blobs, commitments})
-	if err != nil {
-		return nil, nil, err
-	}
-	r := kzg.BytesToBLSField(sum)
-
-	powers := kzg.ComputePowers(r, len(blobs))
-
-	commitmentsG1 := make([]bls.G1Point, len(commitments))
-	for i := 0; i < len(commitmentsG1); i++ {
-		p, _ := bls.FromCompressedG1(commitments[i][:])
-		bls.CopyG1(&commitmentsG1[i], p)
-	}
-	aggregateCommitmentG1 := bls.LinCombG1(commitmentsG1, powers)
-	var aggregateCommitment KZGCommitment
-	copy(aggregateCommitment[:], bls.ToCompressedG1(aggregateCommitmentG1))
-
-	polys, ok := blobs.toKZGBlobSequence()
-	if !ok {
-		return nil, nil, err
-	}
-	aggregatePoly, err := bls.PolyLinComb(polys, powers)
-	if err != nil {
-		return nil, nil, err
-	}
-	return aggregatePoly, aggregateCommitmentG1, nil
-}

core/types/transaction.go

@@ -98,7 +98,7 @@ type TxWrapData interface {
 	aggregatedProof() KZGProof
 	encodeTyped(w io.Writer, txdata TxData) error
 	sizeWrapData() common.StorageSize
-	verifyBlobs(inner TxData) error
+	validateBlobTransactionWrapper(inner TxData) error
 }
 
 // TxData is the underlying data of a transaction.
@@ -543,7 +543,7 @@ func (tx *Transaction) IsIncomplete() bool {
 // VerifyBlobs verifies the blob transaction
 func (tx *Transaction) VerifyBlobs() error {
 	if tx.wrapData != nil {
-		return tx.wrapData.verifyBlobs(tx.inner)
+		return tx.wrapData.validateBlobTransactionWrapper(tx.inner)
 	}
 	return nil
 }

core/types/transaction_marshalling.go

@@ -362,7 +362,7 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error {
 				KzgAggregatedProof: dec.KzgAggregatedProof,
 			}
 			// Verify that versioned hashes match kzgs, and kzgs match blobs.
-			if err := tx.wrapData.verifyBlobs(&itx); err != nil {
+			if err := tx.wrapData.validateBlobTransactionWrapper(&itx); err != nil {
 				return fmt.Errorf("blob wrapping data is invalid: %v", err)
 			}
 		}

core/types/transaction_test.go

@@ -490,7 +490,7 @@ func TestTransactionCoding(t *testing.T) {
 					GasTipCap:           view.Uint256View(*uint256.NewInt(42)),
 					GasFeeCap:           view.Uint256View(*uint256.NewInt(10)),
 					AccessList:          AccessListView(accesses),
-					BlobVersionedHashes: VersionedHashesView{common.HexToHash("0x01624652859a6e98ffc1608e2af0147ca4e86e1ce27672d8d3f3c9d4ffd6ef7e")},
+					BlobVersionedHashes: VersionedHashesView{common.HexToHash("0x010657f37554c781402a22917dee2f75def7ab966d7b770905398eba3c444014")},
 				},
 			}
 			var kzgProof KZGProof

core/vm/testdata/precompiles/pointEvaluation.json

@@ -1,6 +1,6 @@
 [
   {
-    "Input": "01342233e6ebb423c766d3a0f8d183e84c453865b392f5ab1f8a8218506e89d842000000000000000000000000000000000000000000000000000000000000002b2f0b0a19cbe19b4c9dbc32af755539fec08bae3eeecbe0ec625037fe3f0a6fa3cfbde6cf9875270479e0e2290726d150412591e07b4fad36472fa1ad38c19eb232cd2ebd3738ea1d9a0a3be07764a8b2faf3776cf5fb7bea8263ab92181326b898c4dc5da95e76e6977c4e204a94f1a3fe5033e19435fa51a8c70b272c06ac",
+      "Input": "01d0db71b458e8955efa3ef62f1b6b45a2d9c8633dc59ed0b995cecf8b7bb48442000000000000000000000000000000000000000000000000000000000000003b11ebd59d5d12d6ef8e5e48f71770515e032595a0e55eaf80e906b65b2a625282bead0f31f58ee4fd81e93f796bb57acd6f8f6e4def04182c8e949c71ea00d85a44c12102bd817bc97696a6b8fd75618fcd8c2030080c9602e08e935cdf6f779d0d89e7764d855edfbaa730eddfff836fc324957db4f74d1565503bcfcaf157",
     "Expected": "",
     "Name": "pointEvaluation1",
     "Gas": 50000,