1package common
  2
  3import (
  4	"fmt"
  5	"math"
  6	"math/big"
  7	"testing"
  8
  9	ethCommon "github.com/ethereum/go-ethereum/common"
 10	ethCrypto "github.com/ethereum/go-ethereum/crypto"
 11	cryptoConstants "github.com/iden3/go-iden3-crypto/constants"
 12	cryptoUtils "github.com/iden3/go-iden3-crypto/utils"
 13	"github.com/stretchr/testify/assert"
 14)
 15
 16func TestLeaf(t *testing.T) {
 17	leaf := &Leaf{
 18		TokenID: TokenID(1),
 19		Nonce:   uint64(1234),
 20		Balance: big.NewInt(1000),
 21		Ax:      big.NewInt(9876),
 22		Ay:      big.NewInt(6789),
 23		EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
 24	}
 25	b, err := leaf.Bytes()
 26	assert.Nil(t, err)
 27	l1, err := LeafFromBytes(b)
 28	assert.Nil(t, err)
 29	assert.Equal(t, leaf, l1)
 30
 31	e, err := leaf.BigInts()
 32	assert.Nil(t, err)
 33	assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
 34	assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
 35	assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
 36	assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
 37	assert.True(t, cryptoUtils.CheckBigIntInField(e[4]))
 38
 39	assert.Equal(t, "1000", e[1].String())
 40	assert.Equal(t, "9876", e[2].String())
 41	assert.Equal(t, "6789", e[3].String())
 42
 43	l2, err := LeafFromBigInts(e)
 44	assert.Nil(t, err)
 45	assert.Equal(t, leaf, l2)
 46	assert.Equal(t, l1, l2)
 47}
 48
 49func TestLeafLoop(t *testing.T) {
 50	// check that for different Address there is no problem
 51	for i := 0; i < 256; i++ {
 52		key, err := ethCrypto.GenerateKey()
 53		assert.Nil(t, err)
 54		address := ethCrypto.PubkeyToAddress(key.PublicKey)
 55
 56		leaf := &Leaf{
 57			TokenID: TokenID(i),
 58			Nonce:   uint64(i),
 59			Balance: big.NewInt(1000),
 60			Ax:      big.NewInt(9876),
 61			Ay:      big.NewInt(6789),
 62			EthAddr: address,
 63		}
 64		b, err := leaf.Bytes()
 65		assert.Nil(t, err)
 66		l1, err := LeafFromBytes(b)
 67		assert.Nil(t, err)
 68		assert.Equal(t, leaf, l1)
 69
 70		e, err := leaf.BigInts()
 71		assert.Nil(t, err)
 72		assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
 73		assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
 74		assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
 75		assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
 76		assert.True(t, cryptoUtils.CheckBigIntInField(e[4]))
 77
 78		l2, err := LeafFromBigInts(e)
 79		assert.Nil(t, err)
 80		assert.Equal(t, leaf, l2)
 81	}
 82}
 83
 84func TestLeafErrNotInFF(t *testing.T) {
 85	z := big.NewInt(0)
 86
 87	// Q-1 should not give error
 88	r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1))
 89	e := [5]*big.Int{z, z, r, r, r}
 90	_, err := LeafFromBigInts(e)
 91	assert.Nil(t, err)
 92
 93	// Q should give error
 94	r = cryptoConstants.Q
 95	e = [5]*big.Int{z, z, r, r, r}
 96	_, err = LeafFromBigInts(e)
 97	assert.NotNil(t, err)
 98	assert.Equal(t, ErrNotInFF, err)
 99
100	// Q+1 should give error
101	r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1))
102	e = [5]*big.Int{z, z, r, r, r}
103	_, err = LeafFromBigInts(e)
104	assert.NotNil(t, err)
105	assert.Equal(t, ErrNotInFF, err)
106}
107
108func TestLeafErrNumOverflowNonce(t *testing.T) {
109	// check limit
110	leaf := &Leaf{
111		TokenID: TokenID(1),
112		Nonce:   uint64(math.Pow(2, 40) - 1),
113		Balance: big.NewInt(1000),
114		Ax:      big.NewInt(9876),
115		Ay:      big.NewInt(6789),
116		EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
117	}
118	_, err := leaf.Bytes()
119	assert.Nil(t, err)
120
121	// force value overflow
122	leaf.Nonce = uint64(math.Pow(2, 40))
123	b, err := leaf.Bytes()
124	assert.NotNil(t, err)
125	assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err)
126
127	_, err = LeafFromBytes(b)
128	assert.Nil(t, err)
129
130	b[9] = 1
131	_, err = LeafFromBytes(b)
132	assert.NotNil(t, err)
133	assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err)
134}
135
136func TestLeafErrNumOverflowBalance(t *testing.T) {
137	// check limit
138	leaf := &Leaf{
139		TokenID: TokenID(1),
140		Nonce:   uint64(math.Pow(2, 40) - 1),
141		Balance: new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)),
142		Ax:      big.NewInt(9876),
143		Ay:      big.NewInt(6789),
144		EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
145	}
146	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", leaf.Balance.String())
147
148	_, err := leaf.Bytes()
149	assert.Nil(t, err)
150
151	// force value overflow
152	leaf.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
153	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", leaf.Balance.String())
154	b, err := leaf.Bytes()
155	assert.NotNil(t, err)
156	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
157
158	_, err = LeafFromBytes(b)
159	assert.Nil(t, err)
160
161	b[56] = 1
162	_, err = LeafFromBytes(b)
163	assert.NotNil(t, err)
164	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
165}