1package edwards_curve
  2
  3import (
  4	"testing"
  5
  6	"github.com/consensys/gnark-crypto/ecc"
  7	"github.com/consensys/gnark/frontend"
  8	"github.com/consensys/gnark/std/math/emulated"
  9	"github.com/consensys/gnark/test"
 10	// "github.com/ethereum/go-ethereum/crypto/secp256k1"
 11)
 12
 13type OnCurveTest[T, S emulated.FieldParams] struct {
 14	P AffinePoint[T]
 15}
 16
 17func (c *OnCurveTest[T, S]) Define(api frontend.API) error {
 18	cr, err := New[T, S](api)
 19	if err != nil {
 20		return err
 21	}
 22	cr.AssertIsOnCurve(c.P)
 23	return nil
 24}
 25
 26func TestGenerator(t *testing.T) {
 27	assert := test.NewAssert(t)
 28	circuit := OnCurveTest[Ed25519, Ed25519Scalars]{}
 29	witness := OnCurveTest[Ed25519, Ed25519Scalars]{
 30		P: AffinePoint[Ed25519]{
 31			X: emulated.NewElement[Ed25519](newBigInt("216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A")),
 32			Y: emulated.NewElement[Ed25519](newBigInt("6666666666666666666666666666666666666666666666666666666666666658")),
 33		},
 34	}
 35	err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
 36	assert.NoError(err)
 37}
 38
 39var testCurve = ecc.BN254
 40
 41// type NegTest[T, S emulated.FieldParams] struct {
 42// 	P, Q AffinePoint[T]
 43// }
 44
 45// func (c *NegTest[T, S]) Define(api frontend.API) error {
 46// 	cr, err := New[T, S](api)
 47// 	if err != nil {
 48// 		return err
 49// 	}
 50// 	res := cr.Neg(c.P)
 51// 	cr.AssertIsEqual(res, c.Q)
 52// 	return nil
 53// }
 54
 55// func TestNeg(t *testing.T) {
 56// 	assert := test.NewAssert(t)
 57// 	secpCurve := secp256k1.S256()
 58// 	yn := new(big.Int).Sub(secpCurve.P, secpCurve.Gy)
 59// 	circuit := NegTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
 60// 	witness := NegTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
 61// 		P: AffinePoint[emulated.Secp256k1]{
 62// 			X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
 63// 			Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
 64// 		},
 65// 		Q: AffinePoint[emulated.Secp256k1]{
 66// 			X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
 67// 			Y: emulated.NewElement[emulated.Secp256k1](yn),
 68// 		},
 69// 	}
 70// 	err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
 71// 	assert.NoError(err)
 72// }
 73
 74// type AddTest[T, S emulated.FieldParams] struct {
 75// 	P, Q, R AffinePoint[T]
 76// }
 77
 78// func (c *AddTest[T, S]) Define(api frontend.API) error {
 79// 	cr, err := New[T, S](api)
 80// 	if err != nil {
 81// 		return err
 82// 	}
 83// 	res := cr.Add(c.P, c.Q)
 84// 	cr.AssertIsEqual(res, c.R)
 85// 	return nil
 86// }
 87
 88// func TestAdd(t *testing.T) {
 89// 	assert := test.NewAssert(t)
 90// 	secpCurve := secp256k1.S256()
 91// 	xd, yd := secpCurve.Double(secpCurve.Gx, secpCurve.Gy)
 92// 	xa, ya := secpCurve.Add(xd, yd, secpCurve.Gx, secpCurve.Gy)
 93// 	circuit := AddTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
 94// 	witness := AddTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
 95// 		P: AffinePoint[emulated.Secp256k1]{
 96// 			X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
 97// 			Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
 98// 		},
 99// 		Q: AffinePoint[emulated.Secp256k1]{
100// 			X: emulated.NewElement[emulated.Secp256k1](xd),
101// 			Y: emulated.NewElement[emulated.Secp256k1](yd),
102// 		},
103// 		R: AffinePoint[emulated.Secp256k1]{
104// 			X: emulated.NewElement[emulated.Secp256k1](xa),
105// 			Y: emulated.NewElement[emulated.Secp256k1](ya),
106// 		},
107// 	}
108// 	err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
109// 	assert.NoError(err)
110// }
111
112// type DoubleTest[T, S emulated.FieldParams] struct {
113// 	P, Q AffinePoint[T]
114// }
115
116// func (c *DoubleTest[T, S]) Define(api frontend.API) error {
117// 	cr, err := New[T, S](api)
118// 	if err != nil {
119// 		return err
120// 	}
121// 	res := cr.Double(c.P)
122// 	cr.AssertIsEqual(res, c.Q)
123// 	return nil
124// }
125
126// func TestDouble(t *testing.T) {
127// 	assert := test.NewAssert(t)
128// 	secpCurve := secp256k1.S256()
129// 	xd, yd := secpCurve.Double(secpCurve.Gx, secpCurve.Gy)
130// 	circuit := DoubleTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
131// 	witness := DoubleTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
132// 		P: AffinePoint[emulated.Secp256k1]{
133// 			X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
134// 			Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
135// 		},
136// 		Q: AffinePoint[emulated.Secp256k1]{
137// 			X: emulated.NewElement[emulated.Secp256k1](xd),
138// 			Y: emulated.NewElement[emulated.Secp256k1](yd),
139// 		},
140// 	}
141// 	err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
142// 	assert.NoError(err)
143// }
144
145// type ScalarMulTest[T, S emulated.FieldParams] struct {
146// 	P, Q AffinePoint[T]
147// 	S    emulated.Element[S]
148// }
149
150// func (c *ScalarMulTest[T, S]) Define(api frontend.API) error {
151// 	cr, err := New[T, S](api)
152// 	if err != nil {
153// 		return err
154// 	}
155// 	res := cr.ScalarMul(c.P, c.S)
156// 	cr.AssertIsEqual(res, c.Q)
157// 	return nil
158// }
159
160// func TestScalarMul(t *testing.T) {
161// 	assert := test.NewAssert(t)
162// 	secpCurve := secp256k1.S256()
163// 	s, ok := new(big.Int).SetString("44693544921776318736021182399461740191514036429448770306966433218654680512345", 10)
164// 	assert.True(ok)
165// 	sx, sy := secpCurve.ScalarMult(secpCurve.Gx, secpCurve.Gy, s.Bytes())
166
167// 	circuit := ScalarMulTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{}
168// 	witness := ScalarMulTest[emulated.Secp256k1, emulated.Secp256k1Scalars]{
169// 		S: emulated.NewElement[emulated.Secp256k1Scalars](s),
170// 		P: AffinePoint[emulated.Secp256k1]{
171// 			X: emulated.NewElement[emulated.Secp256k1](secpCurve.Gx),
172// 			Y: emulated.NewElement[emulated.Secp256k1](secpCurve.Gy),
173// 		},
174// 		Q: AffinePoint[emulated.Secp256k1]{
175// 			X: emulated.NewElement[emulated.Secp256k1](sx),
176// 			Y: emulated.NewElement[emulated.Secp256k1](sy),
177// 		},
178// 	}
179// 	err := test.IsSolved(&circuit, &witness, testCurve.ScalarField())
180// 	assert.NoError(err)
181// 	// _, err = frontend.Compile(testCurve.ScalarField(), r1cs.NewBuilder, &circuit)
182// 	// assert.NoError(err)
183// }