add interface and impl

encoding/kzg/prover/compute_proof.go

@@ -5,18 +5,29 @@ import (
 	"math"
 	"time"
 
+	"github.com/Layr-Labs/eigenda/encoding/fft"
+	"github.com/Layr-Labs/eigenda/encoding/kzg"
 	"github.com/Layr-Labs/eigenda/encoding/utils/toeplitz"
 	"github.com/consensys/gnark-crypto/ecc"
 	"github.com/consensys/gnark-crypto/ecc/bn254"
 	"github.com/consensys/gnark-crypto/ecc/bn254/fr"
 )
 
+type CpuComputer struct {
+	*kzg.KzgConfig
+	Fs         *fft.FFTSettings
+	FFTPointsT [][]bn254.G1Affine // transpose of FFTPoints
+	SFs        *fft.FFTSettings
+	Srs        *kzg.SRS
+	G2Trailing []bn254.G2Affine
+}
+
 type WorkerResult struct {
 	points []bn254.G1Affine
 	err    error
 }
 
-func (p *ParametrizedProver) ComputeLengthProof(coeffs []fr.Element) (*bn254.G2Affine, error) {
+func (p *CpuComputer) ComputeLengthProof(coeffs []fr.Element) (*bn254.G2Affine, error) {
 	inputLength := uint64(len(coeffs))
 	shiftedSecret := p.G2Trailing[p.KzgConfig.SRSNumberToLoad-inputLength:]
 	config := ecc.MultiExpConfig{}
@@ -29,7 +40,7 @@ func (p *ParametrizedProver) ComputeLengthProof(coeffs []fr.Element) (*bn254.G2A
 	return &lengthProof, nil
 }
 
-func (p *ParametrizedProver) ComputeCommitment(coeffs []fr.Element) (*bn254.G1Affine, error) {
+func (p *CpuComputer) ComputeCommitment(coeffs []fr.Element) (*bn254.G1Affine, error) {
 	// compute commit for the full poly
 	config := ecc.MultiExpConfig{}
 	var commitment bn254.G1Affine
@@ -40,7 +51,7 @@ func (p *ParametrizedProver) ComputeCommitment(coeffs []fr.Element) (*bn254.G1Af
 	return &commitment, nil
 }
 
-func (p *ParametrizedProver) ComputeLengthCommitment(coeffs []fr.Element) (*bn254.G2Affine, error) {
+func (p *CpuComputer) ComputeLengthCommitment(coeffs []fr.Element) (*bn254.G2Affine, error) {
 	config := ecc.MultiExpConfig{}
 
 	var lengthCommitment bn254.G2Affine
@@ -51,7 +62,7 @@ func (p *ParametrizedProver) ComputeLengthCommitment(coeffs []fr.Element) (*bn25
 	return &lengthCommitment, nil
 }
 
-func (p *ParametrizedProver) ComputeMultiFrameProof(polyFr []fr.Element, numChunks, chunkLen, numWorker uint64) ([]bn254.G1Affine, error) {
+func (p *CpuComputer) ComputeMultiFrameProof(polyFr []fr.Element, numChunks, chunkLen, numWorker uint64) ([]bn254.G1Affine, error) {
 	begin := time.Now()
 	// Robert: Standardizing this to use the same math used in precomputeSRS
 	dimE := numChunks
@@ -134,7 +145,7 @@ func (p *ParametrizedProver) ComputeMultiFrameProof(polyFr []fr.Element, numChun
 	return proofs, nil
 }
 
-func (p *ParametrizedProver) proofWorker(
+func (p *CpuComputer) proofWorker(
 	polyFr []fr.Element,
 	jobChan <-chan uint64,
 	l uint64,
@@ -167,7 +178,7 @@ func (p *ParametrizedProver) proofWorker(
 // phi ^ (coset size ) = 1
 //
 // implicitly pad slices to power of 2
-func (p *ParametrizedProver) GetSlicesCoeff(polyFr []fr.Element, dimE, j, l uint64) ([]fr.Element, error) {
+func (p *CpuComputer) GetSlicesCoeff(polyFr []fr.Element, dimE, j, l uint64) ([]fr.Element, error) {
 	// there is a constant term
 	m := uint64(len(polyFr)) - 1
 	dim := (m - j) / l

encoding/kzg/prover/encode.go

@@ -0,0 +1,14 @@
+package prover
+
+import (
+	"github.com/consensys/gnark-crypto/ecc/bn254"
+	"github.com/consensys/gnark-crypto/ecc/bn254/fr"
+)
+
+type ProofComputeDevice interface {
+	// blobFr are coefficients
+	ComputeCommitment(blobFr []fr.Element) (*bn254.G1Affine, error)
+	ComputeMultiFrameProof(blobFr []fr.Element, numChunks, chunkLen, numWorker uint64) ([]bn254.G1Affine, error)
+	ComputeLengthCommitment(blobFr []fr.Element) (*bn254.G2Affine, error)
+	ComputeLengthProof(blobFr []fr.Element) (*bn254.G2Affine, error)
+}

encoding/kzg/prover/parametrized_prover.go

@@ -8,7 +8,6 @@ import (
 	"github.com/Layr-Labs/eigenda/encoding"
 	"github.com/hashicorp/go-multierror"
 
-	"github.com/Layr-Labs/eigenda/encoding/fft"
 	"github.com/Layr-Labs/eigenda/encoding/kzg"
 	"github.com/Layr-Labs/eigenda/encoding/rs"
 	"github.com/consensys/gnark-crypto/ecc/bn254"
@@ -19,13 +18,9 @@ type ParametrizedProver struct {
 	*rs.Encoder
 
 	*kzg.KzgConfig
-	Srs        *kzg.SRS
-	G2Trailing []bn254.G2Affine
+	Ks *kzg.KZGSettings
 
-	Fs         *fft.FFTSettings
-	Ks         *kzg.KZGSettings
-	SFs        *fft.FFTSettings   // fft used for submatrix product helper
-	FFTPointsT [][]bn254.G1Affine // transpose of FFTPoints
+	Computer ProofComputeDevice
 }
 
 type RsEncodeResult struct {
@@ -94,7 +89,7 @@ func (g *ParametrizedProver) Encode(inputFr []fr.Element) (*bn254.G1Affine, *bn2
 	// compute commit for the full poly
 	go func() {
 		start := time.Now()
-		commit, err := g.ComputeCommitment(inputFr)
+		commit, err := g.Computer.ComputeCommitment(inputFr)
 		commitmentChan <- CommitmentResult{
 			Commitment: *commit,
 			Err:        err,
@@ -104,7 +99,7 @@ func (g *ParametrizedProver) Encode(inputFr []fr.Element) (*bn254.G1Affine, *bn2
 
 	go func() {
 		start := time.Now()
-		lengthCommitment, err := g.ComputeLengthCommitment(inputFr)
+		lengthCommitment, err := g.Computer.ComputeLengthCommitment(inputFr)
 		lengthCommitmentChan <- LengthCommitmentResult{
 			LengthCommitment: *lengthCommitment,
 			Err:              err,
@@ -114,7 +109,7 @@ func (g *ParametrizedProver) Encode(inputFr []fr.Element) (*bn254.G1Affine, *bn2
 
 	go func() {
 		start := time.Now()
-		lengthProof, err := g.ComputeLengthProof(inputFr)
+		lengthProof, err := g.Computer.ComputeLengthProof(inputFr)
 		lengthProofChan <- LengthProofResult{
 			LengthProof: *lengthProof,
 			Err:         err,
@@ -135,7 +130,7 @@ func (g *ParametrizedProver) Encode(inputFr []fr.Element) (*bn254.G1Affine, *bn2
 			flatpaddedCoeffs = append(flatpaddedCoeffs, paddedCoeffs...)
 		}
 
-		proofs, err := g.ComputeMultiFrameProof(flatpaddedCoeffs, g.NumChunks, g.ChunkLength, g.NumWorker)
+		proofs, err := g.Computer.ComputeMultiFrameProof(flatpaddedCoeffs, g.NumChunks, g.ChunkLength, g.NumWorker)
 		proofChan <- ProofsResult{
 			Proofs:   proofs,
 			Err:      err,
@@ -162,7 +157,7 @@ func (g *ParametrizedProver) Encode(inputFr []fr.Element) (*bn254.G1Affine, *bn2
 		lengthCommitmentResult.Duration,
 		lengthProofResult.Duration,
 		proofsResult.Duration,
-		len(g.Srs.G2),
+		g.SRSOrder,
 		g.SRSOrder-uint64(len(inputFr)),
 	)
 

encoding/kzg/prover/prover.go

@@ -236,15 +236,20 @@ func (g *Prover) newProver(params encoding.EncodingParams) (*ParametrizedProver,
 	t := uint8(math.Log2(float64(2 * encoder.NumChunks)))
 	sfs := fft.NewFFTSettings(t)
 
-	return &ParametrizedProver{
-		Encoder:    encoder,
-		KzgConfig:  g.KzgConfig,
-		Srs:        g.Srs,
-		G2Trailing: g.G2Trailing,
+	computer := &CpuComputer{
 		Fs:         fs,
-		Ks:         ks,
-		SFs:        sfs,
 		FFTPointsT: fftPointsT,
+		SFs:        sfs,
+		Srs:        g.Srs,
+		G2Trailing: g.G2Trailing,
+		KzgConfig:  g.KzgConfig,
+	}
+
+	return &ParametrizedProver{
+		Encoder:   encoder,
+		KzgConfig: g.KzgConfig,
+		Ks:        ks,
+		Computer:  computer,
 	}, nil
 }