From 4dd73e2b6157cc41b7c272662c4a3d589e2b3002 Mon Sep 17 00:00:00 2001 From: Bowen Xue <93296844+bxue-l2@users.noreply.github.com> Date: Wed, 10 Jul 2024 18:33:20 -0700 Subject: [PATCH] Refactor cpu prover (#629) Co-authored-by: Bowen Xue --- encoding/kzg/prover/parametrized_prover.go | 352 ++++++++------------- encoding/kzg/prover/proof_computer.go | 209 ++++++++++++ encoding/kzg/prover/proof_device.go | 14 + encoding/kzg/prover/prover.go | 19 +- encoding/rs/encode.go | 17 +- encoding/rs/encode_test.go | 6 +- encoding/rs/encoder_fuzz_test.go | 2 +- encoding/rs/frame_test.go | 2 +- encoding/test/main.go | 15 +- 9 files changed, 383 insertions(+), 253 deletions(-) create mode 100644 encoding/kzg/prover/proof_computer.go create mode 100644 encoding/kzg/prover/proof_device.go diff --git a/encoding/kzg/prover/parametrized_prover.go b/encoding/kzg/prover/parametrized_prover.go index ceabb8dfd..d5c367781 100644 --- a/encoding/kzg/prover/parametrized_prover.go +++ b/encoding/kzg/prover/parametrized_prover.go @@ -3,16 +3,13 @@ package prover import ( "fmt" "log" - "math" "time" "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/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" ) @@ -21,18 +18,36 @@ 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 ProofComputer } -type WorkerResult struct { - points []bn254.G1Affine - err error +type RsEncodeResult struct { + Frames []rs.Frame + Indices []uint32 + Duration time.Duration + Err error +} +type LengthCommitmentResult struct { + LengthCommitment bn254.G2Affine + Duration time.Duration + Err error +} +type LengthProofResult struct { + LengthProof bn254.G2Affine + Duration time.Duration + Err error +} +type CommitmentResult struct { + Commitment bn254.G1Affine + Duration time.Duration + Err error +} +type ProofsResult struct { + Proofs []bn254.G1Affine + Duration time.Duration + Err error } // just a wrapper to take bytes not Fr Element @@ -46,228 +61,117 @@ func (g *ParametrizedProver) EncodeBytes(inputBytes []byte) (*bn254.G1Affine, *b func (g *ParametrizedProver) Encode(inputFr []fr.Element) (*bn254.G1Affine, *bn254.G2Affine, *bn254.G2Affine, []encoding.Frame, []uint32, error) { - startTime := time.Now() - poly, frames, indices, err := g.Encoder.Encode(inputFr) - if err != nil { - return nil, nil, nil, nil, nil, err - } - - if len(poly.Coeffs) > int(g.KzgConfig.SRSNumberToLoad) { - return nil, nil, nil, nil, nil, fmt.Errorf("poly Coeff length %v is greater than Loaded SRS points %v", len(poly.Coeffs), int(g.KzgConfig.SRSNumberToLoad)) - } - - // compute commit for the full poly - commit, err := g.Commit(poly.Coeffs) - if err != nil { - return nil, nil, nil, nil, nil, err + if len(inputFr) > int(g.KzgConfig.SRSNumberToLoad) { + return nil, nil, nil, nil, nil, fmt.Errorf("poly Coeff length %v is greater than Loaded SRS points %v", len(inputFr), int(g.KzgConfig.SRSNumberToLoad)) } - config := ecc.MultiExpConfig{} + encodeStart := time.Now() - var lengthCommitment bn254.G2Affine - _, err = lengthCommitment.MultiExp(g.Srs.G2[:len(poly.Coeffs)], poly.Coeffs, config) - if err != nil { - return nil, nil, nil, nil, nil, err - } - - intermediate := time.Now() - - chunkLength := uint64(len(inputFr)) - - if g.Verbose { - log.Printf(" Commiting takes %v\n", time.Since(intermediate)) - intermediate = time.Now() - - log.Printf("shift %v\n", g.SRSOrder-chunkLength) - log.Printf("order %v\n", len(g.Srs.G2)) - log.Println("low degree verification info") - } - - shiftedSecret := g.G2Trailing[g.KzgConfig.SRSNumberToLoad-chunkLength:] - - //The proof of low degree is commitment of the polynomial shifted to the largest srs degree - var lengthProof bn254.G2Affine - _, err = lengthProof.MultiExp(shiftedSecret, poly.Coeffs, config) - if err != nil { - return nil, nil, nil, nil, nil, err - } + rsChan := make(chan RsEncodeResult, 1) + lengthCommitmentChan := make(chan LengthCommitmentResult, 1) + lengthProofChan := make(chan LengthProofResult, 1) + commitmentChan := make(chan CommitmentResult, 1) + proofChan := make(chan ProofsResult, 1) - if g.Verbose { - log.Printf(" Generating Length Proof takes %v\n", time.Since(intermediate)) - intermediate = time.Now() - } - - // compute proofs - paddedCoeffs := make([]fr.Element, g.NumEvaluations()) - copy(paddedCoeffs, poly.Coeffs) - - proofs, err := g.ProveAllCosetThreads(paddedCoeffs, g.NumChunks, g.ChunkLength, g.NumWorker) - if err != nil { - return nil, nil, nil, nil, nil, fmt.Errorf("could not generate proofs: %v", err) - } - - if g.Verbose { - log.Printf(" Proving takes %v\n", time.Since(intermediate)) - } - - kzgFrames := make([]encoding.Frame, len(frames)) - for i, index := range indices { - kzgFrames[i] = encoding.Frame{ - Proof: proofs[index], - Coeffs: frames[i].Coeffs, + // inputFr is untouched + // compute chunks + go func() { + start := time.Now() + frames, indices, err := g.Encoder.Encode(inputFr) + rsChan <- RsEncodeResult{ + Frames: frames, + Indices: indices, + Err: err, + Duration: time.Since(start), } - } - - if g.Verbose { - log.Printf("Total encoding took %v\n", time.Since(startTime)) - } - return &commit, &lengthCommitment, &lengthProof, kzgFrames, indices, nil -} + }() -func (g *ParametrizedProver) Commit(polyFr []fr.Element) (bn254.G1Affine, error) { - commit, err := g.Ks.CommitToPoly(polyFr) - return *commit, err -} - -func (p *ParametrizedProver) ProveAllCosetThreads(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 - l := chunkLen - - sumVec := make([]bn254.G1Affine, dimE*2) - - jobChan := make(chan uint64, numWorker) - results := make(chan WorkerResult, numWorker) - - // create storage for intermediate fft outputs - coeffStore := make([][]fr.Element, dimE*2) - for i := range coeffStore { - coeffStore[i] = make([]fr.Element, l) - } - - for w := uint64(0); w < numWorker; w++ { - go p.proofWorker(polyFr, jobChan, l, dimE, coeffStore, results) - } - - for j := uint64(0); j < l; j++ { - jobChan <- j - } - close(jobChan) - - // return last error - var err error - for w := uint64(0); w < numWorker; w++ { - wr := <-results - if wr.err != nil { - err = wr.err + // compute commit for the full poly + go func() { + start := time.Now() + commit, err := g.Computer.ComputeCommitment(inputFr) + commitmentChan <- CommitmentResult{ + Commitment: *commit, + Err: err, + Duration: time.Since(start), } - } - - if err != nil { - return nil, fmt.Errorf("proof worker error: %v", err) - } - - t0 := time.Now() - - // compute proof by multi scaler multiplication - msmErrors := make(chan error, dimE*2) - for i := uint64(0); i < dimE*2; i++ { - - go func(k uint64) { - _, err := sumVec[k].MultiExp(p.FFTPointsT[k], coeffStore[k], ecc.MultiExpConfig{}) - // handle error - msmErrors <- err - }(i) - } - - for i := uint64(0); i < dimE*2; i++ { - err := <-msmErrors - if err != nil { - fmt.Println("Error. MSM while adding points", err) - return nil, err + }() + + go func() { + start := time.Now() + lengthCommitment, err := g.Computer.ComputeLengthCommitment(inputFr) + lengthCommitmentChan <- LengthCommitmentResult{ + LengthCommitment: *lengthCommitment, + Err: err, + Duration: time.Since(start), } - } - - t1 := time.Now() - - // only 1 ifft is needed - sumVecInv, err := p.Fs.FFTG1(sumVec, true) - if err != nil { - return nil, fmt.Errorf("fft error: %v", err) - } - - t2 := time.Now() - - // outputs is out of order - buttefly - proofs, err := p.Fs.FFTG1(sumVecInv[:dimE], false) - if err != nil { - return nil, err - } - - t3 := time.Now() - - fmt.Printf("mult-th %v, msm %v,fft1 %v, fft2 %v,\n", t0.Sub(begin), t1.Sub(t0), t2.Sub(t1), t3.Sub(t2)) - - return proofs, nil -} - -func (p *ParametrizedProver) proofWorker( - polyFr []fr.Element, - jobChan <-chan uint64, - l uint64, - dimE uint64, - coeffStore [][]fr.Element, - results chan<- WorkerResult, -) { - - for j := range jobChan { - coeffs, err := p.GetSlicesCoeff(polyFr, dimE, j, l) - if err != nil { - results <- WorkerResult{ - points: nil, - err: err, - } - } else { - for i := 0; i < len(coeffs); i++ { - coeffStore[i][j] = coeffs[i] - } + }() + + go func() { + start := time.Now() + lengthProof, err := g.Computer.ComputeLengthProof(inputFr) + lengthProofChan <- LengthProofResult{ + LengthProof: *lengthProof, + Err: err, + Duration: time.Since(start), + } + }() + + go func() { + start := time.Now() + // compute proofs + paddedCoeffs := make([]fr.Element, g.NumEvaluations()) + // polyCoeffs has less points than paddedCoeffs in general due to erasure redundancy + copy(paddedCoeffs, inputFr) + + numBlob := 1 + flatpaddedCoeffs := make([]fr.Element, 0, numBlob*len(paddedCoeffs)) + for i := 0; i < numBlob; i++ { + flatpaddedCoeffs = append(flatpaddedCoeffs, paddedCoeffs...) } - } - - results <- WorkerResult{ - err: nil, - } -} - -// output is in the form see primeField toeplitz -// -// 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) { - // there is a constant term - m := uint64(len(polyFr)) - 1 - dim := (m - j) / l - - toeV := make([]fr.Element, 2*dimE-1) - for i := uint64(0); i < dim; i++ { - toeV[i].Set(&polyFr[m-(j+i*l)]) + proofs, err := g.Computer.ComputeMultiFrameProof(flatpaddedCoeffs, g.NumChunks, g.ChunkLength, g.NumWorker) + proofChan <- ProofsResult{ + Proofs: proofs, + Err: err, + Duration: time.Since(start), + } + }() + + lengthProofResult := <-lengthProofChan + lengthCommitmentResult := <-lengthCommitmentChan + commitmentResult := <-commitmentChan + rsResult := <-rsChan + proofsResult := <-proofChan + + if lengthProofResult.Err != nil || lengthCommitmentResult.Err != nil || + commitmentResult.Err != nil || rsResult.Err != nil || + proofsResult.Err != nil { + return nil, nil, nil, nil, nil, multierror.Append(lengthProofResult.Err, lengthCommitmentResult.Err, commitmentResult.Err, rsResult.Err, proofsResult.Err) + } + totalProcessingTime := time.Since(encodeStart) + + log.Printf("\n\t\tRS encode %-v\n\t\tCommiting %-v\n\t\tLengthCommit %-v\n\t\tlengthProof %-v\n\t\tmultiProof %-v\n\t\tMetaInfo. order %-v shift %v\n", + rsResult.Duration, + commitmentResult.Duration, + lengthCommitmentResult.Duration, + lengthProofResult.Duration, + proofsResult.Duration, + g.SRSOrder, + g.SRSOrder-uint64(len(inputFr)), + ) + + // assemble frames + kzgFrames := make([]encoding.Frame, len(rsResult.Frames)) + for i, index := range rsResult.Indices { + kzgFrames[i] = encoding.Frame{ + Proof: proofsResult.Proofs[index], + Coeffs: rsResult.Frames[i].Coeffs, + } } - // use precompute table - tm, err := toeplitz.NewToeplitz(toeV, p.SFs) - if err != nil { - return nil, err + if g.Verbose { + log.Printf("Total encoding took %v\n", totalProcessingTime) } - return tm.GetFFTCoeff() -} - -/* -returns the power of 2 which is immediately bigger than the input -*/ -func CeilIntPowerOf2Num(d uint64) uint64 { - nextPower := math.Ceil(math.Log2(float64(d))) - return uint64(math.Pow(2.0, nextPower)) + return &commitmentResult.Commitment, &lengthCommitmentResult.LengthCommitment, &lengthProofResult.LengthProof, kzgFrames, rsResult.Indices, nil } diff --git a/encoding/kzg/prover/proof_computer.go b/encoding/kzg/prover/proof_computer.go new file mode 100644 index 000000000..658ec7b34 --- /dev/null +++ b/encoding/kzg/prover/proof_computer.go @@ -0,0 +1,209 @@ +package prover + +import ( + "fmt" + "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 CpuProofComputer 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 *CpuProofComputer) ComputeLengthProof(coeffs []fr.Element) (*bn254.G2Affine, error) { + inputLength := uint64(len(coeffs)) + shiftedSecret := p.G2Trailing[p.KzgConfig.SRSNumberToLoad-inputLength:] + config := ecc.MultiExpConfig{} + //The proof of low degree is commitment of the polynomial shifted to the largest srs degree + var lengthProof bn254.G2Affine + _, err := lengthProof.MultiExp(shiftedSecret, coeffs, config) + if err != nil { + return nil, err + } + return &lengthProof, nil +} + +func (p *CpuProofComputer) ComputeCommitment(coeffs []fr.Element) (*bn254.G1Affine, error) { + // compute commit for the full poly + config := ecc.MultiExpConfig{} + var commitment bn254.G1Affine + _, err := commitment.MultiExp(p.Srs.G1[:len(coeffs)], coeffs, config) + if err != nil { + return nil, err + } + return &commitment, nil +} + +func (p *CpuProofComputer) ComputeLengthCommitment(coeffs []fr.Element) (*bn254.G2Affine, error) { + config := ecc.MultiExpConfig{} + + var lengthCommitment bn254.G2Affine + _, err := lengthCommitment.MultiExp(p.Srs.G2[:len(coeffs)], coeffs, config) + if err != nil { + return nil, err + } + return &lengthCommitment, nil +} + +func (p *CpuProofComputer) 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 + l := chunkLen + + sumVec := make([]bn254.G1Affine, dimE*2) + + jobChan := make(chan uint64, numWorker) + results := make(chan WorkerResult, numWorker) + + // create storage for intermediate fft outputs + coeffStore := make([][]fr.Element, dimE*2) + for i := range coeffStore { + coeffStore[i] = make([]fr.Element, l) + } + + for w := uint64(0); w < numWorker; w++ { + go p.proofWorker(polyFr, jobChan, l, dimE, coeffStore, results) + } + + for j := uint64(0); j < l; j++ { + jobChan <- j + } + close(jobChan) + + // return last error + var err error + for w := uint64(0); w < numWorker; w++ { + wr := <-results + if wr.err != nil { + err = wr.err + } + } + + if err != nil { + return nil, fmt.Errorf("proof worker error: %v", err) + } + + t0 := time.Now() + + // compute proof by multi scaler multiplication + msmErrors := make(chan error, dimE*2) + for i := uint64(0); i < dimE*2; i++ { + + go func(k uint64) { + _, err := sumVec[k].MultiExp(p.FFTPointsT[k], coeffStore[k], ecc.MultiExpConfig{}) + // handle error + msmErrors <- err + }(i) + } + + for i := uint64(0); i < dimE*2; i++ { + err := <-msmErrors + if err != nil { + fmt.Println("Error. MSM while adding points", err) + return nil, err + } + } + + t1 := time.Now() + + // only 1 ifft is needed + sumVecInv, err := p.Fs.FFTG1(sumVec, true) + if err != nil { + return nil, fmt.Errorf("fft error: %v", err) + } + + t2 := time.Now() + + // outputs is out of order - buttefly + proofs, err := p.Fs.FFTG1(sumVecInv[:dimE], false) + if err != nil { + return nil, err + } + + t3 := time.Now() + + fmt.Printf("mult-th %v, msm %v,fft1 %v, fft2 %v,\n", t0.Sub(begin), t1.Sub(t0), t2.Sub(t1), t3.Sub(t2)) + + return proofs, nil +} + +func (p *CpuProofComputer) proofWorker( + polyFr []fr.Element, + jobChan <-chan uint64, + l uint64, + dimE uint64, + coeffStore [][]fr.Element, + results chan<- WorkerResult, +) { + + for j := range jobChan { + coeffs, err := p.GetSlicesCoeff(polyFr, dimE, j, l) + if err != nil { + results <- WorkerResult{ + points: nil, + err: err, + } + } else { + for i := 0; i < len(coeffs); i++ { + coeffStore[i][j] = coeffs[i] + } + } + } + + results <- WorkerResult{ + err: nil, + } +} + +// output is in the form see primeField toeplitz +// +// phi ^ (coset size ) = 1 +// +// implicitly pad slices to power of 2 +func (p *CpuProofComputer) 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 + + // maximal number of unique values from a toeplitz matrix + tDim := 2*dimE - 1 + + toeV := make([]fr.Element, tDim) + for i := uint64(0); i < dim; i++ { + + toeV[i].Set(&polyFr[m-(j+i*l)]) + } + + // use precompute table + tm, err := toeplitz.NewToeplitz(toeV, p.SFs) + if err != nil { + return nil, err + } + return tm.GetFFTCoeff() +} + +/* +returns the power of 2 which is immediately bigger than the input +*/ +func CeilIntPowerOf2Num(d uint64) uint64 { + nextPower := math.Ceil(math.Log2(float64(d))) + return uint64(math.Pow(2.0, nextPower)) +} diff --git a/encoding/kzg/prover/proof_device.go b/encoding/kzg/prover/proof_device.go new file mode 100644 index 000000000..680b9ab09 --- /dev/null +++ b/encoding/kzg/prover/proof_device.go @@ -0,0 +1,14 @@ +package prover + +import ( + "github.com/consensys/gnark-crypto/ecc/bn254" + "github.com/consensys/gnark-crypto/ecc/bn254/fr" +) + +type ProofComputer 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) +} diff --git a/encoding/kzg/prover/prover.go b/encoding/kzg/prover/prover.go index f3fec7ef1..d5a2768c3 100644 --- a/encoding/kzg/prover/prover.go +++ b/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 := &CpuProofComputer{ 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 } diff --git a/encoding/rs/encode.go b/encoding/rs/encode.go index 401b6f963..241f0b27d 100644 --- a/encoding/rs/encode.go +++ b/encoding/rs/encode.go @@ -18,10 +18,10 @@ type GlobalPoly struct { } // just a wrapper to take bytes not Fr Element -func (g *Encoder) EncodeBytes(inputBytes []byte) (*GlobalPoly, []Frame, []uint32, error) { +func (g *Encoder) EncodeBytes(inputBytes []byte) ([]Frame, []uint32, error) { inputFr, err := ToFrArray(inputBytes) if err != nil { - return nil, nil, nil, fmt.Errorf("cannot convert bytes to field elements, %w", err) + return nil, nil, fmt.Errorf("cannot convert bytes to field elements, %w", err) } return g.Encode(inputFr) } @@ -33,7 +33,7 @@ func (g *Encoder) EncodeBytes(inputBytes []byte) (*GlobalPoly, []Frame, []uint32 // frame, the multireveal interpolating coefficients are identical to the part of input bytes // in the form of field element. The extra returned integer list corresponds to which leading // coset root of unity, the frame is proving against, which can be deduced from a frame's index -func (g *Encoder) Encode(inputFr []fr.Element) (*GlobalPoly, []Frame, []uint32, error) { +func (g *Encoder) Encode(inputFr []fr.Element) ([]Frame, []uint32, error) { start := time.Now() intermediate := time.Now() @@ -42,12 +42,7 @@ func (g *Encoder) Encode(inputFr []fr.Element) (*GlobalPoly, []Frame, []uint32, // extend data based on Sys, Par ratio. The returned fullCoeffsPoly is padded with 0 to ease proof polyEvals, _, err := g.ExtendPolyEval(polyCoeffs) if err != nil { - return nil, nil, nil, err - } - - poly := &GlobalPoly{ - Values: polyEvals, - Coeffs: polyCoeffs, + return nil, nil, err } if g.verbose { @@ -57,13 +52,13 @@ func (g *Encoder) Encode(inputFr []fr.Element) (*GlobalPoly, []Frame, []uint32, // create frames to group relevant info frames, indices, err := g.MakeFrames(polyEvals) if err != nil { - return nil, nil, nil, err + return nil, nil, err } log.Printf(" SUMMARY: RSEncode %v byte among %v numChunks with chunkLength %v takes %v\n", len(inputFr)*encoding.BYTES_PER_SYMBOL, g.NumChunks, g.ChunkLength, time.Since(start)) - return poly, frames, indices, nil + return frames, indices, nil } // MakeFrames function takes extended evaluation data and bundles relevant information into Frame. diff --git a/encoding/rs/encode_test.go b/encoding/rs/encode_test.go index 832e369b5..fd43fec67 100644 --- a/encoding/rs/encode_test.go +++ b/encoding/rs/encode_test.go @@ -22,7 +22,7 @@ func TestEncodeDecode_InvertsWhenSamplingAllFrames(t *testing.T) { inputFr, err := rs.ToFrArray(GETTYSBURG_ADDRESS_BYTES) assert.Nil(t, err) - _, frames, _, err := enc.Encode(inputFr) + frames, _, err := enc.Encode(inputFr) assert.Nil(t, err) // sample some frames @@ -45,7 +45,7 @@ func TestEncodeDecode_InvertsWhenSamplingMissingFrame(t *testing.T) { inputFr, err := rs.ToFrArray(GETTYSBURG_ADDRESS_BYTES) assert.Nil(t, err) - _, frames, _, err := enc.Encode(inputFr) + frames, _, err := enc.Encode(inputFr) assert.Nil(t, err) // sample some frames @@ -70,7 +70,7 @@ func TestEncodeDecode_ErrorsWhenNotEnoughSampledFrames(t *testing.T) { inputFr, err := rs.ToFrArray(GETTYSBURG_ADDRESS_BYTES) assert.Nil(t, err) - _, frames, _, err := enc.Encode(inputFr) + frames, _, err := enc.Encode(inputFr) assert.Nil(t, err) // sample some frames diff --git a/encoding/rs/encoder_fuzz_test.go b/encoding/rs/encoder_fuzz_test.go index 0c70d5464..b9eb1a7bc 100644 --- a/encoding/rs/encoder_fuzz_test.go +++ b/encoding/rs/encoder_fuzz_test.go @@ -20,7 +20,7 @@ func FuzzOnlySystematic(f *testing.F) { } //encode the data - _, frames, _, err := enc.EncodeBytes(input) + frames, _, err := enc.EncodeBytes(input) if err != nil { t.Errorf("Error Encoding:\n Data:\n %q \n Err: %q", input, err) } diff --git a/encoding/rs/frame_test.go b/encoding/rs/frame_test.go index dc230664e..717b64ff7 100644 --- a/encoding/rs/frame_test.go +++ b/encoding/rs/frame_test.go @@ -17,7 +17,7 @@ func TestEncodeDecodeFrame_AreInverses(t *testing.T) { enc, _ := rs.NewEncoder(params, true) require.NotNil(t, enc) - _, frames, _, err := enc.EncodeBytes(GETTYSBURG_ADDRESS_BYTES) + frames, _, err := enc.EncodeBytes(GETTYSBURG_ADDRESS_BYTES) require.Nil(t, err) require.NotNil(t, frames, err) diff --git a/encoding/test/main.go b/encoding/test/main.go index c2b163935..fb8314c4d 100644 --- a/encoding/test/main.go +++ b/encoding/test/main.go @@ -18,14 +18,15 @@ import ( ) func main() { - // TestKzgRs() + TestKzgRs() //err := kzg.WriteGeneratorPoints(30000) //if err != nil { // log.Println("WriteGeneratorPoints failed:", err) //} - readpoints() + //readpoints() } +/* func readpoints() { kzgConfig := &kzg.KzgConfig{ G1Path: "../../inabox/resources/kzg/g1.point", @@ -47,9 +48,10 @@ func readpoints() { fmt.Println("start with gen") } } +*/ func TestKzgRs() { - numSymbols := 3 + numSymbols := 1024 // encode parameters numNode := uint64(4) // 200 numSys := uint64(2) // 180 @@ -61,18 +63,19 @@ func TestKzgRs() { //fmt.Printf(" Data size(byte): %v\n", len(inputBytes)) kzgConfig := &kzg.KzgConfig{ - G1Path: "g1.point", - G2Path: "g2.point", + G1Path: "../../inabox/resources/kzg/g1.point", + G2Path: "../../inabox/resources/kzg/g2.point", CacheDir: "SRSTables", SRSOrder: 3000, SRSNumberToLoad: 3000, NumWorker: uint64(runtime.GOMAXPROCS(0)), + Verbose: true, } // create encoding object p, _ := prover.NewProver(kzgConfig, true) - params := encoding.EncodingParams{NumChunks: 200, ChunkLength: 180} + params := encoding.EncodingParams{NumChunks: numNode, ChunkLength: uint64(numSymbols) / numSys} enc, _ := p.GetKzgEncoder(params) //inputFr := kzg.ToFrArray(inputBytes)