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