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 TestAccount(t *testing.T) {
 19	var sk babyjub.PrivateKey
 20	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
 21	assert.Nil(t, err)
 22	pk := sk.Public()
 23
 24	account := &Account{
 25		TokenID:   TokenID(1),
 26		Nonce:     uint64(1234),
 27		Balance:   big.NewInt(1000),
 28		PublicKey: pk,
 29		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
 30	}
 31	b, err := account.Bytes()
 32	assert.Nil(t, err)
 33	assert.Equal(t, byte(1), b[10])
 34	a1, err := AccountFromBytes(b)
 35	assert.Nil(t, err)
 36	assert.Equal(t, account, a1)
 37
 38	e, err := account.BigInts()
 39	assert.Nil(t, err)
 40	assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
 41	assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
 42	assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
 43	assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
 44
 45	assert.Equal(t, "1000", e[1].String())
 46	assert.Equal(t, pk.Y.String(), e[2].String())
 47	assert.Equal(t, new(big.Int).SetBytes(SwapEndianness(account.EthAddr.Bytes())).String(), e[3].String())
 48
 49	a2, err := AccountFromBigInts(e)
 50	assert.Nil(t, err)
 51	assert.Equal(t, account, a2)
 52	assert.Equal(t, a1, a2)
 53}
 54
 55func TestAccountLoop(t *testing.T) {
 56	// check that for different Address there is no problem
 57	for i := 0; i < 256; i++ {
 58		var sk babyjub.PrivateKey
 59		_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
 60		assert.Nil(t, err)
 61		pk := sk.Public()
 62
 63		key, err := ethCrypto.GenerateKey()
 64		assert.Nil(t, err)
 65		address := ethCrypto.PubkeyToAddress(key.PublicKey)
 66
 67		account := &Account{
 68			TokenID:   TokenID(i),
 69			Nonce:     uint64(i),
 70			Balance:   big.NewInt(1000),
 71			PublicKey: pk,
 72			EthAddr:   address,
 73		}
 74		b, err := account.Bytes()
 75		assert.Nil(t, err)
 76		a1, err := AccountFromBytes(b)
 77		assert.Nil(t, err)
 78		assert.Equal(t, account, a1)
 79
 80		e, err := account.BigInts()
 81		assert.Nil(t, err)
 82		assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
 83		assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
 84		assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
 85		assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
 86
 87		a2, err := AccountFromBigInts(e)
 88		assert.Nil(t, err)
 89		assert.Equal(t, account, a2)
 90	}
 91}
 92
 93func TestAccountHashValue(t *testing.T) {
 94	var sk babyjub.PrivateKey
 95	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
 96	assert.Nil(t, err)
 97	pk := sk.Public()
 98
 99	account := &Account{
100		TokenID:   TokenID(1),
101		Nonce:     uint64(1234),
102		Balance:   big.NewInt(1000),
103		PublicKey: pk,
104		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
105	}
106
107	v, err := account.HashValue()
108	assert.Nil(t, err)
109	assert.Equal(t, "16085711911723375585301279875451049849443101031421093098714359651259271023730", v.String())
110}
111
112func TestAccountErrNotInFF(t *testing.T) {
113	z := big.NewInt(0)
114
115	// Q-1 should not give error
116	r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1))
117	e := [NLEAFELEMS]*big.Int{z, z, r, r}
118	_, err := AccountFromBigInts(e)
119	assert.Nil(t, err)
120
121	// Q should give error
122	r = cryptoConstants.Q
123	e = [NLEAFELEMS]*big.Int{z, z, r, r}
124	_, err = AccountFromBigInts(e)
125	assert.NotNil(t, err)
126	assert.Equal(t, ErrNotInFF, err)
127
128	// Q+1 should give error
129	r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1))
130	e = [NLEAFELEMS]*big.Int{z, z, r, r}
131	_, err = AccountFromBigInts(e)
132	assert.NotNil(t, err)
133	assert.Equal(t, ErrNotInFF, err)
134}
135
136func TestAccountErrNumOverflowNonce(t *testing.T) {
137	var sk babyjub.PrivateKey
138	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
139	assert.Nil(t, err)
140	pk := sk.Public()
141
142	// check limit
143	account := &Account{
144		TokenID:   TokenID(1),
145		Nonce:     uint64(math.Pow(2, 40) - 1),
146		Balance:   big.NewInt(1000),
147		PublicKey: pk,
148		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
149	}
150	_, err = account.Bytes()
151	assert.Nil(t, err)
152
153	// force value overflow
154	account.Nonce = uint64(math.Pow(2, 40))
155	b, err := account.Bytes()
156	assert.NotNil(t, err)
157	assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err)
158
159	_, err = AccountFromBytes(b)
160	assert.Nil(t, err)
161}
162
163func TestAccountErrNumOverflowBalance(t *testing.T) {
164	var sk babyjub.PrivateKey
165	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
166	assert.Nil(t, err)
167	pk := sk.Public()
168
169	// check limit
170	account := &Account{
171		TokenID:   TokenID(1),
172		Nonce:     uint64(math.Pow(2, 40) - 1),
173		Balance:   new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)),
174		PublicKey: pk,
175		EthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
176	}
177	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", account.Balance.String())
178
179	_, err = account.Bytes()
180	assert.Nil(t, err)
181
182	// force value overflow
183	account.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
184	assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", account.Balance.String())
185	b, err := account.Bytes()
186	assert.NotNil(t, err)
187	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
188
189	_, err = AccountFromBytes(b)
190	assert.Nil(t, err)
191
192	b[56] = 1
193	_, err = AccountFromBytes(b)
194	assert.NotNil(t, err)
195	assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
196}