refactor: commit and stage1 now incremental

4 files changed, 42 insertions, 40 deletions

diff --git a/nizk/commit.go b/nizk/commit.go
index 7f46d36..5b703d9 100644
--- a/nizk/commit.go
+++ b/nizk/commit.go
@@ -11,7 +11,7 @@ import (
 //
 // for given C, A and B
 
-type Bid struct {
+type Bit struct {
 	bitSet bool
 	α      *Scalar
 	β      *Scalar
@@ -23,32 +23,32 @@ type Commitment struct {
 	C *Point // g^(ab)g^(bitSet)
 }
 
-func NewBid(bitSet bool) *Bid {
+func NewBit(bitSet bool) *Bit {
 	α, β := Curve.RandomScalar(), Curve.RandomScalar()
-	return NewBidFromScalars(bitSet, α, β)
+	return NewBitFromScalars(bitSet, α, β)
 }
 
-func NewBidFromScalars(bitSet bool, α, β *Scalar) *Bid {
-	return &Bid{
+func NewBitFromScalars(bitSet bool, α, β *Scalar) *Bit {
+	return &Bit{
 		α:      α,
 		β:      β,
 		bitSet: bitSet,
 	}
 }
 
-func commitment(α, β *Scalar, bitSet bool) *Commitment {
+func (b *Bit) commitment() *Commitment {
 	var C *Point
-	c := α.Mul(β)
+	c := b.α.Mul(b.β)
 
-	if bitSet {
+	if b.bitSet {
 		C = G.Exp(c.Add(One))
 	} else {
 		C = G.Exp(c)
 	}
 	return &Commitment{
 		C: C,
-		A: G.Exp(α),
-		B: G.Exp(β),
+		A: G.Exp(b.α),
+		B: G.Exp(b.β),
 	}
 }
 
@@ -62,7 +62,7 @@ type Proof struct {
 	}
 }
 
-func (s *Bid) proof(id Bytes, c *Commitment) *Proof {
+func (s *Bit) proof(id Bytes, c *Commitment) *Proof {
 	var e [2][2]*Point
 	var r1, r2, w *Scalar
 	r1 = Curve.RandomScalar()
@@ -101,8 +101,8 @@ func (s *Bid) proof(id Bytes, c *Commitment) *Proof {
 	return pr
 }
 
-func (s *Bid) Commit(id Bytes) (*Commitment, *Proof) {
-	c := commitment(s.α, s.β, s.bitSet)
+func (s *Bit) Commit(id Bytes) (*Commitment, *Proof) {
+	c := s.commitment()
 	return c, s.proof(id, c)
 }
 
diff --git a/nizk/commit_test.go b/nizk/commit_test.go
index 32d337b..061a772 100644
--- a/nizk/commit_test.go
+++ b/nizk/commit_test.go
@@ -10,7 +10,7 @@ func TestStatement(t *testing.T) {
 	id := Curve.RandomScalar()
 	Id := G.Exp(id)
 
-	st1, st2 := NewBid(true), NewBid(false)
+	st1, st2 := NewBit(true), NewBit(false)
 	c1, p1 := st1.Commit(Id)
 	c2, p2 := st2.Commit(Id)
 	if !c1.Verify(p1) {
@@ -31,7 +31,7 @@ func TestStatementFromScalar(t *testing.T) {
 
 	Id := G.Exp(id)
 
-	st1, st2 := NewBidFromScalars(true, α, β), NewBidFromScalars(false, α, β)
+	st1, st2 := NewBitFromScalars(true, α, β), NewBitFromScalars(false, α, β)
 	c1, p1 := st1.Commit(Id)
 	c2, p2 := st2.Commit(Id)
 	if !c1.Verify(p1) {
diff --git a/nizk/stage1.go b/nizk/stage1.go
index 3d07224..ff42e7f 100644
--- a/nizk/stage1.go
+++ b/nizk/stage1.go
@@ -8,21 +8,18 @@ import . "kesim.org/seal/common"
 // for given Z, X, Y, R, C, A and B
 
 type Stage1 struct {
+	// Original Bit
+	*Bit
+
+	// New stage 1 private data
 	x *Scalar
 	y *Scalar
 	r *Scalar
-
-	// Original Bid
-	α      *Scalar
-	β      *Scalar
-	bitSet bool
 }
 
 type Stage1Commitment struct {
 	// Original Commitment
-	A *Point
-	B *Point
-	C *Point
+	*Commitment
 
 	// New
 	R *Point
@@ -31,22 +28,20 @@ type Stage1Commitment struct {
 	Z *Point
 }
 
-func NewStage1(bitSet bool) *Stage1 {
-	var x [5]*Scalar
+func (b *Bit) Stage1() *Stage1 {
+	var x [3]*Scalar
 	for i := range x {
 		x[i] = Curve.RandomScalar()
 	}
-	return NewStage1FromScalars(bitSet, x[0], x[1], x[2], x[3], x[4])
+	return b.Stage1FromScalars(x[0], x[1], x[2])
 }
 
-func NewStage1FromScalars(bitSet bool, x, y, r, α, β *Scalar) *Stage1 {
+func (b *Bit) Stage1FromScalars(x, y, r *Scalar) *Stage1 {
 	return &Stage1{
-		x:      x,
-		y:      y,
-		r:      r,
-		α:      α,
-		β:      β,
-		bitSet: bitSet,
+		x:   x,
+		y:   y,
+		r:   r,
+		Bit: b,
 	}
 }
 
@@ -65,9 +60,12 @@ func (s *Stage1) commit() *Stage1Commitment {
 		X: G.Exp(s.x),
 		Y: G.Exp(s.y),
 		R: G.Exp(s.r),
-		A: G.Exp(s.α),
-		B: G.Exp(s.β),
-		C: G.Exp(φ),
+
+		Commitment: &Commitment{
+			A: G.Exp(s.α),
+			B: G.Exp(s.β),
+			C: G.Exp(φ),
+		},
 	}
 }
 
diff --git a/nizk/stage1_test.go b/nizk/stage1_test.go
index c429e69..3a1fac3 100644
--- a/nizk/stage1_test.go
+++ b/nizk/stage1_test.go
@@ -7,8 +7,10 @@ import (
 )
 
 func TestStage1(t *testing.T) {
-	st1 := NewStage1(true)
-	st2 := NewStage1(false)
+	b1 := NewBit(true)
+	b2 := NewBit(false)
+	st1 := b1.Stage1()
+	st2 := b2.Stage1()
 
 	c1, pr1 := st1.Commit()
 	c2, pr2 := st2.Commit()
@@ -30,8 +32,10 @@ func TestStage1FromScalars(t *testing.T) {
 		*s = Curve.RandomScalar()
 	}
 
-	st1 := NewStage1FromScalars(true, x, y, r, α, β)
-	st2 := NewStage1FromScalars(false, x, y, r, α, β)
+	b1 := NewBitFromScalars(true, α, β)
+	b2 := NewBitFromScalars(false, α, β)
+	st1 := b1.Stage1FromScalars(x, y, r)
+	st2 := b2.Stage1FromScalars(x, y, r)
 
 	c1, pr1 := st1.Commit()
 	c2, pr2 := st2.Commit()