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 fromIdx := Idx(300)
21 l1Tx := &L1Tx{
22 ToForgeL1TxsNum: &toForge,
23 Position: 71,
24 UserOrigin: true,
25 ToIdx: 301,
26 TokenID: 5,
27 Amount: big.NewInt(1),
28 LoadAmount: big.NewInt(2),
29 FromIdx: &fromIdx,
30 }
31 l1Tx, err := NewL1Tx(l1Tx)
32 assert.Nil(t, err)
33 assert.Equal(t, "0x00000000000001e240004700", l1Tx.TxID.String())
34}
35
36func TestNewL1CoordinatorTx(t *testing.T) {
37 fromIdx := Idx(300)
38 batchNum := BatchNum(51966)
39 l1Tx := &L1Tx{
40 Position: 88,
41 UserOrigin: false,
42 ToIdx: 301,
43 TokenID: 5,
44 Amount: big.NewInt(1),
45 LoadAmount: big.NewInt(2),
46 FromIdx: &fromIdx,
47 BatchNum: &batchNum,
48 }
49 l1Tx, err := NewL1Tx(l1Tx)
50 assert.Nil(t, err)
51 assert.Equal(t, "0x01000000000000cafe005800", l1Tx.TxID.String())
52}
53
54func TestL1TxByteParsers(t *testing.T) {
55 var pkComp babyjub.PublicKeyComp
56 pkCompL := []byte("0x56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
57 err := pkComp.UnmarshalText(pkCompL)
58 require.Nil(t, err)
59
60 pk, err := pkComp.Decompress()
61 require.Nil(t, err)
62
63 fromIdx := new(Idx)
64 *fromIdx = 2
65 l1Tx := &L1Tx{
66 ToIdx: 3,
67 TokenID: 5,
68 Amount: big.NewInt(1),
69 LoadAmount: big.NewInt(2),
70 FromIdx: fromIdx,
71 FromBJJ: pk,
72 FromEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
73 }
74
75 encodedData, err := l1Tx.Bytes()
76 require.Nil(t, err)
77 decodedData, err := L1TxFromBytes(encodedData)
78 require.Nil(t, err)
79 assert.Equal(t, l1Tx, decodedData)
80 encodedData2, err := decodedData.Bytes()
81 require.Nil(t, err)
82 assert.Equal(t, encodedData, encodedData2)
83
84 // expect error if length!=68
85 _, err = L1TxFromBytes(encodedData[:66])
86 require.NotNil(t, err)
87 _, err = L1TxFromBytes([]byte{})
88 require.NotNil(t, err)
89 _, err = L1TxFromBytes(nil)
90 require.NotNil(t, err)
91}
92
93func TestL1TxByteParsersCompatibility(t *testing.T) {
94 // Data from compatibility test
95 var pkComp babyjub.PublicKeyComp
96 pkCompB, err := hex.DecodeString("0dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a")
97 require.Nil(t, err)
98 pkCompL := SwapEndianness(pkCompB)
99 err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
100 require.Nil(t, err)
101
102 pk, err := pkComp.Decompress()
103 require.Nil(t, err)
104
105 fromIdx := new(Idx)
106 *fromIdx = 29767899
107 loadAmount := new(big.Int)
108 loadAmount.SetString("100000000000000000000", 10)
109 l1Tx := &L1Tx{
110 ToIdx: 87865485,
111 TokenID: 2098076,
112 Amount: big.NewInt(2400000000000000000),
113 LoadAmount: loadAmount,
114 FromIdx: fromIdx,
115 FromBJJ: pk,
116 FromEthAddr: ethCommon.HexToAddress("0x85dab5b9e2e361d0c208d77be90efcc0439b0a53"),
117 }
118
119 expected, err := utils.HexDecode("85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db8be880f00020039c0000053cb88d")
120 require.Nil(t, err)
121
122 encodedData, err := l1Tx.Bytes()
123 require.Nil(t, err)
124 assert.Equal(t, expected, encodedData)
125}
126
127func TestL1CoordinatorTxByteParsers(t *testing.T) {
128 privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
129 require.Nil(t, err)
130
131 publicKey := privateKey.Public()
132 publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
133 if !ok {
134 log.Fatal("error casting public key to ECDSA")
135 }
136 publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
137 pubKey, err := crypto.UnmarshalPubkey(publicKeyBytes)
138 require.Nil(t, err)
139 fromEthAddr := crypto.PubkeyToAddress(*pubKey)
140 var pkComp babyjub.PublicKeyComp
141 pkCompL := []byte("56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
142 err = pkComp.UnmarshalText(pkCompL)
143 require.Nil(t, err)
144 pk, err := pkComp.Decompress()
145 require.Nil(t, err)
146 bytesMessage1 := []byte("\x19Ethereum Signed Message:\n98")
147 bytesMessage2 := []byte("I authorize this babyjubjub key for hermez rollup account creation")
148
149 babyjub := pk.Compress()
150 babyjubB := SwapEndianness(babyjub[:])
151 var data []byte
152 data = append(data, bytesMessage1...)
153 data = append(data, bytesMessage2...)
154 data = append(data, babyjubB[:]...)
155 hash := crypto.Keccak256Hash(data)
156 signature, err := crypto.Sign(hash.Bytes(), privateKey)
157 require.Nil(t, err)
158 // Ethereum adds 27 to v
159 v := int(signature[64])
160 signature[64] = byte(v + 27)
161
162 l1Tx := &L1Tx{
163 TokenID: 231,
164 FromBJJ: pk,
165 FromEthAddr: fromEthAddr,
166 }
167
168 bytesCoordinatorL1, err := l1Tx.BytesCoordinatorTx(signature)
169 require.Nil(t, err)
170 l1txDecoded, err := L1TxFromCoordinatorBytes(bytesCoordinatorL1)
171 require.Nil(t, err)
172 assert.Equal(t, l1Tx, l1txDecoded)
173 bytesCoordinatorL12, err := l1txDecoded.BytesCoordinatorTx(signature)
174 require.Nil(t, err)
175 assert.Equal(t, bytesCoordinatorL1, bytesCoordinatorL12)
176
177 // expect error if length!=68
178 _, err = L1TxFromCoordinatorBytes(bytesCoordinatorL1[:66])
179 require.NotNil(t, err)
180 _, err = L1TxFromCoordinatorBytes([]byte{})
181 require.NotNil(t, err)
182 _, err = L1TxFromCoordinatorBytes(nil)
183 require.NotNil(t, err)
184}
185
186func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
187 // Data from compatibility test
188 var signature []byte
189 r, err := hex.DecodeString("da71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3b")
190 require.Nil(t, err)
191 s, err := hex.DecodeString("186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8c")
192 require.Nil(t, err)
193 v, err := hex.DecodeString("1b")
194 require.Nil(t, err)
195
196 signature = append(signature, r[:]...)
197 signature = append(signature, s[:]...)
198 signature = append(signature, v[:]...)
199
200 var pkComp babyjub.PublicKeyComp
201 pkCompB, err := hex.DecodeString("a2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c")
202 require.Nil(t, err)
203 pkCompL := SwapEndianness(pkCompB)
204 err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
205 require.Nil(t, err)
206 // Data from the compatibility test
207 require.Nil(t, err)
208 pk, err := pkComp.Decompress()
209 require.Nil(t, err)
210 l1Tx := &L1Tx{
211 TokenID: 231,
212 FromBJJ: pk,
213 }
214
215 encodeData, err := l1Tx.BytesCoordinatorTx(signature)
216 require.Nil(t, err)
217
218 expected, err := utils.HexDecode("1b186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8cda71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3ba2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c000000e7")
219 require.Nil(t, err)
220
221 assert.Equal(t, expected, encodeData)
222}