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