gnark-plonky2-verifier/edwards_curve/edpoint_test.go
edwards_curve/edpoint_test.goRaw
1package edwards_curve
2
3import (
4 "math/big"
5 "testing"
6
7 "github.com/consensys/gnark-crypto/ecc"
8 "github.com/consensys/gnark/frontend"
9 "github.com/consensys/gnark/std/math/emulated"
10 "github.com/consensys/gnark/test"
11 // "github.com/ethereum/go-ethereum/crypto/secp256k1"
12)
13
14type OnCurveTest[T, S emulated.FieldParams] struct {
15 P AffinePoint[T]
16}
17
18func (c *OnCurveTest[T, S]) Define(api frontend.API) error {
19 cr, err := New[T, S](api)
20 if err != nil {
21 return err
22 }
23 cr.AssertIsOnCurve(c.P)
24 return nil
25}
26
27func TestGeneratorIsOnCurve(t *testing.T) {
28 assert := test.NewAssert(t)
29 circuit := OnCurveTest[Ed25519, Ed25519Scalars]{}
30 witness := OnCurveTest[Ed25519, Ed25519Scalars]{
31 P: AffinePoint[Ed25519]{
32 X: emulated.NewElement[Ed25519](newBigInt("216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A")),
33 Y: emulated.NewElement[Ed25519](newBigInt("6666666666666666666666666666666666666666666666666666666666666658")),
34 },
35 }
36 err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
37 assert.NoError(err)
38}
39
40// s1*x1 + s2*x2 = y
41type MulAddTest[T, S emulated.FieldParams] struct {
42 X1, X2 AffinePoint[T]
43 S1, S2 emulated.Element[S]
44 Y AffinePoint[T]
45}
46
47func (c *MulAddTest[T, S]) Define(api frontend.API) error {
48 cr, err := New[T, S](api)
49 if err != nil {
50 return err
51 }
52 X1S1 := cr.ScalarMul(c.X1, c.S1)
53 X2S2 := cr.ScalarMul(c.X2, c.S2)
54 sum := cr.Add(X1S1, X2S2)
55 cr.AssertIsEqual(sum, c.Y)
56 cr.scalarApi.AssertIsEqual(
57 cr.scalarApi.Add(c.S1, c.S2),
58 emulated.NewElement[S](big.NewInt(1)),
59 )
60 return nil
61}
62
63func TestGeneratorGeneratesCurveOfCorrectOrder(t *testing.T) {
64 assert := test.NewAssert(t)
65 Gx, Gy := Ed25519{}.Generator()
66 G := AffinePoint[Ed25519]{
67 X: emulated.NewElement[Ed25519](Gx),
68 Y: emulated.NewElement[Ed25519](Gy),
69 }
70 for i := 2; i <= 3; i++ {
71 S1 := new(big.Int).Sub(rEd25519, big.NewInt(int64(i - 1)))
72 S2 := big.NewInt(int64(i))
73 circuit := MulAddTest[Ed25519, Ed25519Scalars]{}
74 witness := MulAddTest[Ed25519, Ed25519Scalars]{
75 X1: G,
76 X2: G,
77 S1: emulated.NewElement[Ed25519Scalars](S1),
78 S2: emulated.NewElement[Ed25519Scalars](S2),
79 Y: G,
80 }
81 err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
82 assert.NoError(err)
83 }
84}
85
86var testCurve = ecc.BN254
87
88// type NegTest[T, S emulated.FieldParams] struct {
89// P, Q AffinePoint[T]
90// }
91
92// func (c *NegTest[T, S]) Define(api frontend.API) error {
93// cr, err := New[T, S](api)
94// if err != nil {
95// return err
96// }
97// res := cr.Neg(c.P)
98// cr.AssertIsEqual(res, c.Q)
99// return nil
100// }
101
102// func TestNeg(t *testing.T) {
103// assert := test.NewAssert(t)
104// secpCurve := secp256k1.S256()
105// yn := new(big.Int).Sub(secpCurve.P, secpCurve.Gy)
106// circuit := NegTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
107// witness := NegTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
108// P: AffinePoint[emulated.Secp256k1]{
109// X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
110// Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
111// },
112// Q: AffinePoint[emulated.Secp256k1]{
113// X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
114// Y: emulated.NewElement[emulated.Secp256k1](yn),
115// },
116// }
117// err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
118// assert.NoError(err)
119// }
120
121// type AddTest[T, S emulated.FieldParams] struct {
122// P, Q, R AffinePoint[T]
123// }
124
125// func (c *AddTest[T, S]) Define(api frontend.API) error {
126// cr, err := New[T, S](api)
127// if err != nil {
128// return err
129// }
130// res := cr.Add(c.P, c.Q)
131// cr.AssertIsEqual(res, c.R)
132// return nil
133// }
134
135// func TestAdd(t *testing.T) {
136// assert := test.NewAssert(t)
137// secpCurve := secp256k1.S256()
138// xd, yd := secpCurve.Double(secpCurve.Gx, secpCurve.Gy)
139// xa, ya := secpCurve.Add(xd, yd, secpCurve.Gx, secpCurve.Gy)
140// circuit := AddTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
141// witness := AddTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
142// P: AffinePoint[emulated.Secp256k1]{
143// X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
144// Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
145// },
146// Q: AffinePoint[emulated.Secp256k1]{
147// X: emulated.NewElement[emulated.Secp256k1](xd),
148// Y: emulated.NewElement[emulated.Secp256k1](yd),
149// },
150// R: AffinePoint[emulated.Secp256k1]{
151// X: emulated.NewElement[emulated.Secp256k1](xa),
152// Y: emulated.NewElement[emulated.Secp256k1](ya),
153// },
154// }
155// err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
156// assert.NoError(err)
157// }
158
159// type DoubleTest[T, S emulated.FieldParams] struct {
160// P, Q AffinePoint[T]
161// }
162
163// func (c *DoubleTest[T, S]) Define(api frontend.API) error {
164// cr, err := New[T, S](api)
165// if err != nil {
166// return err
167// }
168// res := cr.Double(c.P)
169// cr.AssertIsEqual(res, c.Q)
170// return nil
171// }
172
173// func TestDouble(t *testing.T) {
174// assert := test.NewAssert(t)
175// secpCurve := secp256k1.S256()
176// xd, yd := secpCurve.Double(secpCurve.Gx, secpCurve.Gy)
177// circuit := DoubleTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
178// witness := DoubleTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
179// P: AffinePoint[emulated.Secp256k1]{
180// X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
181// Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
182// },
183// Q: AffinePoint[emulated.Secp256k1]{
184// X: emulated.NewElement[emulated.Secp256k1](xd),
185// Y: emulated.NewElement[emulated.Secp256k1](yd),
186// },
187// }
188// err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
189// assert.NoError(err)
190// }
191
192// type ScalarMulTest[T, S emulated.FieldParams] struct {
193// P, Q AffinePoint[T]
194// S emulated.Element[S]
195// }
196
197// func (c *ScalarMulTest[T, S]) Define(api frontend.API) error {
198// cr, err := New[T, S](api)
199// if err != nil {
200// return err
201// }
202// res := cr.ScalarMul(c.P, c.S)
203// cr.AssertIsEqual(res, c.Q)
204// return nil
205// }
206
207// func TestScalarMul(t *testing.T) {
208// assert := test.NewAssert(t)
209// secpCurve := secp256k1.S256()
210// s, ok := new(big.Int).SetString("44693544921776318736021182399461740191514036429448770306966433218654680512345", 10)
211// assert.True(ok)
212// sx, sy := secpCurve.ScalarMult(secpCurve.Gx, secpCurve.Gy, s.Bytes())
213
214// circuit := ScalarMulTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
215// witness := ScalarMulTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
216// S: emulated.NewElement[emulated.Secp256k1Scalars](s),
217// P: AffinePoint[emulated.Secp256k1]{
218// X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
219// Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
220// },
221// Q: AffinePoint[emulated.Secp256k1]{
222// X: emulated.NewElement[emulated.Secp256k1](sx),
223// Y: emulated.NewElement[emulated.Secp256k1](sy),
224// },
225// }
226// err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
227// assert.NoError(err)
228// // _, err = frontend.Compile(testCurve.ScalarField(), r1cs.NewBuilder, &circuit)
229// // assert.NoError(err)
230// }