github.com/dusk-network/dusk-crypto@v0.1.3/rangeproof/poly_test.go (about)

     1  package rangeproof
     2  
     3  import (
     4  	"math/big"
     5  	"testing"
     6  
     7  	ristretto "github.com/bwesterb/go-ristretto"
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func TestDelta(t *testing.T) {
    12  	var y, z ristretto.Scalar
    13  	y.Rand()
    14  	z.Rand()
    15  
    16  	var zSq, zCu ristretto.Scalar
    17  	zSq.SetZero()
    18  	zCu.SetZero()
    19  
    20  	zSq.Square(&z)
    21  	zCu.Mul(&z, &zSq)
    22  
    23  	var powerG ristretto.Scalar
    24  	powerG.SetZero()
    25  
    26  	var expY, exp2 ristretto.Scalar
    27  	expY.SetOne()
    28  	exp2.SetOne()
    29  
    30  	var two ristretto.Scalar
    31  	two.SetBigInt(big.NewInt(2))
    32  
    33  	n := 256
    34  
    35  	for i := 0; i < n; i++ {
    36  		var a ristretto.Scalar
    37  		a.Sub(&z, &zSq)  // z-z^2
    38  		a.Mul(&a, &expY) // (z-z^2)y^i
    39  
    40  		var b ristretto.Scalar
    41  		b.Mul(&zCu, &exp2) // z^3 * 2^i
    42  
    43  		var c ristretto.Scalar
    44  		c.Sub(&a, &b) // (z-z^2)y^i - z^3 * 2^i
    45  
    46  		powerG.Add(&powerG, &c)
    47  
    48  		expY.Mul(&expY, &y)
    49  		exp2.Mul(&exp2, &two)
    50  	}
    51  
    52  	have := computeDelta(y, z, uint32(n), 1)
    53  
    54  	ok := powerG.Equals(&have)
    55  
    56  	assert.Equal(t, true, ok)
    57  }
    58  
    59  // t0 = z^m * v[m] + D(y,z)
    60  // N.B. There was a bug in computeT0; the below three test cases were used to debug this value, by fixing n,m,y,z, and v
    61  // Removing them would be fine
    62  func TestComputeT0(t *testing.T) {
    63  	// This is the T0 calculated using the public data
    64  	// case when n,m, z, v = 1, y = 0
    65  
    66  	var n, m uint32
    67  	n = 1
    68  	m = 1
    69  
    70  	var amount, y, z ristretto.Scalar
    71  	y.SetZero()
    72  	z.SetBigInt(big.NewInt(1))
    73  	amount.SetOne()
    74  
    75  	poly := polynomial{}
    76  	t0 := poly.computeT0(y, z, []ristretto.Scalar{amount}, n, m)
    77  
    78  	// compute Delta
    79  	delta := computeDelta(y, z, n, m)
    80  
    81  	var minusOne ristretto.Scalar
    82  	minusOne.SetBigInt(big.NewInt(-1))
    83  
    84  	assert.Equal(t, minusOne.Bytes(), delta.Bytes())
    85  
    86  	var want ristretto.Scalar
    87  	want.Add(&amount, &delta)
    88  
    89  	ok := want.Equals(&t0)
    90  
    91  	assert.Equal(t, true, ok)
    92  }
    93  
    94  func TestComputeT0Case2(t *testing.T) {
    95  	// This is the T0 calculated using the public data
    96  	// case when: n = 64, m = 2, y = 1, amount = 1, z = 1
    97  
    98  	var n, m uint32
    99  	n = 32
   100  	m = 2
   101  
   102  	var amount, y, z ristretto.Scalar
   103  	y.SetOne()
   104  	z.SetBigInt(big.NewInt(1))
   105  	amount.SetOne()
   106  
   107  	poly := polynomial{}
   108  	t0 := poly.computeT0(y, z, []ristretto.Scalar{amount, amount}, n, m)
   109  
   110  	// compute Delta
   111  	delta := computeDelta(y, z, n, m) // (1-1)*sumY - (1 * 4294967295 *2)
   112  	var deltaWant ristretto.Scalar
   113  	deltaWant.SetBigInt(big.NewInt(-4294967295 * 2))
   114  	assert.Equal(t, deltaWant.Bytes(), delta.Bytes())
   115  
   116  	// z^m *v[m] = z^2 + z^3 = 1 + 1 = 2
   117  
   118  	var two ristretto.Scalar
   119  	two.SetBigInt(big.NewInt(2))
   120  
   121  	var sum ristretto.Scalar
   122  	sum.Add(&delta, &two)
   123  
   124  	assert.Equal(t, t0.Bytes(), sum.Bytes())
   125  }
   126  
   127  func TestComputeT0Case3(t *testing.T) {
   128  	// This is the T0 calculated using the public data
   129  	// case when: n = 64, m = 2, y = 1, amount = 1, z = 2
   130  
   131  	var n, m uint32
   132  	n = 32
   133  	m = 2
   134  
   135  	var amount, y, z ristretto.Scalar
   136  	y.SetOne()
   137  	z.SetBigInt(big.NewInt(2))
   138  	amount.SetOne()
   139  
   140  	poly := polynomial{}
   141  	t0 := poly.computeT0(y, z, []ristretto.Scalar{amount, amount}, n, m)
   142  
   143  	// compute Delta
   144  	delta := computeDelta(y, z, n, m) // (2 -4) * 64 - (8 * 4294967295 * 3)
   145  	var deltaWant ristretto.Scalar
   146  	d, ok := big.NewInt(0).SetString("-103079215208", 10)
   147  	assert.Equal(t, true, ok)
   148  	deltaWant.SetBigInt(d)
   149  	assert.Equal(t, deltaWant.Bytes(), delta.Bytes())
   150  
   151  	// z^m *v[m] = z^2 + z^3 = 4 + 8 = 2
   152  
   153  	var two ristretto.Scalar
   154  	two.SetBigInt(big.NewInt(12))
   155  
   156  	var sum ristretto.Scalar
   157  	sum.Add(&delta, &two)
   158  
   159  	assert.Equal(t, t0.Bytes(), sum.Bytes())
   160  }