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