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		Sign:    true,
 21		Ay:      big.NewInt(6789),
 22		EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
 23	}
 24	b, err := leaf.Bytes()
 25	assert.Nil(t, err)
 26	assert.Equal(t, byte(1), b[10])
 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
 38	assert.Equal(t, "1000", e[1].String())
 39	assert.Equal(t, "6789", e[2].String())
 40	assert.Equal(t, new(big.Int).SetBytes(SwapEndianness(leaf.EthAddr.Bytes())).String(), 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//                         Sign:    true,
 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//
 76//                 l2, err := LeafFromBigInts(e)
 77//                 assert.Nil(t, err)
 78//                 assert.Equal(t, leaf, l2)
 79//         }
 80// }
 81
 82func TestLeafErrNotInFF(t *testing.T) {
 83	z := big.NewInt(0)
 84
 85	// Q-1 should not give error
 86	r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1))
 87	e := [NLEAFELEMS]*big.Int{z, z, r, r}
 88	_, err := LeafFromBigInts(e)
 89	assert.Nil(t, err)
 90
 91	// Q should give error
 92	r = cryptoConstants.Q
 93	e = [NLEAFELEMS]*big.Int{z, z, r, r}
 94	_, err = LeafFromBigInts(e)
 95	assert.NotNil(t, err)
 96	assert.Equal(t, ErrNotInFF, err)
 97
 98	// Q+1 should give error
 99	r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1))
100	e = [NLEAFELEMS]*big.Int{z, z, r, r}
101	_, err = LeafFromBigInts(e)
102	assert.NotNil(t, err)
103	assert.Equal(t, ErrNotInFF, err)
104}
105
106func TestLeafErrNumOverflowNonce(t *testing.T) {
107	// check limit
108	leaf := &Leaf{
109		TokenID: TokenID(1),
110		Nonce:   uint64(math.Pow(2, 40) - 1),
111		Balance: big.NewInt(1000),
112		Sign:    true,
113		Ay:      big.NewInt(6789),
114		EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
115	}
116	_, err := leaf.Bytes()
117	assert.Nil(t, err)
118
119	// force value overflow
120	leaf.Nonce = uint64(math.Pow(2, 40))
121	b, err := leaf.Bytes()
122	assert.NotNil(t, err)
123	assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err)
124
125	_, err = LeafFromBytes(b)
126	assert.Nil(t, err)
127}
128
129func TestLeafErrNumOverflowBalance(t *testing.T) {
130	// check limit
131	leaf := &Leaf{
132		TokenID: TokenID(1),
133		Nonce:   uint64(math.Pow(2, 40) - 1),
134		Balance: new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)),
135		Sign:    true,
136		Ay:      big.NewInt(6789),
137		EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
138	}
139	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", leaf.Balance.String())
140
141	_, err := leaf.Bytes()
142	assert.Nil(t, err)
143
144	// force value overflow
145	leaf.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
146	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", leaf.Balance.String())
147	b, err := leaf.Bytes()
148	assert.NotNil(t, err)
149	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
150
151	_, err = LeafFromBytes(b)
152	assert.Nil(t, err)
153
154	b[56] = 1
155	_, err = LeafFromBytes(b)
156	assert.NotNil(t, err)
157	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
158}