1package common
  2
  3import (
  4	"encoding/hex"
  5	"fmt"
  6	"math"
  7	"math/big"
  8	"testing"
  9
 10	ethCommon "github.com/ethereum/go-ethereum/common"
 11	ethCrypto "github.com/ethereum/go-ethereum/crypto"
 12	"github.com/iden3/go-iden3-crypto/babyjub"
 13	cryptoConstants "github.com/iden3/go-iden3-crypto/constants"
 14	cryptoUtils "github.com/iden3/go-iden3-crypto/utils"
 15	"github.com/stretchr/testify/assert"
 16)
 17
 18func TestIdxParser(t *testing.T) {
 19	i := Idx(1)
 20	iBytes, err := i.Bytes()
 21	assert.Nil(t, err)
 22	assert.Equal(t, 6, len(iBytes))
 23	assert.Equal(t, "000000000001", hex.EncodeToString(iBytes[:]))
 24	i2, err := IdxFromBytes(iBytes[:])
 25	assert.Nil(t, err)
 26	assert.Equal(t, i, i2)
 27
 28	i = Idx(100)
 29	assert.Equal(t, big.NewInt(100), i.BigInt())
 30
 31	// value before overflow
 32	i = Idx(281474976710655)
 33	iBytes, err = i.Bytes()
 34	assert.Nil(t, err)
 35	assert.Equal(t, 6, len(iBytes))
 36	assert.Equal(t, "ffffffffffff", hex.EncodeToString(iBytes[:]))
 37	i2, err = IdxFromBytes(iBytes[:])
 38	assert.Nil(t, err)
 39	assert.Equal(t, i, i2)
 40
 41	// expect value overflow
 42	i = Idx(281474976710656)
 43	iBytes, err = i.Bytes()
 44	assert.NotNil(t, err)
 45	assert.Equal(t, ErrIdxOverflow, err)
 46}
 47
 48func TestNonceParser(t *testing.T) {
 49	n := Nonce(1)
 50	nBytes, err := n.Bytes()
 51	assert.Nil(t, err)
 52	assert.Equal(t, 5, len(nBytes))
 53	assert.Equal(t, "0000000001", hex.EncodeToString(nBytes[:]))
 54	n2 := NonceFromBytes(nBytes)
 55	assert.Equal(t, n, n2)
 56
 57	// value before overflow
 58	n = Nonce(1099511627775)
 59	nBytes, err = n.Bytes()
 60	assert.Nil(t, err)
 61	assert.Equal(t, 5, len(nBytes))
 62	assert.Equal(t, "ffffffffff", hex.EncodeToString(nBytes[:]))
 63	n2 = NonceFromBytes(nBytes)
 64	assert.Equal(t, n, n2)
 65
 66	// expect value overflow
 67	n = Nonce(1099511627776)
 68	nBytes, err = n.Bytes()
 69	assert.NotNil(t, err)
 70	assert.Equal(t, ErrNonceOverflow, err)
 71}
 72
 73func TestAccount(t *testing.T) {
 74	var sk babyjub.PrivateKey
 75	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
 76	assert.Nil(t, err)
 77	pk := sk.Public()
 78
 79	account := &Account{
 80		TokenID:   TokenID(1),
 81		Nonce:     Nonce(1234),
 82		Balance:   big.NewInt(1000),
 83		PublicKey: pk,
 84		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
 85	}
 86	b, err := account.Bytes()
 87	assert.Nil(t, err)
 88	assert.Equal(t, byte(1), b[10])
 89	a1, err := AccountFromBytes(b)
 90	assert.Nil(t, err)
 91	assert.Equal(t, account, a1)
 92
 93	e, err := account.BigInts()
 94	assert.Nil(t, err)
 95	assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
 96	assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
 97	assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
 98	assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
 99
100	assert.Equal(t, "1000", e[1].String())
101	assert.Equal(t, pk.Y.String(), e[2].String())
102	assert.Equal(t, new(big.Int).SetBytes(SwapEndianness(account.EthAddr.Bytes())).String(), e[3].String())
103
104	a2, err := AccountFromBigInts(e)
105	assert.Nil(t, err)
106	assert.Equal(t, account, a2)
107	assert.Equal(t, a1, a2)
108}
109
110func TestAccountLoop(t *testing.T) {
111	// check that for different Address there is no problem
112	for i := 0; i < 256; i++ {
113		var sk babyjub.PrivateKey
114		_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
115		assert.Nil(t, err)
116		pk := sk.Public()
117
118		key, err := ethCrypto.GenerateKey()
119		assert.Nil(t, err)
120		address := ethCrypto.PubkeyToAddress(key.PublicKey)
121
122		account := &Account{
123			TokenID:   TokenID(i),
124			Nonce:     Nonce(i),
125			Balance:   big.NewInt(1000),
126			PublicKey: pk,
127			EthAddr:   address,
128		}
129		b, err := account.Bytes()
130		assert.Nil(t, err)
131		a1, err := AccountFromBytes(b)
132		assert.Nil(t, err)
133		assert.Equal(t, account, a1)
134
135		e, err := account.BigInts()
136		assert.Nil(t, err)
137		assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
138		assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
139		assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
140		assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
141
142		a2, err := AccountFromBigInts(e)
143		assert.Nil(t, err)
144		assert.Equal(t, account, a2)
145	}
146}
147
148func TestAccountHashValue(t *testing.T) {
149	var sk babyjub.PrivateKey
150	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
151	assert.Nil(t, err)
152	pk := sk.Public()
153
154	account := &Account{
155		TokenID:   TokenID(1),
156		Nonce:     Nonce(1234),
157		Balance:   big.NewInt(1000),
158		PublicKey: pk,
159		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
160	}
161
162	v, err := account.HashValue()
163	assert.Nil(t, err)
164	assert.Equal(t, "9478468711598093334066833736294178928569163287501434518121324135729106649559", v.String())
165}
166
167func TestAccountErrNotInFF(t *testing.T) {
168	z := big.NewInt(0)
169
170	// Q-1 should not give error
171	r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1))
172	e := [NLeafElems]*big.Int{z, z, r, r}
173	_, err := AccountFromBigInts(e)
174	assert.Nil(t, err)
175
176	// Q should give error
177	r = cryptoConstants.Q
178	e = [NLeafElems]*big.Int{z, z, r, r}
179	_, err = AccountFromBigInts(e)
180	assert.NotNil(t, err)
181	assert.Equal(t, ErrNotInFF, err)
182
183	// Q+1 should give error
184	r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1))
185	e = [NLeafElems]*big.Int{z, z, r, r}
186	_, err = AccountFromBigInts(e)
187	assert.NotNil(t, err)
188	assert.Equal(t, ErrNotInFF, err)
189}
190
191func TestAccountErrNumOverflowNonce(t *testing.T) {
192	var sk babyjub.PrivateKey
193	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
194	assert.Nil(t, err)
195	pk := sk.Public()
196
197	// check limit
198	account := &Account{
199		TokenID:   TokenID(1),
200		Nonce:     Nonce(math.Pow(2, 40) - 1),
201		Balance:   big.NewInt(1000),
202		PublicKey: pk,
203		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
204	}
205	_, err = account.Bytes()
206	assert.Nil(t, err)
207
208	// force value overflow
209	account.Nonce = Nonce(math.Pow(2, 40))
210	b, err := account.Bytes()
211	assert.NotNil(t, err)
212	assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err)
213
214	_, err = AccountFromBytes(b)
215	assert.Nil(t, err)
216}
217
218func TestAccountErrNumOverflowBalance(t *testing.T) {
219	var sk babyjub.PrivateKey
220	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
221	assert.Nil(t, err)
222	pk := sk.Public()
223
224	// check limit
225	account := &Account{
226		TokenID:   TokenID(1),
227		Nonce:     Nonce(math.Pow(2, 40) - 1),
228		Balance:   new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)),
229		PublicKey: pk,
230		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
231	}
232	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", account.Balance.String())
233
234	_, err = account.Bytes()
235	assert.Nil(t, err)
236
237	// force value overflow
238	account.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
239	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", account.Balance.String())
240	b, err := account.Bytes()
241	assert.NotNil(t, err)
242	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
243
244	_, err = AccountFromBytes(b)
245	assert.Nil(t, err)
246
247	b[56] = 1
248	_, err = AccountFromBytes(b)
249	assert.NotNil(t, err)
250	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
251}