Skip to content

Commit 2268cab

Browse files
adecaroadecaro
committed
constructors
Signed-off-by: Angelo De Caro <adc@zurich.ibm.com>
1 parent a138079 commit 2268cab

File tree

1 file changed

+93
-42
lines changed

1 file changed

+93
-42
lines changed

‎math.go‎

Lines changed: 93 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -56,26 +56,26 @@ func CurveIDToString(id CurveID) string {
5656
}
5757

5858
var Curves []*Curve = []*Curve{
59-
{
60-
c: amcl.NewFp256bn(),
61-
GenG1: &G1{g1: (&amcl.Fp256bn{}).GenG1(), curveID: FP256BN_AMCL},
62-
GenG2: &G2{g2: (&amcl.Fp256bn{}).GenG2(), curveID: FP256BN_AMCL},
63-
GenGt: &Gt{gt: (&amcl.Fp256bn{}).GenGt(), curveID: FP256BN_AMCL},
64-
GroupOrder: &Zr{zr: amcl.NewFp256bn().GroupOrder(), curveID: FP256BN_AMCL},
65-
CoordByteSize: (&amcl.Fp256bn{}).CoordinateByteSize(),
66-
G1ByteSize: (&amcl.Fp256bn{}).G1ByteSize(),
67-
CompressedG1ByteSize: (&amcl.Fp256bn{}).CompressedG1ByteSize(),
68-
G2ByteSize: (&amcl.Fp256bn{}).G2ByteSize(),
69-
CompressedG2ByteSize: (&amcl.Fp256bn{}).CompressedG2ByteSize(),
70-
ScalarByteSize: (&amcl.Fp256bn{}).ScalarByteSize(),
71-
curveID: FP256BN_AMCL,
72-
},
59+
NewCurve(
60+
amcl.NewFp256bn(),
61+
NewG1((&amcl.Fp256bn{}).GenG1(), FP256BN_AMCL),
62+
NewG2((&amcl.Fp256bn{}).GenG2(), FP256BN_AMCL),
63+
NewGt((&amcl.Fp256bn{}).GenGt(), FP256BN_AMCL),
64+
NewZr(amcl.NewFp256bn().GroupOrder(), FP256BN_AMCL),
65+
(&amcl.Fp256bn{}).CoordinateByteSize(),
66+
(&amcl.Fp256bn{}).G1ByteSize(),
67+
(&amcl.Fp256bn{}).CompressedG1ByteSize(),
68+
(&amcl.Fp256bn{}).G2ByteSize(),
69+
(&amcl.Fp256bn{}).CompressedG2ByteSize(),
70+
(&amcl.Fp256bn{}).ScalarByteSize(),
71+
FP256BN_AMCL,
72+
),
7373
{
7474
c: gurvy.NewBn254(),
75-
GenG1: &G1{g1: (&gurvy.Bn254{}).GenG1(), curveID: BN254},
76-
GenG2: &G2{g2: (&gurvy.Bn254{}).GenG2(), curveID: BN254},
77-
GenGt: &Gt{gt: (&gurvy.Bn254{}).GenGt(), curveID: BN254},
78-
GroupOrder: &Zr{zr: gurvy.NewBn254().GroupOrder(), curveID: BN254},
75+
GenG1: NewG1((&gurvy.Bn254{}).GenG1(), BN254),
76+
GenG2: NewG2((&gurvy.Bn254{}).GenG2(), BN254),
77+
GenGt: NewGt((&gurvy.Bn254{}).GenGt(), BN254),
78+
GroupOrder: NewZr(gurvy.NewBn254().GroupOrder(), BN254),
7979
CoordByteSize: (&gurvy.Bn254{}).CoordinateByteSize(),
8080
G1ByteSize: (&gurvy.Bn254{}).G1ByteSize(),
8181
CompressedG1ByteSize: (&gurvy.Bn254{}).CompressedG1ByteSize(),
@@ -86,10 +86,10 @@ var Curves []*Curve = []*Curve{
8686
},
8787
{
8888
c: amcl.NewFp256Miraclbn(),
89-
GenG1: &G1{g1: (&amcl.Fp256Miraclbn{}).GenG1(), curveID: FP256BN_AMCL_MIRACL},
90-
GenG2: &G2{g2: (&amcl.Fp256Miraclbn{}).GenG2(), curveID: FP256BN_AMCL_MIRACL},
91-
GenGt: &Gt{gt: (&amcl.Fp256Miraclbn{}).GenGt(), curveID: FP256BN_AMCL_MIRACL},
92-
GroupOrder: &Zr{zr: amcl.NewFp256Miraclbn().GroupOrder(), curveID: FP256BN_AMCL_MIRACL},
89+
GenG1: NewG1((&amcl.Fp256Miraclbn{}).GenG1(), FP256BN_AMCL_MIRACL),
90+
GenG2: NewG2((&amcl.Fp256Miraclbn{}).GenG2(), FP256BN_AMCL_MIRACL),
91+
GenGt: NewGt((&amcl.Fp256Miraclbn{}).GenGt(), FP256BN_AMCL_MIRACL),
92+
GroupOrder: NewZr(amcl.NewFp256Miraclbn().GroupOrder(), FP256BN_AMCL_MIRACL),
9393
CoordByteSize: (&amcl.Fp256Miraclbn{}).CoordinateByteSize(),
9494
G1ByteSize: (&amcl.Fp256Miraclbn{}).G1ByteSize(),
9595
CompressedG1ByteSize: (&amcl.Fp256Miraclbn{}).CompressedG1ByteSize(),
@@ -100,10 +100,10 @@ var Curves []*Curve = []*Curve{
100100
},
101101
{
102102
c: kilic.NewBls12_381(),
103-
GenG1: &G1{g1: (&kilic.Bls12_381{}).GenG1(), curveID: BLS12_381},
104-
GenG2: &G2{g2: (&kilic.Bls12_381{}).GenG2(), curveID: BLS12_381},
105-
GenGt: &Gt{gt: (&kilic.Bls12_381{}).GenGt(), curveID: BLS12_381},
106-
GroupOrder: &Zr{zr: kilic.NewBls12_381().GroupOrder(), curveID: BLS12_381},
103+
GenG1: NewG1((&kilic.Bls12_381{}).GenG1(), BLS12_381),
104+
GenG2: NewG2((&kilic.Bls12_381{}).GenG2(), BLS12_381),
105+
GenGt: NewGt((&kilic.Bls12_381{}).GenGt(), BLS12_381),
106+
GroupOrder: NewZr(kilic.NewBls12_381().GroupOrder(), BLS12_381),
107107
CoordByteSize: (&kilic.Bls12_381{}).CoordinateByteSize(),
108108
G1ByteSize: (&kilic.Bls12_381{}).G1ByteSize(),
109109
CompressedG1ByteSize: (&kilic.Bls12_381{}).CompressedG1ByteSize(),
@@ -114,10 +114,10 @@ var Curves []*Curve = []*Curve{
114114
},
115115
{
116116
c: gurvy.NewBls12_377(),
117-
GenG1: &G1{g1: (&gurvy.Bls12_377{}).GenG1(), curveID: BLS12_377_GURVY},
118-
GenG2: &G2{g2: (&gurvy.Bls12_377{}).GenG2(), curveID: BLS12_377_GURVY},
119-
GenGt: &Gt{gt: (&gurvy.Bls12_377{}).GenGt(), curveID: BLS12_377_GURVY},
120-
GroupOrder: &Zr{zr: gurvy.NewBls12_377().GroupOrder(), curveID: BLS12_377_GURVY},
117+
GenG1: NewG1((&gurvy.Bls12_377{}).GenG1(), BLS12_377_GURVY),
118+
GenG2: NewG2((&gurvy.Bls12_377{}).GenG2(), BLS12_377_GURVY),
119+
GenGt: NewGt((&gurvy.Bls12_377{}).GenGt(), BLS12_377_GURVY),
120+
GroupOrder: NewZr(gurvy.NewBls12_377().GroupOrder(), BLS12_377_GURVY),
121121
CoordByteSize: (&gurvy.Bls12_377{}).CoordinateByteSize(),
122122
G1ByteSize: (&gurvy.Bls12_377{}).G1ByteSize(),
123123
CompressedG1ByteSize: (&gurvy.Bls12_377{}).CompressedG1ByteSize(),
@@ -128,10 +128,10 @@ var Curves []*Curve = []*Curve{
128128
},
129129
{
130130
c: gurvy.NewBls12_381(),
131-
GenG1: &G1{g1: (&gurvy.Bls12_381{}).GenG1(), curveID: BLS12_381_GURVY},
132-
GenG2: &G2{g2: (&gurvy.Bls12_381{}).GenG2(), curveID: BLS12_381_GURVY},
133-
GenGt: &Gt{gt: (&gurvy.Bls12_381{}).GenGt(), curveID: BLS12_381_GURVY},
134-
GroupOrder: &Zr{zr: gurvy.NewBls12_381().GroupOrder(), curveID: BLS12_381_GURVY},
131+
GenG1: NewG1((&gurvy.Bls12_381{}).GenG1(), BLS12_381_GURVY),
132+
GenG2: NewG2((&gurvy.Bls12_381{}).GenG2(), BLS12_381_GURVY),
133+
GenGt: NewGt((&gurvy.Bls12_381{}).GenGt(), BLS12_381_GURVY),
134+
GroupOrder: NewZr(gurvy.NewBls12_381().GroupOrder(), BLS12_381_GURVY),
135135
CoordByteSize: (&gurvy.Bls12_381{}).CoordinateByteSize(),
136136
G1ByteSize: (&gurvy.Bls12_381{}).G1ByteSize(),
137137
CompressedG1ByteSize: (&gurvy.Bls12_381{}).CompressedG1ByteSize(),
@@ -142,10 +142,10 @@ var Curves []*Curve = []*Curve{
142142
},
143143
{
144144
c: kilic.NewBls12_381BBS(),
145-
GenG1: &G1{g1: kilic.NewBls12_381BBS().GenG1(), curveID: BLS12_381_BBS},
146-
GenG2: &G2{g2: kilic.NewBls12_381BBS().GenG2(), curveID: BLS12_381_BBS},
147-
GenGt: &Gt{gt: kilic.NewBls12_381BBS().GenGt(), curveID: BLS12_381_BBS},
148-
GroupOrder: &Zr{zr: kilic.NewBls12_381().GroupOrder(), curveID: BLS12_381_BBS},
145+
GenG1: NewG1(kilic.NewBls12_381BBS().GenG1(), BLS12_381_BBS),
146+
GenG2: NewG2(kilic.NewBls12_381BBS().GenG2(), BLS12_381_BBS),
147+
GenGt: NewGt(kilic.NewBls12_381BBS().GenGt(), BLS12_381_BBS),
148+
GroupOrder: NewZr(kilic.NewBls12_381().GroupOrder(), BLS12_381_BBS),
149149
CoordByteSize: kilic.NewBls12_381BBS().CoordinateByteSize(),
150150
G1ByteSize: kilic.NewBls12_381BBS().G1ByteSize(),
151151
CompressedG1ByteSize: kilic.NewBls12_381BBS().CompressedG1ByteSize(),
@@ -156,10 +156,10 @@ var Curves []*Curve = []*Curve{
156156
},
157157
{
158158
c: gurvy.NewBls12_381BBS(),
159-
GenG1: &G1{g1: gurvy.NewBls12_381BBS().GenG1(), curveID: BLS12_381_BBS_GURVY},
160-
GenG2: &G2{g2: gurvy.NewBls12_381BBS().GenG2(), curveID: BLS12_381_BBS_GURVY},
161-
GenGt: &Gt{gt: gurvy.NewBls12_381BBS().GenGt(), curveID: BLS12_381_BBS_GURVY},
162-
GroupOrder: &Zr{zr: gurvy.NewBls12_381().GroupOrder(), curveID: BLS12_381_BBS_GURVY},
159+
GenG1: NewG1(gurvy.NewBls12_381BBS().GenG1(), BLS12_381_BBS_GURVY),
160+
GenG2: NewG2(gurvy.NewBls12_381BBS().GenG2(), BLS12_381_BBS_GURVY),
161+
GenGt: NewGt(gurvy.NewBls12_381BBS().GenGt(), BLS12_381_BBS_GURVY),
162+
GroupOrder: NewZr(gurvy.NewBls12_381().GroupOrder(), BLS12_381_BBS_GURVY),
163163
CoordByteSize: gurvy.NewBls12_381BBS().CoordinateByteSize(),
164164
G1ByteSize: gurvy.NewBls12_381BBS().G1ByteSize(),
165165
CompressedG1ByteSize: gurvy.NewBls12_381BBS().CompressedG1ByteSize(),
@@ -177,6 +177,11 @@ type Zr struct {
177177
curveID CurveID
178178
}
179179

180+
// NewZr return a new Zr for the given arguments
181+
func NewZr(zr driver.Zr, curveID CurveID) *Zr {
182+
return &Zr{zr: zr, curveID: curveID}
183+
}
184+
180185
func (z *Zr) CurveID() CurveID {
181186
return z.curveID
182187
}
@@ -257,6 +262,11 @@ type G1 struct {
257262
curveID CurveID
258263
}
259264

265+
// NewG1 return a new G1 for the given arguments
266+
func NewG1(g1 driver.G1, curveID CurveID) *G1 {
267+
return &G1{g1: g1, curveID: curveID}
268+
}
269+
260270
func (g *G1) CurveID() CurveID {
261271
return g.curveID
262272
}
@@ -316,6 +326,11 @@ type G2 struct {
316326
curveID CurveID
317327
}
318328

329+
// NewG2 return a new G2 for the given arguments
330+
func NewG2(g2 driver.G2, curveID CurveID) *G2 {
331+
return &G2{g2: g2, curveID: curveID}
332+
}
333+
319334
func (g *G2) CurveID() CurveID {
320335
return g.curveID
321336
}
@@ -367,6 +382,11 @@ type Gt struct {
367382
curveID CurveID
368383
}
369384

385+
// NewGt return a new Gt for the given arguments
386+
func NewGt(gt driver.Gt, curveID CurveID) *Gt {
387+
return &Gt{gt: gt, curveID: curveID}
388+
}
389+
370390
func (g *Gt) CurveID() CurveID {
371391
return g.curveID
372392
}
@@ -416,6 +436,37 @@ type Curve struct {
416436
curveID CurveID
417437
}
418438

439+
// NewCurve returns a new instance of Curve for the given arguments
440+
func NewCurve(
441+
c driver.Curve,
442+
genG1 *G1,
443+
genG2 *G2,
444+
genGt *Gt,
445+
groupOrder *Zr,
446+
coordByteSize int,
447+
g1ByteSize int,
448+
compressedG1ByteSize int,
449+
g2ByteSize int,
450+
compressedG2ByteSize int,
451+
scalarByteSize int,
452+
curveID CurveID,
453+
) *Curve {
454+
return &Curve{
455+
c: c,
456+
GenG1: genG1,
457+
GenG2: genG2,
458+
GenGt: genGt,
459+
GroupOrder: groupOrder,
460+
CoordByteSize: coordByteSize,
461+
G1ByteSize: g1ByteSize,
462+
CompressedG1ByteSize: compressedG1ByteSize,
463+
G2ByteSize: g2ByteSize,
464+
CompressedG2ByteSize: compressedG2ByteSize,
465+
ScalarByteSize: scalarByteSize,
466+
curveID: curveID,
467+
}
468+
}
469+
419470
func (c *Curve) Rand() (io.Reader, error) {
420471
return c.c.Rand()
421472
}

0 commit comments

Comments
 (0)