hermez-node/common/l1tx_test.go
common/l1tx_test.goRaw
1package common
2
3import (
4 "crypto/ecdsa"
5 "encoding/hex"
6 "log"
7 "math/big"
8 "testing"
9
10 ethCommon "github.com/ethereum/go-ethereum/common"
11 "github.com/ethereum/go-ethereum/crypto"
12 "github.com/iden3/go-iden3-crypto/babyjub"
13 "github.com/iden3/go-iden3-crypto/utils"
14 "github.com/stretchr/testify/assert"
15 "github.com/stretchr/testify/require"
16)
17
18func TestNewL1UserTx(t *testing.T) {
19 toForge := int64(123456)
20 l1Tx := &L1Tx{
21 ToForgeL1TxsNum: &toForge,
22 Position: 71,
23 UserOrigin: true,
24 ToIdx: 301,
25 TokenID: 5,
26 Amount: big.NewInt(1),
27 DepositAmount: big.NewInt(2),
28 FromIdx: Idx(300),
29 }
30 l1Tx, err := NewL1Tx(l1Tx)
31 assert.NoError(t, err)
32 assert.Equal(t, "0x00a6cbae3b8661fb75b0919ca6605a02cfb04d9c6dd16870fa0fcdf01befa32768",
33 l1Tx.TxID.String())
34}
35
36func TestNewL1CoordinatorTx(t *testing.T) {
37 batchNum := BatchNum(51966)
38 l1Tx := &L1Tx{
39 Position: 88,
40 UserOrigin: false,
41 ToIdx: 301,
42 TokenID: 5,
43 Amount: big.NewInt(1),
44 DepositAmount: big.NewInt(2),
45 FromIdx: Idx(300),
46 BatchNum: &batchNum,
47 }
48 l1Tx, err := NewL1Tx(l1Tx)
49 assert.NoError(t, err)
50 assert.Equal(t, "0x01274482d73df4dab34a1b6740adfca347a462513aa14e82f27b12f818d1b68c84",
51 l1Tx.TxID.String())
52}
53
54func TestL1TxCompressedData(t *testing.T) {
55 // test vectors values generated from javascript implementation (using
56 // PoolL2Tx values)
57 amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
58 require.True(t, ok)
59 tx := L1Tx{
60 FromIdx: (1 << 48) - 1,
61 ToIdx: (1 << 48) - 1,
62 Amount: amount,
63 TokenID: (1 << 32) - 1,
64 }
65 txCompressedData, err := tx.TxCompressedData(uint16((1 << 16) - 1))
66 assert.NoError(t, err)
67 expectedStr := "ffffffffffffffffffffffffffffffffffffc60be60f"
68 assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
69
70 tx = L1Tx{
71 FromIdx: 0,
72 ToIdx: 0,
73 Amount: big.NewInt(0),
74 TokenID: 0,
75 }
76 txCompressedData, err = tx.TxCompressedData(uint16(0))
77 assert.NoError(t, err)
78 expectedStr = "c60be60f"
79 assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
80
81 amount, ok = new(big.Int).SetString("63000000000000000", 10)
82 require.True(t, ok)
83 tx = L1Tx{
84 FromIdx: 324,
85 ToIdx: 256,
86 Amount: amount,
87 TokenID: 123,
88 }
89 txCompressedData, err = tx.TxCompressedData(uint16(1))
90 assert.NoError(t, err)
91 expectedStr = "7b0000000001000000000001440001c60be60f"
92 assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
93
94 tx = L1Tx{
95 FromIdx: 1,
96 ToIdx: 2,
97 TokenID: 3,
98 }
99 txCompressedData, err = tx.TxCompressedData(uint16(0))
100 assert.NoError(t, err)
101 expectedStr = "030000000000020000000000010000c60be60f"
102 assert.Equal(t, expectedStr, hex.EncodeToString(txCompressedData.Bytes()))
103}
104
105func TestBytesDataAvailability(t *testing.T) {
106 // test vectors values generated from javascript implementation
107 amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
108 require.True(t, ok)
109 tx := L1Tx{
110 ToIdx: (1 << 16) - 1,
111 FromIdx: (1 << 16) - 1,
112 EffectiveAmount: amount,
113 }
114 txCompressedData, err := tx.BytesDataAvailability(16)
115 assert.NoError(t, err)
116 assert.Equal(t, "ffffffffffffffffff00", hex.EncodeToString(txCompressedData))
117 l1tx, err := L1TxFromDataAvailability(txCompressedData, 16)
118 require.NoError(t, err)
119 assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
120 assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
121 assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
122
123 tx = L1Tx{
124 ToIdx: (1 << 32) - 1,
125 FromIdx: (1 << 32) - 1,
126 EffectiveAmount: amount,
127 }
128 txCompressedData, err = tx.BytesDataAvailability(32)
129 assert.NoError(t, err)
130 assert.Equal(t, "ffffffffffffffffffffffffff00", hex.EncodeToString(txCompressedData))
131 l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
132 require.NoError(t, err)
133 assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
134 assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
135 assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
136
137 tx = L1Tx{
138 ToIdx: 0,
139 FromIdx: 0,
140 EffectiveAmount: big.NewInt(0),
141 }
142 txCompressedData, err = tx.BytesDataAvailability(32)
143 assert.NoError(t, err)
144 assert.Equal(t, "0000000000000000000000000000", hex.EncodeToString(txCompressedData))
145 l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
146 require.NoError(t, err)
147 assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
148 assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
149 assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
150
151 tx = L1Tx{
152 ToIdx: 635,
153 FromIdx: 296,
154 EffectiveAmount: big.NewInt(1000000000000000000),
155 }
156 txCompressedData, err = tx.BytesDataAvailability(32)
157 assert.NoError(t, err)
158 assert.Equal(t, "000001280000027b42540be40000", hex.EncodeToString(txCompressedData))
159 l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
160 require.NoError(t, err)
161 assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
162 assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
163 assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
164}
165
166func TestL1userTxByteParsers(t *testing.T) {
167 var pkComp babyjub.PublicKeyComp
168 pkCompL := []byte("0x56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
169 err := pkComp.UnmarshalText(pkCompL)
170 require.NoError(t, err)
171
172 l1Tx := &L1Tx{
173 UserOrigin: true,
174 ToIdx: 3,
175 TokenID: 5,
176 Amount: big.NewInt(1),
177 DepositAmount: big.NewInt(2),
178 FromIdx: 2,
179 FromBJJ: pkComp,
180 FromEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
181 }
182
183 encodedData, err := l1Tx.BytesUser()
184 require.NoError(t, err)
185 decodedData, err := L1UserTxFromBytes(encodedData)
186 require.NoError(t, err)
187 assert.Equal(t, l1Tx, decodedData)
188 encodedData2, err := decodedData.BytesUser()
189 require.NoError(t, err)
190 assert.Equal(t, encodedData, encodedData2)
191
192 // expect error if length!=68
193 _, err = L1UserTxFromBytes(encodedData[:66])
194 require.NotNil(t, err)
195 _, err = L1UserTxFromBytes([]byte{})
196 require.NotNil(t, err)
197 _, err = L1UserTxFromBytes(nil)
198 require.NotNil(t, err)
199}
200
201func TestL1TxByteParsersCompatibility(t *testing.T) {
202 // Data from compatibility test
203 var pkComp babyjub.PublicKeyComp
204 pkCompB, err :=
205 hex.DecodeString("0dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a")
206 require.NoError(t, err)
207 pkCompL := SwapEndianness(pkCompB)
208 err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
209 require.NoError(t, err)
210
211 depositAmount := new(big.Int)
212 depositAmount.SetString("100000000000000000000", 10)
213 l1Tx := &L1Tx{
214 ToIdx: 87865485,
215 TokenID: 2098076,
216 Amount: big.NewInt(2400000000000000000),
217 DepositAmount: depositAmount,
218 FromIdx: Idx(29767899),
219 FromBJJ: pkComp,
220 FromEthAddr: ethCommon.HexToAddress("0x85dab5b9e2e361d0c208d77be90efcc0439b0a53"),
221 UserOrigin: true,
222 }
223
224 encodedData, err := l1Tx.BytesUser()
225 require.NoError(t, err)
226 expected := "85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79e" +
227 "e1f41a7def613e73a20c32eece5a000001c638db52540be400459682f0000020039c0000053cb88d"
228 assert.Equal(t, expected, hex.EncodeToString(encodedData))
229}
230
231func TestL1CoordinatorTxByteParsers(t *testing.T) {
232 hermezAddress := ethCommon.HexToAddress("0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe")
233 chainID := big.NewInt(1337)
234
235 privateKey, err :=
236 crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
237 require.NoError(t, err)
238
239 publicKey := privateKey.Public()
240 publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
241 if !ok {
242 log.Fatal("error casting public key to ECDSA")
243 }
244 publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
245 pubKey, err := crypto.UnmarshalPubkey(publicKeyBytes)
246 require.NoError(t, err)
247 fromEthAddr := crypto.PubkeyToAddress(*pubKey)
248 var pkComp babyjub.PublicKeyComp
249 pkCompL := []byte("56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
250 err = pkComp.UnmarshalText(pkCompL)
251 require.NoError(t, err)
252
253 accCreationAuth := AccountCreationAuth{
254 EthAddr: fromEthAddr,
255 BJJ: pkComp,
256 }
257
258 h, err := accCreationAuth.HashToSign(uint16(chainID.Uint64()), hermezAddress)
259 require.NoError(t, err)
260
261 signature, err := crypto.Sign(h, privateKey)
262 require.NoError(t, err)
263 // Ethereum adds 27 to v
264 v := int(signature[64])
265 signature[64] = byte(v + 27)
266
267 l1Tx := &L1Tx{
268 TokenID: 231,
269 FromBJJ: pkComp,
270 FromEthAddr: fromEthAddr,
271 Amount: big.NewInt(0),
272 DepositAmount: big.NewInt(0),
273 }
274
275 bytesCoordinatorL1, err := l1Tx.BytesCoordinatorTx(signature)
276 require.NoError(t, err)
277 l1txDecoded, err := L1CoordinatorTxFromBytes(bytesCoordinatorL1, chainID, hermezAddress)
278 require.NoError(t, err)
279 assert.Equal(t, l1Tx, l1txDecoded)
280 bytesCoordinatorL12, err := l1txDecoded.BytesCoordinatorTx(signature)
281 require.NoError(t, err)
282 assert.Equal(t, bytesCoordinatorL1, bytesCoordinatorL12)
283
284 // expect error if length!=68
285 _, err = L1CoordinatorTxFromBytes(bytesCoordinatorL1[:66], chainID, hermezAddress)
286 require.NotNil(t, err)
287 _, err = L1CoordinatorTxFromBytes([]byte{}, chainID, hermezAddress)
288 require.NotNil(t, err)
289 _, err = L1CoordinatorTxFromBytes(nil, chainID, hermezAddress)
290 require.NotNil(t, err)
291}
292
293func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
294 // Data from compatibility test
295 var signature []byte
296 r, err := hex.DecodeString("da71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3b")
297 require.NoError(t, err)
298 s, err := hex.DecodeString("186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8c")
299 require.NoError(t, err)
300 v, err := hex.DecodeString("1b")
301 require.NoError(t, err)
302
303 signature = append(signature, r[:]...)
304 signature = append(signature, s[:]...)
305 signature = append(signature, v[:]...)
306
307 var pkComp babyjub.PublicKeyComp
308 pkCompB, err :=
309 hex.DecodeString("a2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c")
310 require.NoError(t, err)
311 pkCompL := SwapEndianness(pkCompB)
312 err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
313 require.NoError(t, err)
314 // Data from the compatibility test
315 require.NoError(t, err)
316 l1Tx := &L1Tx{
317 TokenID: 231,
318 FromBJJ: pkComp,
319 }
320
321 encodeData, err := l1Tx.BytesCoordinatorTx(signature)
322 require.NoError(t, err)
323
324 expected, err := utils.HexDecode("1b186d7122ff7f654cfed3156719774898d573900c86599a885a706" +
325 "dbdffe5ea8cda71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3ba2c28" +
326 "07ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c000000e7")
327 require.NoError(t, err)
328
329 assert.Equal(t, expected, encodeData)
330}
331
332func TestL1TxID(t *testing.T) {
333 // L1UserTx
334 i64_1 := int64(1)
335 i64_2 := int64(2)
336 tx0 := L1Tx{
337 UserOrigin: true,
338 ToForgeL1TxsNum: &i64_1,
339 Position: 1,
340 }
341 err := tx0.SetID()
342 require.NoError(t, err)
343 assert.Equal(t, TxIDPrefixL1UserTx, tx0.TxID[0])
344
345 // differ ToForgeL1TxsNum
346 tx1 := L1Tx{
347 UserOrigin: true,
348 ToForgeL1TxsNum: &i64_2,
349 Position: 1,
350 }
351 err = tx1.SetID()
352 require.NoError(t, err)
353 assert.NotEqual(t, tx0.TxID, tx1.TxID)
354
355 // differ Position
356 tx1 = L1Tx{
357 UserOrigin: true,
358 ToForgeL1TxsNum: &i64_1,
359 Position: 2,
360 }
361 err = tx1.SetID()
362 require.NoError(t, err)
363 assert.NotEqual(t, tx0.TxID, tx1.TxID)
364
365 // L1CoordinatorTx
366 bn1 := BatchNum(1)
367 bn2 := BatchNum(2)
368 tx0 = L1Tx{
369 UserOrigin: false,
370 BatchNum: &bn1,
371 Position: 1,
372 }
373 err = tx0.SetID()
374 require.NoError(t, err)
375 assert.Equal(t, TxIDPrefixL1CoordTx, tx0.TxID[0])
376
377 // differ BatchNum
378 tx1 = L1Tx{
379 UserOrigin: false,
380 BatchNum: &bn2,
381 Position: 1,
382 }
383 err = tx1.SetID()
384 require.NoError(t, err)
385 assert.NotEqual(t, tx0.TxID, tx1.TxID)
386
387 // differ Position
388 tx1 = L1Tx{
389 UserOrigin: false,
390 BatchNum: &bn1,
391 Position: 2,
392 }
393 err = tx1.SetID()
394 require.NoError(t, err)
395 assert.NotEqual(t, tx0.TxID, tx1.TxID)
396}