hermez-node/common/pooll2tx_test.go
common/pooll2tx_test.goRaw
1package common
2
3import (
4 "encoding/hex"
5 "math/big"
6 "testing"
7
8 ethCommon "github.com/ethereum/go-ethereum/common"
9 "github.com/iden3/go-iden3-crypto/babyjub"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12)
13
14func TestNewPoolL2Tx(t *testing.T) {
15 poolL2Tx := &PoolL2Tx{
16 FromIdx: 87654,
17 ToIdx: 300,
18 Amount: big.NewInt(4),
19 TokenID: 5,
20 Nonce: 144,
21 }
22 poolL2Tx, err := NewPoolL2Tx(poolL2Tx)
23 assert.NoError(t, err)
24 assert.Equal(t, "0x02fb52b5d0b9ef2626c11701bb751b2720c76d59946b9a48146ac153bb6e63bf6a", poolL2Tx.TxID.String())
25}
26
27func TestTxCompressedData(t *testing.T) {
28 chainID := uint16(0)
29 var sk babyjub.PrivateKey
30 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
31 assert.NoError(t, err)
32 tx := PoolL2Tx{
33 FromIdx: 2,
34 ToIdx: 3,
35 Amount: big.NewInt(4),
36 TokenID: 5,
37 Nonce: 6,
38 ToBJJ: sk.Public().Compress(),
39 }
40 txCompressedData, err := tx.TxCompressedData(chainID)
41 assert.NoError(t, err)
42 // test vector value generated from javascript implementation
43 expectedStr := "1766847064778421992193717128424891165872736891548909569553540445094274575"
44 assert.Equal(t, expectedStr, txCompressedData.String())
45 assert.Equal(t, "010000000000060000000500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
46 // using a different chainID
47 txCompressedData, err = tx.TxCompressedData(uint16(100))
48 assert.NoError(t, err)
49 expectedStr = "1766847064778421992193717128424891165872736891548909569553540874591004175"
50 assert.Equal(t, expectedStr, txCompressedData.String())
51 assert.Equal(t, "010000000000060000000500040000000000030000000000020064c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
52 txCompressedData, err = tx.TxCompressedData(uint16(65535))
53 assert.NoError(t, err)
54 expectedStr = "1766847064778421992193717128424891165872736891548909569553821915776017935"
55 assert.Equal(t, expectedStr, txCompressedData.String())
56 assert.Equal(t, "01000000000006000000050004000000000003000000000002ffffc60be60f", hex.EncodeToString(txCompressedData.Bytes()))
57
58 tx = PoolL2Tx{
59 RqFromIdx: 7,
60 RqToIdx: 8,
61 RqAmount: big.NewInt(9),
62 RqTokenID: 10,
63 RqNonce: 11,
64 RqFee: 12,
65 RqToBJJ: sk.Public().Compress(),
66 }
67 rqTxCompressedData, err := tx.RqTxCompressedDataV2()
68 assert.NoError(t, err)
69 // test vector value generated from javascript implementation
70 expectedStr = "6571340879233176732837827812956721483162819083004853354503"
71 assert.Equal(t, expectedStr, rqTxCompressedData.String())
72 assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(rqTxCompressedData.Bytes()))
73}
74
75func TestTxCompressedDataV2(t *testing.T) {
76 var sk babyjub.PrivateKey
77 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
78 assert.NoError(t, err)
79 tx := PoolL2Tx{
80 FromIdx: 7,
81 ToIdx: 8,
82 Amount: big.NewInt(9),
83 TokenID: 10,
84 Nonce: 11,
85 Fee: 12,
86 ToBJJ: sk.Public().Compress(),
87 }
88 txCompressedData, err := tx.TxCompressedDataV2()
89 assert.NoError(t, err)
90 // test vector value generated from javascript implementation
91 expectedStr := "6571340879233176732837827812956721483162819083004853354503"
92 assert.Equal(t, expectedStr, txCompressedData.String())
93 expected, ok := new(big.Int).SetString(expectedStr, 10)
94 assert.True(t, ok)
95
96 assert.Equal(t, expected.Bytes(), txCompressedData.Bytes())
97 assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
98}
99
100func TestRqTxCompressedDataV2(t *testing.T) {
101 var sk babyjub.PrivateKey
102 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
103 assert.NoError(t, err)
104 tx := PoolL2Tx{
105 RqFromIdx: 7,
106 RqToIdx: 8,
107 RqAmount: big.NewInt(9),
108 RqTokenID: 10,
109 RqNonce: 11,
110 RqFee: 12,
111 RqToBJJ: sk.Public().Compress(),
112 }
113 txCompressedData, err := tx.RqTxCompressedDataV2()
114 assert.NoError(t, err)
115 // test vector value generated from javascript implementation
116 expectedStr := "6571340879233176732837827812956721483162819083004853354503"
117 assert.Equal(t, expectedStr, txCompressedData.String())
118 expected, ok := new(big.Int).SetString(expectedStr, 10)
119 assert.True(t, ok)
120 assert.Equal(t, expected.Bytes(), txCompressedData.Bytes())
121 assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
122}
123
124func TestHashToSign(t *testing.T) {
125 chainID := uint16(0)
126 var sk babyjub.PrivateKey
127 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
128 assert.NoError(t, err)
129 tx := PoolL2Tx{
130 FromIdx: 2,
131 ToIdx: 3,
132 Amount: big.NewInt(4),
133 TokenID: 5,
134 Nonce: 6,
135 ToEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
136 }
137 toSign, err := tx.HashToSign(chainID)
138 assert.NoError(t, err)
139 assert.Equal(t, "1469900657138253851938022936440971384682713995864967090251961124784132925291", toSign.String())
140}
141
142func TestVerifyTxSignature(t *testing.T) {
143 chainID := uint16(0)
144 var sk babyjub.PrivateKey
145 _, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
146 assert.NoError(t, err)
147 tx := PoolL2Tx{
148 FromIdx: 2,
149 ToIdx: 3,
150 Amount: big.NewInt(4),
151 TokenID: 5,
152 Nonce: 6,
153 ToBJJ: sk.Public().Compress(),
154 RqToEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
155 RqToBJJ: sk.Public().Compress(),
156 }
157 toSign, err := tx.HashToSign(chainID)
158 assert.NoError(t, err)
159 assert.Equal(t, "18645218094210271622244722988708640202588315450486586312909439859037906375295", toSign.String())
160
161 sig := sk.SignPoseidon(toSign)
162 tx.Signature = sig.Compress()
163 assert.True(t, tx.VerifySignature(chainID, sk.Public().Compress()))
164}
165
166func TestDecompressEmptyBJJComp(t *testing.T) {
167 pkComp := EmptyBJJComp
168 pk, err := pkComp.Decompress()
169 require.NoError(t, err)
170 assert.Equal(t, "2957874849018779266517920829765869116077630550401372566248359756137677864698", pk.X.String())
171 assert.Equal(t, "0", pk.Y.String())
172}
173
174func TestPoolL2TxID(t *testing.T) {
175 tx0 := PoolL2Tx{
176 FromIdx: 5,
177 ToIdx: 5,
178 Amount: big.NewInt(5),
179 Fee: 126,
180 TokenID: 5,
181 Nonce: 5,
182 }
183 err := tx0.SetID()
184 require.NoError(t, err)
185
186 // differ TokenID
187 tx1 := PoolL2Tx{
188 FromIdx: 5,
189 ToIdx: 5,
190 Amount: big.NewInt(5),
191 Fee: 126,
192 TokenID: 4,
193 Nonce: 5,
194 }
195 err = tx1.SetID()
196 require.NoError(t, err)
197 assert.NotEqual(t, tx0.TxID, tx1.TxID)
198 // differ Nonce
199 tx1 = PoolL2Tx{
200 FromIdx: 5,
201 ToIdx: 5,
202 Amount: big.NewInt(5),
203 Fee: 126,
204 TokenID: 5,
205 Nonce: 4,
206 }
207 err = tx1.SetID()
208 require.NoError(t, err)
209 assert.NotEqual(t, tx0.TxID, tx1.TxID)
210 // differ Fee
211 tx1 = PoolL2Tx{
212 FromIdx: 5,
213 ToIdx: 5,
214 Amount: big.NewInt(5),
215 Fee: 124,
216 TokenID: 5,
217 Nonce: 5,
218 }
219 err = tx1.SetID()
220 require.NoError(t, err)
221 assert.NotEqual(t, tx0.TxID, tx1.TxID)
222}