remove prover with verifier

verify/verifier.go

@@ -3,7 +3,7 @@ package verify
 import (
 	"fmt"
 
-	"github.com/Layr-Labs/eigenda/encoding"
+	"github.com/consensys/gnark-crypto/ecc"
 	"github.com/consensys/gnark-crypto/ecc/bn254"
 	"github.com/consensys/gnark-crypto/ecc/bn254/fp"
 	"github.com/ethereum/go-ethereum/log"
@@ -12,7 +12,7 @@ import (
 
 	"github.com/Layr-Labs/eigenda/api/grpc/common"
 	"github.com/Layr-Labs/eigenda/encoding/kzg"
-	"github.com/Layr-Labs/eigenda/encoding/kzg/prover"
+	"github.com/Layr-Labs/eigenda/encoding/kzg/verifier"
 	"github.com/Layr-Labs/eigenda/encoding/rs"
 )
 
@@ -25,9 +25,9 @@ type Config struct {
 }
 
 type Verifier struct {
-	verifyCert bool
-	kzgProver     *prover.Prover
-	cv         *CertVerifier
+	verifyCert  bool
+	kzgVerifier *verifier.Verifier
+	cv          *CertVerifier
 }
 
 func NewVerifier(cfg *Config, l log.Logger) (*Verifier, error) {
@@ -41,15 +41,15 @@ func NewVerifier(cfg *Config, l log.Logger) (*Verifier, error) {
 		}
 	}
 
-	prover, err := prover.NewProver(cfg.KzgConfig, false) // don't load G2 points
+	v, err := verifier.NewVerifier(cfg.KzgConfig, false)
 	if err != nil {
 		return nil, err
 	}
 
 	return &Verifier{
-		verifyCert: cfg.Verify,
-		kzgProver:     prover,
-		cv:         cv,
+		verifyCert:  cfg.Verify,
+		kzgVerifier: v,
+		cv:          cv,
 	}, nil
 }
 
@@ -87,24 +87,23 @@ func (v *Verifier) VerifyCert(cert *Certificate) error {
 }
 
 func (v *Verifier) Commit(blob []byte) (*bn254.G1Affine, error) {
-	encoder, err := v.kzgProver.GetKzgEncoder(
-		encoding.ParamsFromSysPar(1, 1, uint64(len(blob))),
-	)
-	if err != nil {
-		return nil, err
-	}
-
 	inputFr, err := rs.ToFrArray(blob)
 	if err != nil {
 		return nil, fmt.Errorf("cannot convert bytes to field elements, %w", err)
 	}
 
-	commit, err := encoder.Commit(inputFr)
+	if len(v.kzgVerifier.Srs.G1) < len(inputFr) {
+		return nil, fmt.Errorf("cannot verify commitment because the number of stored srs in the memory is insufficient")
+	}
+
+	config := ecc.MultiExpConfig{}
+	var commitment bn254.G1Affine
+	_, err = commitment.MultiExp(v.kzgVerifier.Srs.G1[:len(inputFr)], inputFr, config)
 	if err != nil {
 		return nil, err
 	}
 
-	return &commit, nil
+	return &commitment, nil
 }
 
 // Verify regenerates a commitment from the blob and asserts equivalence

verify/verify_test.go

@@ -1,6 +1,7 @@
 package verify
 
 import (
+	"crypto/rand"
 	"encoding/hex"
 	"runtime"
 	"testing"
@@ -57,3 +58,49 @@ func TestCommitmentVerification(t *testing.T) {
 	err = v.VerifyCommitment(c, fakeData)
 	require.Error(t, err)
 }
+
+func TestCommitmentWithTooLargeBlob(t *testing.T) {
+
+	var dataRand [4000 * 32]byte
+	_, err := rand.Read(dataRand[:])
+	require.NoError(t, err)
+	data := dataRand[:]
+
+	kzgConfig := &kzg.KzgConfig{
+		G1Path:          "../resources/g1.point",
+		G2PowerOf2Path:  "../resources/g2.point.powerOf2",
+		CacheDir:        "../resources/SRSTables",
+		SRSOrder:        3000,
+		SRSNumberToLoad: 3000,
+		NumWorker:       uint64(runtime.GOMAXPROCS(0)),
+	}
+
+	cfg := &Config{
+		Verify:    false,
+		KzgConfig: kzgConfig,
+	}
+
+	v, err := NewVerifier(cfg, nil)
+	require.NoError(t, err)
+
+	// Some wrong commitment just to pass in function
+	x, err := hex.DecodeString("1021d699eac68ce312196d480266e8b82fd5fe5c4311e53313837b64db6df178")
+	require.NoError(t, err)
+
+	y, err := hex.DecodeString("02efa5a7813233ae13f32bae9b8f48252fa45c1b06a5d70bed471a9bea8d98ae")
+	require.NoError(t, err)
+
+	c := &common.G1Commitment{
+		X: x,
+		Y: y,
+	}
+
+	// Happy path verification
+	codec := codecs.NewIFFTCodec(codecs.NewDefaultBlobCodec())
+	blob, err := codec.EncodeBlob(data)
+
+	require.NoError(t, err)
+	err = v.VerifyCommitment(c, blob)
+	require.EqualError(t, err, "cannot verify commitment because the number of stored srs in the memory is insufficient")
+
+}