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.Nil(t, err)
26 assert.Equal(t, 6, len(iBytes))
27 assert.Equal(t, "000000000001", hex.EncodeToString(iBytes[:]))
28 i2, err := IdxFromBytes(iBytes[:])
29 assert.Nil(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.Nil(t, err)
39 assert.Equal(t, 6, len(iBytes))
40 assert.Equal(t, "ffffffffffff", hex.EncodeToString(iBytes[:]))
41 i2, err = IdxFromBytes(iBytes[:])
42 assert.Nil(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.Nil(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.Nil(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.Nil(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,
88 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
89 }
90 b, err := account.Bytes()
91 assert.Nil(t, err)
92 assert.Equal(t, byte(1), b[22])
93 a1, err := AccountFromBytes(b)
94 assert.Nil(t, err)
95 assert.Equal(t, account, a1)
96
97 e, err := account.BigInts()
98 assert.Nil(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.Nil(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.Nil(t, err)
120 pk := sk.Public()
121
122 key, err := ethCrypto.GenerateKey()
123 assert.Nil(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,
131 EthAddr: address,
132 }
133 b, err := account.Bytes()
134 assert.Nil(t, err)
135 a1, err := AccountFromBytes(b)
136 assert.Nil(t, err)
137 assert.Equal(t, account, a1)
138
139 e, err := account.BigInts()
140 assert.Nil(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.Nil(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.Nil(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,
168 EthAddr: address,
169 }
170 b, err := account.Bytes()
171 assert.Nil(t, err)
172 a1, err := AccountFromBytes(b)
173 assert.Nil(t, err)
174 assert.Equal(t, account, a1)
175
176 e, err := account.BigInts()
177 assert.Nil(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.Nil(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.Nil(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,
211 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
212 }
213 v, err := account.HashValue()
214 assert.Nil(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 bjj, err := babyjub.PointFromSignAndY(true, ay)
223 require.Nil(t, err)
224
225 account := &Account{
226 Idx: 1,
227 TokenID: 0xFFFFFFFF,
228 PublicKey: (*babyjub.PublicKey)(bjj),
229 EthAddr: ethCommon.HexToAddress("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
230 Nonce: Nonce(0xFFFFFFFFFF),
231 Balance: bigFromStr("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", 16),
232 }
233
234 e, err := account.BigInts()
235 assert.Nil(t, err)
236 assert.Equal(t, "9444732965739290427391", e[0].String())
237 assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", e[1].String())
238 assert.Equal(t, "14474011154664524427946373126085988481658748083205070504932198000989141204991", e[2].String())
239 assert.Equal(t, "1461501637330902918203684832716283019655932542975", e[3].String())
240
241 h, err := poseidon.Hash(e[:])
242 assert.Nil(t, err)
243 assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", h.String())
244
245 v, err := account.HashValue()
246 assert.Nil(t, err)
247 assert.Equal(t, "4550823210217540218403400309533329186487982452461145263910122718498735057257", v.String())
248
249 // second account
250 ay = big.NewInt(0)
251 bjj, err = babyjub.PointFromSignAndY(false, ay)
252 require.Nil(t, err)
253 account = &Account{
254 TokenID: 0,
255 PublicKey: (*babyjub.PublicKey)(bjj),
256 EthAddr: ethCommon.HexToAddress("0x00"),
257 Nonce: Nonce(0),
258 Balance: big.NewInt(0),
259 }
260 v, err = account.HashValue()
261 assert.Nil(t, err)
262 assert.Equal(t, "7750253361301235345986002241352365187241910378619330147114280396816709365657", v.String())
263
264 // third account
265 ay = bigFromStr("21b0a1688b37f77b1d1d5539ec3b826db5ac78b2513f574a04c50a7d4f8246d7", 16)
266 bjj, err = babyjub.PointFromSignAndY(false, ay)
267 require.Nil(t, err)
268 account = &Account{
269 TokenID: 3,
270 PublicKey: (*babyjub.PublicKey)(bjj),
271 EthAddr: ethCommon.HexToAddress("0xA3C88ac39A76789437AED31B9608da72e1bbfBF9"),
272 Nonce: Nonce(129),
273 Balance: bigFromStr("42000000000000000000", 10),
274 }
275 e, err = account.BigInts()
276 assert.Nil(t, err)
277 assert.Equal(t, "554050781187", e[0].String())
278 assert.Equal(t, "42000000000000000000", e[1].String())
279 assert.Equal(t, "15238403086306505038849621710779816852318505119327426213168494964113886299863", e[2].String())
280 assert.Equal(t, "935037732739828347587684875151694054123613453305", e[3].String())
281 v, err = account.HashValue()
282 assert.Nil(t, err)
283 assert.Equal(t, "10565754214047872850889045989683221123564392137456000481397520902594455245517", v.String())
284}
285
286func TestAccountErrNotInFF(t *testing.T) {
287 z := big.NewInt(0)
288
289 // Q-1 should not give error
290 r := new(big.Int).Sub(cryptoConstants.Q, big.NewInt(1))
291 e := [NLeafElems]*big.Int{z, z, r, r}
292 _, err := AccountFromBigInts(e)
293 assert.Nil(t, err)
294
295 // Q should give error
296 r = cryptoConstants.Q
297 e = [NLeafElems]*big.Int{z, z, r, r}
298 _, err = AccountFromBigInts(e)
299 assert.NotNil(t, err)
300 assert.Equal(t, ErrNotInFF, tracerr.Unwrap(err))
301
302 // Q+1 should give error
303 r = new(big.Int).Add(cryptoConstants.Q, big.NewInt(1))
304 e = [NLeafElems]*big.Int{z, z, r, r}
305 _, err = AccountFromBigInts(e)
306 assert.NotNil(t, err)
307 assert.Equal(t, ErrNotInFF, tracerr.Unwrap(err))
308}
309
310func TestAccountErrNumOverflowNonce(t *testing.T) {
311 var sk babyjub.PrivateKey
312 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
313 assert.Nil(t, err)
314 pk := sk.Public()
315
316 // check limit
317 account := &Account{
318 TokenID: TokenID(1),
319 Nonce: Nonce(math.Pow(2, 40) - 1),
320 Balance: big.NewInt(1000),
321 PublicKey: pk,
322 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
323 }
324 _, err = account.Bytes()
325 assert.Nil(t, err)
326
327 // force value overflow
328 account.Nonce = Nonce(math.Pow(2, 40))
329 b, err := account.Bytes()
330 assert.NotNil(t, err)
331 assert.Equal(t, fmt.Errorf("%s Nonce", ErrNumOverflow), tracerr.Unwrap(err))
332
333 _, err = AccountFromBytes(b)
334 assert.Nil(t, err)
335}
336
337func TestAccountErrNumOverflowBalance(t *testing.T) {
338 var sk babyjub.PrivateKey
339 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
340 assert.Nil(t, err)
341 pk := sk.Public()
342
343 // check limit
344 account := &Account{
345 TokenID: TokenID(1),
346 Nonce: Nonce(math.Pow(2, 40) - 1),
347 Balance: new(big.Int).Sub(new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil), big.NewInt(1)),
348 PublicKey: pk,
349 EthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
350 }
351 assert.Equal(t, "6277101735386680763835789423207666416102355444464034512895", account.Balance.String())
352
353 _, err = account.Bytes()
354 assert.Nil(t, err)
355
356 // force value overflow
357 account.Balance = new(big.Int).Exp(big.NewInt(2), big.NewInt(192), nil)
358 assert.Equal(t, "6277101735386680763835789423207666416102355444464034512896", account.Balance.String())
359 b, err := account.Bytes()
360 assert.NotNil(t, err)
361 assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), tracerr.Unwrap(err))
362
363 _, err = AccountFromBytes(b)
364 assert.Nil(t, err)
365
366 b[39] = 1
367 _, err = AccountFromBytes(b)
368 assert.NotNil(t, err)
369 assert.Equal(t, fmt.Errorf("%s Balance", ErrNumOverflow), tracerr.Unwrap(err))
370}