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 LoadAmount: big.NewInt(2),
28 FromIdx: Idx(300),
29 }
30 l1Tx, err := NewL1Tx(l1Tx)
31 assert.Nil(t, err)
32 assert.Equal(t, "0x00000000000001e240004700", l1Tx.TxID.String())
33}
34
35func TestNewL1CoordinatorTx(t *testing.T) {
36 batchNum := BatchNum(51966)
37 l1Tx := &L1Tx{
38 Position: 88,
39 UserOrigin: false,
40 ToIdx: 301,
41 TokenID: 5,
42 Amount: big.NewInt(1),
43 LoadAmount: big.NewInt(2),
44 FromIdx: Idx(300),
45 BatchNum: &batchNum,
46 }
47 l1Tx, err := NewL1Tx(l1Tx)
48 assert.Nil(t, err)
49 assert.Equal(t, "0x01000000000000cafe005800", l1Tx.TxID.String())
50}
51
52func TestL1TxCompressedData(t *testing.T) {
53 tx := L1Tx{
54 FromIdx: 2,
55 ToIdx: 3,
56 Amount: big.NewInt(4),
57 TokenID: 5,
58 }
59 txCompressedData, err := tx.TxCompressedData()
60 assert.Nil(t, err)
61
62 // test vector value generated from javascript implementation
63 expectedStr := "7307597389635308713748674793997299267459594577423"
64 assert.Equal(t, expectedStr, txCompressedData.String())
65 assert.Equal(t, "0500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
66}
67
68func TestBytesDataAvailability(t *testing.T) {
69 tx := L1Tx{
70 FromIdx: 2,
71 ToIdx: 3,
72 Amount: big.NewInt(4),
73 TokenID: 5,
74 }
75 txCompressedData, err := tx.BytesDataAvailability(32)
76 assert.Nil(t, err)
77 assert.Equal(t, "0000000200000003000000", hex.EncodeToString(txCompressedData))
78
79 tx = L1Tx{
80 FromIdx: 2,
81 ToIdx: 3,
82 EffectiveAmount: big.NewInt(4),
83 TokenID: 5,
84 }
85 txCompressedData, err = tx.BytesDataAvailability(32)
86 assert.Nil(t, err)
87 assert.Equal(t, "0000000200000003000400", hex.EncodeToString(txCompressedData))
88}
89
90func TestL1TxFromDataAvailability(t *testing.T) {
91 tx := L1Tx{
92 FromIdx: 2,
93 ToIdx: 3,
94 Amount: big.NewInt(4),
95 }
96 txCompressedData, err := tx.BytesDataAvailability(32)
97 assert.Nil(t, err)
98 l1tx, err := L1TxFromDataAvailability(txCompressedData, 32)
99 require.NoError(t, err)
100 assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
101 assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
102
103 tx = L1Tx{
104 FromIdx: 2,
105 ToIdx: 3,
106 EffectiveAmount: big.NewInt(4),
107 }
108 txCompressedData, err = tx.BytesDataAvailability(32)
109 assert.Nil(t, err)
110 l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
111 require.NoError(t, err)
112 assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
113 assert.Equal(t, tx.ToIdx, l1tx.ToIdx)
114 assert.Equal(t, tx.EffectiveAmount, l1tx.EffectiveAmount)
115}
116
117func TestL1userTxByteParsers(t *testing.T) {
118 var pkComp babyjub.PublicKeyComp
119 pkCompL := []byte("0x56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
120 err := pkComp.UnmarshalText(pkCompL)
121 require.Nil(t, err)
122
123 pk, err := pkComp.Decompress()
124 require.Nil(t, err)
125
126 l1Tx := &L1Tx{
127 UserOrigin: true,
128 ToIdx: 3,
129 TokenID: 5,
130 Amount: big.NewInt(1),
131 LoadAmount: big.NewInt(2),
132 FromIdx: 2,
133 FromBJJ: pk,
134 FromEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
135 }
136
137 encodedData, err := l1Tx.BytesUser()
138 require.Nil(t, err)
139 decodedData, err := L1UserTxFromBytes(encodedData)
140 require.Nil(t, err)
141 assert.Equal(t, l1Tx, decodedData)
142 encodedData2, err := decodedData.BytesUser()
143 require.Nil(t, err)
144 assert.Equal(t, encodedData, encodedData2)
145
146 // expect error if length!=68
147 _, err = L1UserTxFromBytes(encodedData[:66])
148 require.NotNil(t, err)
149 _, err = L1UserTxFromBytes([]byte{})
150 require.NotNil(t, err)
151 _, err = L1UserTxFromBytes(nil)
152 require.NotNil(t, err)
153}
154
155func TestL1TxByteParsersCompatibility(t *testing.T) {
156 // Data from compatibility test
157 var pkComp babyjub.PublicKeyComp
158 pkCompB, err := hex.DecodeString("0dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a")
159 require.Nil(t, err)
160 pkCompL := SwapEndianness(pkCompB)
161 err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
162 require.Nil(t, err)
163
164 pk, err := pkComp.Decompress()
165 require.Nil(t, err)
166
167 loadAmount := new(big.Int)
168 loadAmount.SetString("100000000000000000000", 10)
169 l1Tx := &L1Tx{
170 ToIdx: 87865485,
171 TokenID: 2098076,
172 Amount: big.NewInt(2400000000000000000),
173 LoadAmount: loadAmount,
174 FromIdx: Idx(29767899),
175 FromBJJ: pk,
176 FromEthAddr: ethCommon.HexToAddress("0x85dab5b9e2e361d0c208d77be90efcc0439b0a53"),
177 UserOrigin: true,
178 }
179
180 expected, err := utils.HexDecode("85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db8be880f00020039c0000053cb88d")
181 require.Nil(t, err)
182
183 encodedData, err := l1Tx.BytesUser()
184 require.Nil(t, err)
185 assert.Equal(t, expected, encodedData)
186}
187
188func TestL1CoordinatorTxByteParsers(t *testing.T) {
189 hermezAddress := ethCommon.HexToAddress("0xD6C850aeBFDC46D7F4c207e445cC0d6B0919BDBe")
190 chainID := big.NewInt(1337)
191 chainIDBytes := ethCommon.LeftPadBytes(chainID.Bytes(), 2)
192
193 privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
194 require.Nil(t, err)
195
196 publicKey := privateKey.Public()
197 publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
198 if !ok {
199 log.Fatal("error casting public key to ECDSA")
200 }
201 publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
202 pubKey, err := crypto.UnmarshalPubkey(publicKeyBytes)
203 require.Nil(t, err)
204 fromEthAddr := crypto.PubkeyToAddress(*pubKey)
205 var pkComp babyjub.PublicKeyComp
206 pkCompL := []byte("56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
207 err = pkComp.UnmarshalText(pkCompL)
208 require.Nil(t, err)
209 pk, err := pkComp.Decompress()
210 require.Nil(t, err)
211 bytesMessage1 := []byte("\x19Ethereum Signed Message:\n120")
212 bytesMessage2 := []byte("I authorize this babyjubjub key for hermez rollup account creation")
213
214 babyjub := pk.Compress()
215 babyjubB := SwapEndianness(babyjub[:])
216 var data []byte
217 data = append(data, bytesMessage1...)
218 data = append(data, bytesMessage2...)
219 data = append(data, babyjubB[:]...)
220 data = append(data, chainIDBytes...)
221 data = append(data, hermezAddress.Bytes()...)
222 hash := crypto.Keccak256Hash(data)
223 signature, err := crypto.Sign(hash.Bytes(), privateKey)
224 require.Nil(t, err)
225 // Ethereum adds 27 to v
226 v := int(signature[64])
227 signature[64] = byte(v + 27)
228
229 l1Tx := &L1Tx{
230 TokenID: 231,
231 FromBJJ: pk,
232 FromEthAddr: fromEthAddr,
233 Amount: big.NewInt(0),
234 LoadAmount: big.NewInt(0),
235 }
236
237 bytesCoordinatorL1, err := l1Tx.BytesCoordinatorTx(signature)
238 require.Nil(t, err)
239 l1txDecoded, err := L1CoordinatorTxFromBytes(bytesCoordinatorL1, chainID, hermezAddress)
240 require.Nil(t, err)
241 assert.Equal(t, l1Tx, l1txDecoded)
242 bytesCoordinatorL12, err := l1txDecoded.BytesCoordinatorTx(signature)
243 require.Nil(t, err)
244 assert.Equal(t, bytesCoordinatorL1, bytesCoordinatorL12)
245
246 // expect error if length!=68
247 _, err = L1CoordinatorTxFromBytes(bytesCoordinatorL1[:66], chainID, hermezAddress)
248 require.NotNil(t, err)
249 _, err = L1CoordinatorTxFromBytes([]byte{}, chainID, hermezAddress)
250 require.NotNil(t, err)
251 _, err = L1CoordinatorTxFromBytes(nil, chainID, hermezAddress)
252 require.NotNil(t, err)
253}
254
255func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
256 // Data from compatibility test
257 var signature []byte
258 r, err := hex.DecodeString("da71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3b")
259 require.Nil(t, err)
260 s, err := hex.DecodeString("186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8c")
261 require.Nil(t, err)
262 v, err := hex.DecodeString("1b")
263 require.Nil(t, err)
264
265 signature = append(signature, r[:]...)
266 signature = append(signature, s[:]...)
267 signature = append(signature, v[:]...)
268
269 var pkComp babyjub.PublicKeyComp
270 pkCompB, err := hex.DecodeString("a2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c")
271 require.Nil(t, err)
272 pkCompL := SwapEndianness(pkCompB)
273 err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
274 require.Nil(t, err)
275 // Data from the compatibility test
276 require.Nil(t, err)
277 pk, err := pkComp.Decompress()
278 require.Nil(t, err)
279 l1Tx := &L1Tx{
280 TokenID: 231,
281 FromBJJ: pk,
282 }
283
284 encodeData, err := l1Tx.BytesCoordinatorTx(signature)
285 require.Nil(t, err)
286
287 expected, err := utils.HexDecode("1b186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8cda71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3ba2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c000000e7")
288 require.Nil(t, err)
289
290 assert.Equal(t, expected, encodeData)
291}