chore(dep): upgrade go kzg 4844 (#718)

z2trillion · holiman · Mason Liang · web-flow · commit 90221d6fc719 · 2024-04-24T09:38:18.000+08:00
* crypto/kz4844: pass blobs by ref (ethereum#29050) This change makes use of the following underlying changes to the kzg-libraries in order to avoid passing large things on the stack: - c-kzg: ethereum/c-kzg-4844#393 and - go-kzg: https://github.com/crate-crypto/go-kzg-4844/pull/63 * update version patch * run go mod tidy * use blob reference --------- Co-authored-by: Martin HS <martin@swende.se> Co-authored-by: Mason Liang <mason@scroll.io>
diff --git a/crypto/kzg4844/kzg4844.go b/crypto/kzg4844/kzg4844.go
@@ -66,7 +66,7 @@ func UseCKZG(use bool) error {
 }
 
 // BlobToCommitment creates a small commitment out of a data blob.
-func BlobToCommitment(blob Blob) (Commitment, error) {
+func BlobToCommitment(blob *Blob) (Commitment, error) {
 	if useCKZG.Load() {
 		return ckzgBlobToCommitment(blob)
 	}
@@ -75,7 +75,7 @@ func BlobToCommitment(blob Blob) (Commitment, error) {
 
 // ComputeProof computes the KZG proof at the given point for the polynomial
 // represented by the blob.
-func ComputeProof(blob Blob, point Point) (Proof, Claim, error) {
+func ComputeProof(blob *Blob, point Point) (Proof, Claim, error) {
 	if useCKZG.Load() {
 		return ckzgComputeProof(blob, point)
 	}
@@ -95,15 +95,15 @@ func VerifyProof(commitment Commitment, point Point, claim Claim, proof Proof) e
 // the commitment.
 //
 // This method does not verify that the commitment is correct with respect to blob.
-func ComputeBlobProof(blob Blob, commitment Commitment) (Proof, error) {
+func ComputeBlobProof(blob *Blob, commitment Commitment) (Proof, error) {
 	if useCKZG.Load() {
 		return ckzgComputeBlobProof(blob, commitment)
 	}
 	return gokzgComputeBlobProof(blob, commitment)
 }
 
 // VerifyBlobProof verifies that the blob data corresponds to the provided commitment.
-func VerifyBlobProof(blob Blob, commitment Commitment, proof Proof) error {
+func VerifyBlobProof(blob *Blob, commitment Commitment, proof Proof) error {
 	if useCKZG.Load() {
 		return ckzgVerifyBlobProof(blob, commitment, proof)
 	}
diff --git a/crypto/kzg4844/kzg4844_ckzg_cgo.go b/crypto/kzg4844/kzg4844_ckzg_cgo.go
@@ -62,10 +62,10 @@ func ckzgInit() {
 }
 
 // ckzgBlobToCommitment creates a small commitment out of a data blob.
-func ckzgBlobToCommitment(blob Blob) (Commitment, error) {
+func ckzgBlobToCommitment(blob *Blob) (Commitment, error) {
 	ckzgIniter.Do(ckzgInit)
 
-	commitment, err := ckzg4844.BlobToKZGCommitment((ckzg4844.Blob)(blob))
+	commitment, err := ckzg4844.BlobToKZGCommitment((*ckzg4844.Blob)(blob))
 	if err != nil {
 		return Commitment{}, err
 	}
@@ -74,10 +74,10 @@ func ckzgBlobToCommitment(blob Blob) (Commitment, error) {
 
 // ckzgComputeProof computes the KZG proof at the given point for the polynomial
 // represented by the blob.
-func ckzgComputeProof(blob Blob, point Point) (Proof, Claim, error) {
+func ckzgComputeProof(blob *Blob, point Point) (Proof, Claim, error) {
 	ckzgIniter.Do(ckzgInit)
 
-	proof, claim, err := ckzg4844.ComputeKZGProof((ckzg4844.Blob)(blob), (ckzg4844.Bytes32)(point))
+	proof, claim, err := ckzg4844.ComputeKZGProof((*ckzg4844.Blob)(blob), (ckzg4844.Bytes32)(point))
 	if err != nil {
 		return Proof{}, Claim{}, err
 	}
@@ -103,21 +103,21 @@ func ckzgVerifyProof(commitment Commitment, point Point, claim Claim, proof Proo
 // the commitment.
 //
 // This method does not verify that the commitment is correct with respect to blob.
-func ckzgComputeBlobProof(blob Blob, commitment Commitment) (Proof, error) {
+func ckzgComputeBlobProof(blob *Blob, commitment Commitment) (Proof, error) {
 	ckzgIniter.Do(ckzgInit)
 
-	proof, err := ckzg4844.ComputeBlobKZGProof((ckzg4844.Blob)(blob), (ckzg4844.Bytes48)(commitment))
+	proof, err := ckzg4844.ComputeBlobKZGProof((*ckzg4844.Blob)(blob), (ckzg4844.Bytes48)(commitment))
 	if err != nil {
 		return Proof{}, err
 	}
 	return (Proof)(proof), nil
 }
 
 // ckzgVerifyBlobProof verifies that the blob data corresponds to the provided commitment.
-func ckzgVerifyBlobProof(blob Blob, commitment Commitment, proof Proof) error {
+func ckzgVerifyBlobProof(blob *Blob, commitment Commitment, proof Proof) error {
 	ckzgIniter.Do(ckzgInit)
 
-	valid, err := ckzg4844.VerifyBlobKZGProof((ckzg4844.Blob)(blob), (ckzg4844.Bytes48)(commitment), (ckzg4844.Bytes48)(proof))
+	valid, err := ckzg4844.VerifyBlobKZGProof((*ckzg4844.Blob)(blob), (ckzg4844.Bytes48)(commitment), (ckzg4844.Bytes48)(proof))
 	if err != nil {
 		return err
 	}
diff --git a/crypto/kzg4844/kzg4844_ckzg_nocgo.go b/crypto/kzg4844/kzg4844_ckzg_nocgo.go
@@ -32,13 +32,13 @@ func ckzgInit() {
 }
 
 // ckzgBlobToCommitment creates a small commitment out of a data blob.
-func ckzgBlobToCommitment(blob Blob) (Commitment, error) {
+func ckzgBlobToCommitment(blob *Blob) (Commitment, error) {
 	panic("unsupported platform")
 }
 
 // ckzgComputeProof computes the KZG proof at the given point for the polynomial
 // represented by the blob.
-func ckzgComputeProof(blob Blob, point Point) (Proof, Claim, error) {
+func ckzgComputeProof(blob *Blob, point Point) (Proof, Claim, error) {
 	panic("unsupported platform")
 }
 
@@ -52,11 +52,11 @@ func ckzgVerifyProof(commitment Commitment, point Point, claim Claim, proof Proo
 // the commitment.
 //
 // This method does not verify that the commitment is correct with respect to blob.
-func ckzgComputeBlobProof(blob Blob, commitment Commitment) (Proof, error) {
+func ckzgComputeBlobProof(blob *Blob, commitment Commitment) (Proof, error) {
 	panic("unsupported platform")
 }
 
 // ckzgVerifyBlobProof verifies that the blob data corresponds to the provided commitment.
-func ckzgVerifyBlobProof(blob Blob, commitment Commitment, proof Proof) error {
+func ckzgVerifyBlobProof(blob *Blob, commitment Commitment, proof Proof) error {
 	panic("unsupported platform")
 }
diff --git a/crypto/kzg4844/kzg4844_gokzg.go b/crypto/kzg4844/kzg4844_gokzg.go
@@ -46,10 +46,10 @@ func gokzgInit() {
 }
 
 // gokzgBlobToCommitment creates a small commitment out of a data blob.
-func gokzgBlobToCommitment(blob Blob) (Commitment, error) {
+func gokzgBlobToCommitment(blob *Blob) (Commitment, error) {
 	gokzgIniter.Do(gokzgInit)
 
-	commitment, err := context.BlobToKZGCommitment((gokzg4844.Blob)(blob), 0)
+	commitment, err := context.BlobToKZGCommitment((*gokzg4844.Blob)(blob), 0)
 	if err != nil {
 		return Commitment{}, err
 	}
@@ -58,10 +58,10 @@ func gokzgBlobToCommitment(blob Blob) (Commitment, error) {
 
 // gokzgComputeProof computes the KZG proof at the given point for the polynomial
 // represented by the blob.
-func gokzgComputeProof(blob Blob, point Point) (Proof, Claim, error) {
+func gokzgComputeProof(blob *Blob, point Point) (Proof, Claim, error) {
 	gokzgIniter.Do(gokzgInit)
 
-	proof, claim, err := context.ComputeKZGProof((gokzg4844.Blob)(blob), (gokzg4844.Scalar)(point), 0)
+	proof, claim, err := context.ComputeKZGProof((*gokzg4844.Blob)(blob), (gokzg4844.Scalar)(point), 0)
 	if err != nil {
 		return Proof{}, Claim{}, err
 	}
@@ -80,19 +80,19 @@ func gokzgVerifyProof(commitment Commitment, point Point, claim Claim, proof Pro
 // the commitment.
 //
 // This method does not verify that the commitment is correct with respect to blob.
-func gokzgComputeBlobProof(blob Blob, commitment Commitment) (Proof, error) {
+func gokzgComputeBlobProof(blob *Blob, commitment Commitment) (Proof, error) {
 	gokzgIniter.Do(gokzgInit)
 
-	proof, err := context.ComputeBlobKZGProof((gokzg4844.Blob)(blob), (gokzg4844.KZGCommitment)(commitment), 0)
+	proof, err := context.ComputeBlobKZGProof((*gokzg4844.Blob)(blob), (gokzg4844.KZGCommitment)(commitment), 0)
 	if err != nil {
 		return Proof{}, err
 	}
 	return (Proof)(proof), nil
 }
 
 // gokzgVerifyBlobProof verifies that the blob data corresponds to the provided commitment.
-func gokzgVerifyBlobProof(blob Blob, commitment Commitment, proof Proof) error {
+func gokzgVerifyBlobProof(blob *Blob, commitment Commitment, proof Proof) error {
 	gokzgIniter.Do(gokzgInit)
 
-	return context.VerifyBlobKZGProof((gokzg4844.Blob)(blob), (gokzg4844.KZGCommitment)(commitment), (gokzg4844.KZGProof)(proof))
+	return context.VerifyBlobKZGProof((*gokzg4844.Blob)(blob), (gokzg4844.KZGCommitment)(commitment), (gokzg4844.KZGProof)(proof))
 }
diff --git a/crypto/kzg4844/kzg4844_test.go b/crypto/kzg4844/kzg4844_test.go
@@ -36,13 +36,13 @@ func randFieldElement() [32]byte {
 	return gokzg4844.SerializeScalar(r)
 }
 
-func randBlob() Blob {
+func randBlob() *Blob {
 	var blob Blob
 	for i := 0; i < len(blob); i += gokzg4844.SerializedScalarSize {
 		fieldElementBytes := randFieldElement()
 		copy(blob[i:i+gokzg4844.SerializedScalarSize], fieldElementBytes[:])
 	}
-	return blob
+	return &blob
 }
 
 func TestCKZGWithPoint(t *testing.T)  { testKZGWithPoint(t, true) }
diff --git a/go.mod b/go.mod
@@ -13,7 +13,7 @@ require (
 	github.com/cespare/cp v0.1.0
 	github.com/cloudflare/cloudflare-go v0.14.0
 	github.com/consensys/gnark-crypto v0.10.0
-	github.com/crate-crypto/go-kzg-4844 v0.7.0
+	github.com/crate-crypto/go-kzg-4844 v1.0.0
 	github.com/davecgh/go-spew v1.1.1
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea
 	github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf
diff --git a/go.sum b/go.sum
@@ -101,8 +101,8 @@ github.com/consensys/bavard v0.1.13/go.mod h1:9ItSMtA/dXMAiL7BG6bqW2m3NdSEObYWoH
 github.com/consensys/gnark-crypto v0.10.0 h1:zRh22SR7o4K35SoNqouS9J/TKHTyU2QWaj5ldehyXtA=
 github.com/consensys/gnark-crypto v0.10.0/go.mod h1:Iq/P3HHl0ElSjsg2E1gsMwhAyxnxoKK5nVyZKd+/KhU=
 github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/crate-crypto/go-kzg-4844 v0.7.0 h1:C0vgZRk4q4EZ/JgPfzuSoxdCq3C3mOZMBShovmncxvA=
-github.com/crate-crypto/go-kzg-4844 v0.7.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc=
+github.com/crate-crypto/go-kzg-4844 v1.0.0 h1:TsSgHwrkTKecKJ4kadtHi4b3xHW5dCFUDFnUp1TsawI=
+github.com/crate-crypto/go-kzg-4844 v1.0.0/go.mod h1:1kMhvPgI0Ky3yIa+9lFySEBUBXkYxeOi8ZF1sYioxhc=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/cyberdelia/templates v0.0.0-20141128023046-ca7fffd4298c/go.mod h1:GyV+0YP4qX0UQ7r2MoYZ+AvYDp12OF5yg4q8rGnyNh4=
 github.com/dave/jennifer v1.2.0/go.mod h1:fIb+770HOpJ2fmN9EPPKOqm1vMGhB+TwXKMZhrIygKg=
diff --git a/params/version.go b/params/version.go
@@ -24,7 +24,7 @@ import (
 const (
 	VersionMajor = 5         // Major version component of the current release
 	VersionMinor = 3         // Minor version component of the current release
-	VersionPatch = 0         // Patch version component of the current release
+	VersionPatch = 1         // Patch version component of the current release
 	VersionMeta  = "mainnet" // Version metadata to append to the version string
 )
 
diff --git a/rollup/types/encoding/codecv1/codecv1.go b/rollup/types/encoding/codecv1/codecv1.go
@@ -355,7 +355,7 @@ func constructBlobPayload(chunks []*encoding.Chunk) (*kzg4844.Blob, common.Hash,
 	}
 
 	// compute blob versioned hash
-	c, err := kzg4844.BlobToCommitment(*blob)
+	c, err := kzg4844.BlobToCommitment(blob)
 	if err != nil {
 		return nil, common.Hash{}, nil, fmt.Errorf("failed to create blob commitment")
 	}
@@ -452,12 +452,12 @@ func (b *DABatch) BlobDataProof() ([]byte, error) {
 		return nil, errors.New("called BlobDataProof with empty z")
 	}
 
-	commitment, err := kzg4844.BlobToCommitment(*b.blob)
+	commitment, err := kzg4844.BlobToCommitment(b.blob)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create blob commitment")
 	}
 
-	proof, y, err := kzg4844.ComputeProof(*b.blob, *b.z)
+	proof, y, err := kzg4844.ComputeProof(b.blob, *b.z)
 	if err != nil {
 		log.Crit("failed to create KZG proof at point", "err", err, "z", hex.EncodeToString(b.z[:]))
 	}

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ func UseCKZG(use bool) error {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`// BlobToCommitment creates a small commitment out of a data blob.`
`69`		`-func BlobToCommitment(blob Blob) (Commitment, error) {`
	`69`	`+func BlobToCommitment(blob *Blob) (Commitment, error) {`
`70`	`70`	`if useCKZG.Load() {`
`71`	`71`	`return ckzgBlobToCommitment(blob)`
`72`	`72`	`}`
`@@ -75,7 +75,7 @@ func BlobToCommitment(blob Blob) (Commitment, error) {`
`75`	`75`
`76`	`76`	`// ComputeProof computes the KZG proof at the given point for the polynomial`
`77`	`77`	`// represented by the blob.`
`78`		`-func ComputeProof(blob Blob, point Point) (Proof, Claim, error) {`
	`78`	`+func ComputeProof(blob *Blob, point Point) (Proof, Claim, error) {`
`79`	`79`	`if useCKZG.Load() {`
`80`	`80`	`return ckzgComputeProof(blob, point)`
`81`	`81`	`}`
`@@ -95,15 +95,15 @@ func VerifyProof(commitment Commitment, point Point, claim Claim, proof Proof) e`
`95`	`95`	`// the commitment.`
`96`	`96`	`//`
`97`	`97`	`// This method does not verify that the commitment is correct with respect to blob.`
`98`		`-func ComputeBlobProof(blob Blob, commitment Commitment) (Proof, error) {`
	`98`	`+func ComputeBlobProof(blob *Blob, commitment Commitment) (Proof, error) {`
`99`	`99`	`if useCKZG.Load() {`
`100`	`100`	`return ckzgComputeBlobProof(blob, commitment)`
`101`	`101`	`}`
`102`	`102`	`return gokzgComputeBlobProof(blob, commitment)`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`// VerifyBlobProof verifies that the blob data corresponds to the provided commitment.`
`106`		`-func VerifyBlobProof(blob Blob, commitment Commitment, proof Proof) error {`
	`106`	`+func VerifyBlobProof(blob *Blob, commitment Commitment, proof Proof) error {`
`107`	`107`	`if useCKZG.Load() {`
`108`	`108`	`return ckzgVerifyBlobProof(blob, commitment, proof)`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,13 +32,13 @@ func ckzgInit() {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`// ckzgBlobToCommitment creates a small commitment out of a data blob.`
`35`		`-func ckzgBlobToCommitment(blob Blob) (Commitment, error) {`
	`35`	`+func ckzgBlobToCommitment(blob *Blob) (Commitment, error) {`
`36`	`36`	`panic("unsupported platform")`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`// ckzgComputeProof computes the KZG proof at the given point for the polynomial`
`40`	`40`	`// represented by the blob.`
`41`		`-func ckzgComputeProof(blob Blob, point Point) (Proof, Claim, error) {`
	`41`	`+func ckzgComputeProof(blob *Blob, point Point) (Proof, Claim, error) {`
`42`	`42`	`panic("unsupported platform")`
`43`	`43`	`}`
`44`	`44`
`@@ -52,11 +52,11 @@ func ckzgVerifyProof(commitment Commitment, point Point, claim Claim, proof Proo`
`52`	`52`	`// the commitment.`
`53`	`53`	`//`
`54`	`54`	`// This method does not verify that the commitment is correct with respect to blob.`
`55`		`-func ckzgComputeBlobProof(blob Blob, commitment Commitment) (Proof, error) {`
	`55`	`+func ckzgComputeBlobProof(blob *Blob, commitment Commitment) (Proof, error) {`
`56`	`56`	`panic("unsupported platform")`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`// ckzgVerifyBlobProof verifies that the blob data corresponds to the provided commitment.`
`60`		`-func ckzgVerifyBlobProof(blob Blob, commitment Commitment, proof Proof) error {`
	`60`	`+func ckzgVerifyBlobProof(blob *Blob, commitment Commitment, proof Proof) error {`
`61`	`61`	`panic("unsupported platform")`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,13 +36,13 @@ func randFieldElement() [32]byte {`
`36`	`36`	`return gokzg4844.SerializeScalar(r)`
`37`	`37`	`}`
`38`	`38`
`39`		`-func randBlob() Blob {`
	`39`	`+func randBlob() *Blob {`
`40`	`40`	`var blob Blob`
`41`	`41`	`for i := 0; i < len(blob); i += gokzg4844.SerializedScalarSize {`
`42`	`42`	`fieldElementBytes := randFieldElement()`
`43`	`43`	`copy(blob[i:i+gokzg4844.SerializedScalarSize], fieldElementBytes[:])`
`44`	`44`	`}`
`45`		`- return blob`
	`45`	`+ return &blob`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`func TestCKZGWithPoint(t *testing.T) { testKZGWithPoint(t, true) }`
-Original file line number
+Diff line change
 	github.com/cespare/cp v0.1.0
 	github.com/cloudflare/cloudflare-go v0.14.0
 	github.com/consensys/gnark-crypto v0.10.0
 -	github.com/crate-crypto/go-kzg-4844 v0.7.0
 +	github.com/crate-crypto/go-kzg-4844 v1.0.0
 	github.com/davecgh/go-spew v1.1.1
 	github.com/deckarep/golang-set v0.0.0-20180603214616-504e848d77ea
 	github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ import (`
`24`	`24`	`const (`
`25`	`25`	`VersionMajor = 5 // Major version component of the current release`
`26`	`26`	`VersionMinor = 3 // Minor version component of the current release`
`27`		`- VersionPatch = 0 // Patch version component of the current release`
	`27`	`+ VersionPatch = 1 // Patch version component of the current release`
`28`	`28`	`VersionMeta = "mainnet" // Version metadata to append to the version string`
`29`	`29`	`)`
`30`	`30`
Original file line number	Diff line number	Diff line change
`@@ -355,7 +355,7 @@ func constructBlobPayload(chunks []encoding.Chunk) (kzg4844.Blob, common.Hash,`
`355`	`355`	`}`
`356`	`356`
`357`	`357`	`// compute blob versioned hash`
`358`		`- c, err := kzg4844.BlobToCommitment(*blob)`
	`358`	`+ c, err := kzg4844.BlobToCommitment(blob)`
`359`	`359`	`if err != nil {`
`360`	`360`	`return nil, common.Hash{}, nil, fmt.Errorf("failed to create blob commitment")`
`361`	`361`	`}`
`@@ -452,12 +452,12 @@ func (b *DABatch) BlobDataProof() ([]byte, error) {`
`452`	`452`	`return nil, errors.New("called BlobDataProof with empty z")`
`453`	`453`	`}`
`454`	`454`
`455`		`- commitment, err := kzg4844.BlobToCommitment(*b.blob)`
	`455`	`+ commitment, err := kzg4844.BlobToCommitment(b.blob)`
`456`	`456`	`if err != nil {`
`457`	`457`	`return nil, fmt.Errorf("failed to create blob commitment")`
`458`	`458`	`}`
`459`	`459`
`460`		`- proof, y, err := kzg4844.ComputeProof(b.blob, b.z)`
	`460`	`+ proof, y, err := kzg4844.ComputeProof(b.blob, *b.z)`
`461`	`461`	`if err != nil {`
`462`	`462`	`log.Crit("failed to create KZG proof at point", "err", err, "z", hex.EncodeToString(b.z[:]))`
`463`	`463`	`}`