From bf7096562313efbf76e13f31772131f869cb61a1 Mon Sep 17 00:00:00 2001 From: Gautam Botrel Date: Thu, 5 Dec 2024 16:01:39 -0600 Subject: [PATCH 1/2] refactor: change fft domain encoder to not use ecc one --- ecc/bls12-377/fr/fft/domain.go | 28 +++++++++++++++---- ecc/bls12-381/fr/fft/domain.go | 28 +++++++++++++++---- ecc/bls24-315/fr/fft/domain.go | 28 +++++++++++++++---- ecc/bls24-317/fr/fft/domain.go | 28 +++++++++++++++---- ecc/bn254/fr/fft/domain.go | 28 +++++++++++++++---- ecc/bw6-633/fr/fft/domain.go | 28 +++++++++++++++---- ecc/bw6-761/fr/fft/domain.go | 28 +++++++++++++++---- .../generator/fft/template/domain.go.tmpl | 28 +++++++++++++++---- 8 files changed, 184 insertions(+), 40 deletions(-) diff --git a/ecc/bls12-377/fr/fft/domain.go b/ecc/bls12-377/fr/fft/domain.go index 74645ef46d..559dfa3eab 100644 --- a/ecc/bls12-377/fr/fft/domain.go +++ b/ecc/bls12-377/fr/fft/domain.go @@ -17,6 +17,7 @@ package fft import ( + "encoding/binary" "errors" "io" "math/big" @@ -257,18 +258,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader diff --git a/ecc/bls12-381/fr/fft/domain.go b/ecc/bls12-381/fr/fft/domain.go index 3bc21d6f86..d9060cdcfc 100644 --- a/ecc/bls12-381/fr/fft/domain.go +++ b/ecc/bls12-381/fr/fft/domain.go @@ -17,6 +17,7 @@ package fft import ( + "encoding/binary" "errors" "io" "math/big" @@ -257,18 +258,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader diff --git a/ecc/bls24-315/fr/fft/domain.go b/ecc/bls24-315/fr/fft/domain.go index 765f4a8276..59af12d01a 100644 --- a/ecc/bls24-315/fr/fft/domain.go +++ b/ecc/bls24-315/fr/fft/domain.go @@ -17,6 +17,7 @@ package fft import ( + "encoding/binary" "errors" "io" "math/big" @@ -257,18 +258,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader diff --git a/ecc/bls24-317/fr/fft/domain.go b/ecc/bls24-317/fr/fft/domain.go index 6fcdd4f337..52fa0d73e7 100644 --- a/ecc/bls24-317/fr/fft/domain.go +++ b/ecc/bls24-317/fr/fft/domain.go @@ -17,6 +17,7 @@ package fft import ( + "encoding/binary" "errors" "io" "math/big" @@ -257,18 +258,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader diff --git a/ecc/bn254/fr/fft/domain.go b/ecc/bn254/fr/fft/domain.go index 409ff7e4ff..fee420fd2d 100644 --- a/ecc/bn254/fr/fft/domain.go +++ b/ecc/bn254/fr/fft/domain.go @@ -17,6 +17,7 @@ package fft import ( + "encoding/binary" "errors" "io" "math/big" @@ -257,18 +258,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader diff --git a/ecc/bw6-633/fr/fft/domain.go b/ecc/bw6-633/fr/fft/domain.go index c36dfe4a27..9dcd04632a 100644 --- a/ecc/bw6-633/fr/fft/domain.go +++ b/ecc/bw6-633/fr/fft/domain.go @@ -17,6 +17,7 @@ package fft import ( + "encoding/binary" "errors" "io" "math/big" @@ -257,18 +258,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader diff --git a/ecc/bw6-761/fr/fft/domain.go b/ecc/bw6-761/fr/fft/domain.go index 276f1467d5..67ba0c5344 100644 --- a/ecc/bw6-761/fr/fft/domain.go +++ b/ecc/bw6-761/fr/fft/domain.go @@ -17,6 +17,7 @@ package fft import ( + "encoding/binary" "errors" "io" "math/big" @@ -257,18 +258,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader diff --git a/internal/generator/fft/template/domain.go.tmpl b/internal/generator/fft/template/domain.go.tmpl index a6953a29f0..2d3c11518d 100644 --- a/internal/generator/fft/template/domain.go.tmpl +++ b/internal/generator/fft/template/domain.go.tmpl @@ -5,6 +5,7 @@ import ( "runtime" "sync" "errors" + "encoding/binary" {{ template "import_fr" . }} {{ template "import_curve" . }} @@ -252,18 +253,35 @@ func precomputeExpTableChunk(w fr.Element, power uint64, table []fr.Element) { // WriteTo writes a binary representation of the domain (without the precomputed twiddle factors) // to the provided writer func (d *Domain) WriteTo(w io.Writer) (int64, error) { + // note to stay retro compatible with previous version using ecc/encoder, we encode as: + // d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute - enc := curve.NewEncoder(w) + var written int64 + var err error - toEncode := []interface{}{d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Write(w, binary.BigEndian, d.Cardinality) + if err != nil { + return written, err + } + written += 8 + toEncode := []*fr.Element{ &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toEncode { - if err := enc.Encode(v); err != nil { - return enc.BytesWritten(), err + buf := v.Bytes() + _, err = w.Write(buf[:]) + if err != nil { + return written, err } + written += fr.Bytes + } + + err = binary.Write(w, binary.BigEndian, d.withPrecompute) + if err != nil { + return written, err } + written += 1 - return enc.BytesWritten(), nil + return written, nil } // ReadFrom attempts to decode a domain from Reader From 3c3d0fa9ef9fbdd5bf1159183acf13054a3b4179 Mon Sep 17 00:00:00 2001 From: Gautam Botrel Date: Thu, 5 Dec 2024 16:07:05 -0600 Subject: [PATCH 2/2] refactor: remove dependency on ecc encoder in fft domain --- ecc/bls12-377/fr/fft/domain.go | 32 +++++++++++++++---- ecc/bls12-381/fr/fft/domain.go | 32 +++++++++++++++---- ecc/bls24-315/fr/fft/domain.go | 32 +++++++++++++++---- ecc/bls24-317/fr/fft/domain.go | 32 +++++++++++++++---- ecc/bn254/fr/fft/domain.go | 32 +++++++++++++++---- ecc/bw6-633/fr/fft/domain.go | 32 +++++++++++++++---- ecc/bw6-761/fr/fft/domain.go | 32 +++++++++++++++---- .../generator/fft/template/domain.go.tmpl | 31 ++++++++++++++---- 8 files changed, 200 insertions(+), 55 deletions(-) diff --git a/ecc/bls12-377/fr/fft/domain.go b/ecc/bls12-377/fr/fft/domain.go index 559dfa3eab..645b68f4e7 100644 --- a/ecc/bls12-377/fr/fft/domain.go +++ b/ecc/bls12-377/fr/fft/domain.go @@ -27,8 +27,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bls12-377/fr" - curve "github.com/consensys/gnark-crypto/ecc/bls12-377" - "github.com/consensys/gnark-crypto/ecc" ) @@ -292,19 +290,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error + + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil } diff --git a/ecc/bls12-381/fr/fft/domain.go b/ecc/bls12-381/fr/fft/domain.go index d9060cdcfc..7913415e10 100644 --- a/ecc/bls12-381/fr/fft/domain.go +++ b/ecc/bls12-381/fr/fft/domain.go @@ -27,8 +27,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bls12-381/fr" - curve "github.com/consensys/gnark-crypto/ecc/bls12-381" - "github.com/consensys/gnark-crypto/ecc" ) @@ -292,19 +290,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error + + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil } diff --git a/ecc/bls24-315/fr/fft/domain.go b/ecc/bls24-315/fr/fft/domain.go index 59af12d01a..1226a1b856 100644 --- a/ecc/bls24-315/fr/fft/domain.go +++ b/ecc/bls24-315/fr/fft/domain.go @@ -27,8 +27,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bls24-315/fr" - curve "github.com/consensys/gnark-crypto/ecc/bls24-315" - "github.com/consensys/gnark-crypto/ecc" ) @@ -292,19 +290,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error + + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil } diff --git a/ecc/bls24-317/fr/fft/domain.go b/ecc/bls24-317/fr/fft/domain.go index 52fa0d73e7..e60bb48d9d 100644 --- a/ecc/bls24-317/fr/fft/domain.go +++ b/ecc/bls24-317/fr/fft/domain.go @@ -27,8 +27,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bls24-317/fr" - curve "github.com/consensys/gnark-crypto/ecc/bls24-317" - "github.com/consensys/gnark-crypto/ecc" ) @@ -292,19 +290,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error + + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil } diff --git a/ecc/bn254/fr/fft/domain.go b/ecc/bn254/fr/fft/domain.go index fee420fd2d..f80b4e95f8 100644 --- a/ecc/bn254/fr/fft/domain.go +++ b/ecc/bn254/fr/fft/domain.go @@ -27,8 +27,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bn254/fr" - curve "github.com/consensys/gnark-crypto/ecc/bn254" - "github.com/consensys/gnark-crypto/ecc" ) @@ -292,19 +290,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error + + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil } diff --git a/ecc/bw6-633/fr/fft/domain.go b/ecc/bw6-633/fr/fft/domain.go index 9dcd04632a..3174495684 100644 --- a/ecc/bw6-633/fr/fft/domain.go +++ b/ecc/bw6-633/fr/fft/domain.go @@ -27,8 +27,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bw6-633/fr" - curve "github.com/consensys/gnark-crypto/ecc/bw6-633" - "github.com/consensys/gnark-crypto/ecc" ) @@ -292,19 +290,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error + + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil } diff --git a/ecc/bw6-761/fr/fft/domain.go b/ecc/bw6-761/fr/fft/domain.go index 67ba0c5344..ba2932fb9f 100644 --- a/ecc/bw6-761/fr/fft/domain.go +++ b/ecc/bw6-761/fr/fft/domain.go @@ -27,8 +27,6 @@ import ( "github.com/consensys/gnark-crypto/ecc/bw6-761/fr" - curve "github.com/consensys/gnark-crypto/ecc/bw6-761" - "github.com/consensys/gnark-crypto/ecc" ) @@ -292,19 +290,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error + + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil } diff --git a/internal/generator/fft/template/domain.go.tmpl b/internal/generator/fft/template/domain.go.tmpl index 2d3c11518d..59a87a6c19 100644 --- a/internal/generator/fft/template/domain.go.tmpl +++ b/internal/generator/fft/template/domain.go.tmpl @@ -8,7 +8,6 @@ import ( "encoding/binary" {{ template "import_fr" . }} - {{ template "import_curve" . }} "github.com/consensys/gnark-crypto/ecc" ) @@ -287,19 +286,39 @@ func (d *Domain) WriteTo(w io.Writer) (int64, error) { // ReadFrom attempts to decode a domain from Reader func (d *Domain) ReadFrom(r io.Reader) (int64, error) { - dec := curve.NewDecoder(r) + var read int64 + var err error - toDecode := []interface{}{&d.Cardinality, &d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv, &d.withPrecompute} + err = binary.Read(r, binary.BigEndian, &d.Cardinality) + if err != nil { + return read, err + } + read += 8 + + toDecode := []*fr.Element{&d.CardinalityInv, &d.Generator, &d.GeneratorInv, &d.FrMultiplicativeGen, &d.FrMultiplicativeGenInv} for _, v := range toDecode { - if err := dec.Decode(v); err != nil { - return dec.BytesRead(), err + var buf [fr.Bytes]byte + _, err = r.Read(buf[:]) + if err != nil { + return read, err } + read += fr.Bytes + *v, err = fr.BigEndian.Element(&buf) + if err != nil { + return read, err + } + } + + err = binary.Read(r, binary.BigEndian, &d.withPrecompute) + if err != nil { + return read, err } + read += 1 if d.withPrecompute { d.preComputeTwiddles() } - return dec.BytesRead(), nil + return read, nil }