hermez-node/common/account_test.go
common/account_test.goRaw
1package common
2
3import (
4 "encoding/hex"
5 "fmt"
6 "math"
7 "math/big"
8 "strings"
9 "testing"
10
11 ethCommon "github.com/ethereum/go-ethereum/common"
12 ethCrypto "github.com/ethereum/go-ethereum/crypto"
13 "github.com/iden3/go-iden3-crypto/babyjub"
14 cryptoConstants "github.com/iden3/go-iden3-crypto/constants"
15 "github.com/iden3/go-iden3-crypto/poseidon"
16 cryptoUtils "github.com/iden3/go-iden3-crypto/utils"
17 "github.com/stretchr/testify/assert"
18 "github.com/stretchr/testify/require"
19)
20
21func TestIdxParser(t *testing.T) {
22 i := Idx(1)
23 iBytes, err := i.Bytes()
24 assert.Nil(t, err)
25 assert.Equal(t, 6, len(iBytes))
26 assert.Equal(t, "000000000001", hex.EncodeToString(iBytes[:]))
27 i2, err := IdxFromBytes(iBytes[:])
28 assert.Nil(t, err)
29 assert.Equal(t, i, i2)
30
31 i = Idx(100)
32 assert.Equal(t, big.NewInt(100), i.BigInt())
33
34 // value before overflow
35 i = Idx(281474976710655)
36 iBytes, err = i.Bytes()
37 assert.Nil(t, err)
38 assert.Equal(t, 6, len(iBytes))
39 assert.Equal(t, "ffffffffffff", hex.EncodeToString(iBytes[:]))
40 i2, err = IdxFromBytes(iBytes[:])
41 assert.Nil(t, err)
42 assert.Equal(t, i, i2)
43
44 // expect value overflow
45 i = Idx(281474976710656)
46 iBytes, err = i.Bytes()
47 assert.NotNil(t, err)
48 assert.Equal(t, ErrIdxOverflow, err)
49}
50
51func TestNonceParser(t *testing.T) {
52 n := Nonce(1)
53 nBytes, err := n.Bytes()
54 assert.Nil(t, err)
55 assert.Equal(t, 5, len(nBytes))
56 assert.Equal(t, "0000000001", hex.EncodeToString(nBytes[:]))
57 n2 := NonceFromBytes(nBytes)
58 assert.Equal(t, n, n2)
59
60 // value before overflow
61 n = Nonce(1099511627775)
62 nBytes, err = n.Bytes()
63 assert.Nil(t, err)
64 assert.Equal(t, 5, len(nBytes))
65 assert.Equal(t, "ffffffffff", hex.EncodeToString(nBytes[:]))
66 n2 = NonceFromBytes(nBytes)
67 assert.Equal(t, n, n2)
68
69 // expect value overflow
70 n = Nonce(1099511627776)
71 nBytes, err = n.Bytes()
72 assert.NotNil(t, err)
73 assert.Equal(t, ErrNonceOverflow, err)
74}
75
76func TestAccount(t *testing.T) {
77 var sk babyjub.PrivateKey
78 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
79 assert.Nil(t, err)
80 pk := sk.Public()
81
82 account := &Account{
83 TokenID: TokenID(1),
84 Nonce: Nonce(1234),
85 Balance: big.NewInt(1000),
86 PublicKey: pk,
87 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
88 }
89 b, err := account.Bytes()
90 assert.Nil(t, err)
91 assert.Equal(t, byte(1), b[22])
92 a1, err := AccountFromBytes(b)
93 assert.Nil(t, err)
94 assert.Equal(t, account, a1)
95
96 e, err := account.BigInts()
97 assert.Nil(t, err)
98 assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
99 assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
100 assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
101 assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
102
103 assert.Equal(t, "1000", e[1].String())
104 assert.Equal(t, pk.Y.String(), e[2].String())
105 assert.Equal(t, new(big.Int).SetBytes(account.EthAddr.Bytes()).String(), e[3].String())
106
107 a2, err := AccountFromBigInts(e)
108 assert.Nil(t, err)
109 assert.Equal(t, account, a2)
110 assert.Equal(t, a1, a2)
111}
112
113func TestAccountLoop(t *testing.T) {
114 // check that for different deterministic BabyJubJub keys & random Address there is no problem
115 for i := 0; i < 256; i++ {
116 var sk babyjub.PrivateKey
117 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
118 assert.Nil(t, err)
119 pk := sk.Public()
120
121 key, err := ethCrypto.GenerateKey()
122 assert.Nil(t, err)
123 address := ethCrypto.PubkeyToAddress(key.PublicKey)
124
125 account := &Account{
126 TokenID: TokenID(i),
127 Nonce: Nonce(i),
128 Balance: big.NewInt(1000),
129 PublicKey: pk,
130 EthAddr: address,
131 }
132 b, err := account.Bytes()
133 assert.Nil(t, err)
134 a1, err := AccountFromBytes(b)
135 assert.Nil(t, err)
136 assert.Equal(t, account, a1)
137
138 e, err := account.BigInts()
139 assert.Nil(t, err)
140 assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
141 assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
142 assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
143 assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
144
145 a2, err := AccountFromBigInts(e)
146 assert.Nil(t, err)
147 assert.Equal(t, account, a2)
148 }
149}
150
151func TestAccountLoopRandom(t *testing.T) {
152 // check that for different random Address & BabyJubJub keys there is
153 // no problem
154 for i := 0; i < 256; i++ {
155 sk := babyjub.NewRandPrivKey()
156 pk := sk.Public()
157
158 key, err := ethCrypto.GenerateKey()
159 assert.Nil(t, err)
160 address := ethCrypto.PubkeyToAddress(key.PublicKey)
161
162 account := &Account{
163 TokenID: TokenID(i),
164 Nonce: Nonce(i),
165 Balance: big.NewInt(1000),
166 PublicKey: pk,
167 EthAddr: address,
168 }
169 b, err := account.Bytes()
170 assert.Nil(t, err)
171 a1, err := AccountFromBytes(b)
172 assert.Nil(t, err)
173 assert.Equal(t, account, a1)
174
175 e, err := account.BigInts()
176 assert.Nil(t, err)
177 assert.True(t, cryptoUtils.CheckBigIntInField(e[0]))
178 assert.True(t, cryptoUtils.CheckBigIntInField(e[1]))
179 assert.True(t, cryptoUtils.CheckBigIntInField(e[2]))
180 assert.True(t, cryptoUtils.CheckBigIntInField(e[3]))
181
182 a2, err := AccountFromBigInts(e)
183 assert.Nil(t, err)
184 assert.Equal(t, account, a2)
185 }
186}
187
188func bigFromStr(h string, u int) *big.Int {
189 if u == 16 {
190 h = strings.TrimPrefix(h, "0x")
191 }
192 b, ok := new(big.Int).SetString(h, u)
193 if !ok {
194 panic("bigFromStr err")
195 }
196 return b
197}
198
199func TestAccountHashValue(t *testing.T) {
200 var sk babyjub.PrivateKey
201 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
202 assert.Nil(t, err)
203 pk := sk.Public()
204
205 account := &Account{
206 TokenID: TokenID(1),
207 Nonce: Nonce(1234),
208 Balance: big.NewInt(1000),
209 PublicKey: pk,
210 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
211 }
212 v, err := account.HashValue()
213 assert.Nil(t, err)
214 assert.Equal(t, "16297758255249203915951182296472515138555043617458222397753168518282206850764", v.String())
215}
216
217func TestAccountHashValueTestVectors(t *testing.T) {
218 // values from js test vectors
219 ay := new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(253), nil), big.NewInt(1))
220 assert.Equal(t, "1fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", (hex.EncodeToString(ay.Bytes())))
221 bjj, err := babyjub.PointFromSignAndY(true, ay)
222 require.Nil(t, err)
223
224 account := &Account{
225 Idx: 1,
226 TokenID: 0xFFFFFFFF,
227 PublicKey: (*babyjub.PublicKey)(bjj),
228 EthAddr: ethCommon.HexToAddress("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
229 Nonce: Nonce(0xFFFFFFFFFF),
230 Balance: bigFromStr("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16),
231 }
232
233 e, err := account.BigInts()
234 assert.Nil(t, err)
235 assert.Equal(t, "9444732965739290427391", e[0].String())
236 assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", e[1].String())
237 assert.Equal(t, "14474011154664524427946373126085988481658748083205070504932198000989141204991", e[2].String())
238 assert.Equal(t, "1461501637330902918203684832716283019655932542975", e[3].String())
239
240 h, err := poseidon.Hash(e[:])
241 assert.Nil(t, err)
242 assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", h.String())
243
244 v, err := account.HashValue()
245 assert.Nil(t, err)
246 assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", v.String())
247
248 // second account
249 ay = big.NewInt(0)
250 bjj, err = babyjub.PointFromSignAndY(false, ay)
251 require.Nil(t, err)
252 account = &Account{
253 TokenID: 0,
254 PublicKey: (*babyjub.PublicKey)(bjj),
255 EthAddr: ethCommon.HexToAddress("0x00"),
256 Nonce: Nonce(0),
257 Balance: big.NewInt(0),
258 }
259 v, err = account.HashValue()
260 assert.Nil(t, err)
261 assert.Equal(t, "7750253361301235345986002241352365187241910378619330147114280396816709365657", v.String())
262
263 // third account
264 ay = bigFromStr("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7", 16)
265 bjj, err = babyjub.PointFromSignAndY(false, ay)
266 require.Nil(t, err)
267 account = &Account{
268 TokenID: 3,
269 PublicKey: (*babyjub.PublicKey)(bjj),
270 EthAddr: ethCommon.HexToAddress("0xA3C88ac39A76789437AED31B9608da72e1bbfBF9"),
271 Nonce: Nonce(129),
272 Balance: bigFromStr("42000000000000000000", 10),
273 }
274 e, err = account.BigInts()
275 assert.Nil(t, err)
276 assert.Equal(t, "554050781187", e[0].String())
277 assert.Equal(t, "42000000000000000000", e[1].String())
278 assert.Equal(t, "15238403086306505038849621710779816852318505119327426213168494964113886299863", e[2].String())
279 assert.Equal(t, "935037732739828347587684875151694054123613453305", e[3].String())
280 v, err = account.HashValue()
281 assert.Nil(t, err)
282 assert.Equal(t, "10565754214047872850889045989683221123564392137456000481397520902594455245517", v.String())
283}
284
285func TestAccountErrNotInFF(t *testing.T) {
286 z := big.NewInt(0)
287
288 // Q-1 should not give error
289 r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1))
290 e := [NLeafElems]*big.Int{z, z, r, r}
291 _, err := AccountFromBigInts(e)
292 assert.Nil(t, err)
293
294 // Q should give error
295 r = cryptoConstants.Q
296 e = [NLeafElems]*big.Int{z, z, r, r}
297 _, err = AccountFromBigInts(e)
298 assert.NotNil(t, err)
299 assert.Equal(t, ErrNotInFF, err)
300
301 // Q+1 should give error
302 r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1))
303 e = [NLeafElems]*big.Int{z, z, r, r}
304 _, err = AccountFromBigInts(e)
305 assert.NotNil(t, err)
306 assert.Equal(t, ErrNotInFF, err)
307}
308
309func TestAccountErrNumOverflowNonce(t *testing.T) {
310 var sk babyjub.PrivateKey
311 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
312 assert.Nil(t, err)
313 pk := sk.Public()
314
315 // check limit
316 account := &Account{
317 TokenID: TokenID(1),
318 Nonce: Nonce(math.Pow(2, 40) - 1),
319 Balance: big.NewInt(1000),
320 PublicKey: pk,
321 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
322 }
323 _, err = account.Bytes()
324 assert.Nil(t, err)
325
326 // force value overflow
327 account.Nonce = Nonce(math.Pow(2, 40))
328 b, err := account.Bytes()
329 assert.NotNil(t, err)
330 assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), err)
331
332 _, err = AccountFromBytes(b)
333 assert.Nil(t, err)
334}
335
336func TestAccountErrNumOverflowBalance(t *testing.T) {
337 var sk babyjub.PrivateKey
338 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
339 assert.Nil(t, err)
340 pk := sk.Public()
341
342 // check limit
343 account := &Account{
344 TokenID: TokenID(1),
345 Nonce: Nonce(math.Pow(2, 40) - 1),
346 Balance: new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)),
347 PublicKey: pk,
348 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
349 }
350 assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", account.Balance.String())
351
352 _, err = account.Bytes()
353 assert.Nil(t, err)
354
355 // force value overflow
356 account.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
357 assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", account.Balance.String())
358 b, err := account.Bytes()
359 assert.NotNil(t, err)
360 assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
361
362 _, err = AccountFromBytes(b)
363 assert.Nil(t, err)
364
365 b[39] = 1
366 _, err = AccountFromBytes(b)
367 assert.NotNil(t, err)
368 assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), err)
369}