1package common
  2
  3import (
  4	"encoding/hex"
  5	"math/big"
  6	"testing"
  7
  8	"github.com/stretchr/testify/assert"
  9	"github.com/stretchr/testify/require"
 10)
 11
 12func TestNewL2Tx(t *testing.T) {
 13	l2Tx := &L2Tx{
 14		FromIdx: 87654,
 15		ToIdx:   300,
 16		TokenID: 5,
 17		Amount:  big.NewInt(4),
 18		Nonce:   144,
 19	}
 20	l2Tx, err := NewL2Tx(l2Tx)
 21	assert.NoError(t, err)
 22	assert.Equal(t, "0x022669acda59b827d20ef5354a3eebd1dffb3972b0a6bf89d18bfd2efa0ab9f41e",
 23		l2Tx.TxID.String())
 24
 25	l2Tx = &L2Tx{
 26		FromIdx: 87654,
 27		ToIdx:   300,
 28		TokenID: 5,
 29		Amount:  big.NewInt(4),
 30		Nonce:   1,
 31	}
 32	l2Tx, err = NewL2Tx(l2Tx)
 33	assert.NoError(t, err)
 34	assert.Equal(t, "0x029e7499a830f8f5eb17c07da48cf91415710f1bcbe0169d363ff91e81faf92fc2",
 35		l2Tx.TxID.String())
 36
 37	l2Tx = &L2Tx{
 38		FromIdx: 87654,
 39		ToIdx:   300,
 40		TokenID: 5,
 41		Amount:  big.NewInt(4),
 42		Fee:     126,
 43		Nonce:   3,
 44	}
 45	l2Tx, err = NewL2Tx(l2Tx)
 46	assert.NoError(t, err)
 47	assert.Equal(t, "0x0255c70ed20e1b8935232e1b9c5884dbcc88a6e1a3454d24f2d77252eb2bb0b64e",
 48		l2Tx.TxID.String())
 49
 50	l2Tx = &L2Tx{
 51		FromIdx: 87654,
 52		ToIdx:   300,
 53		TokenID: 5,
 54		Amount:  big.NewInt(4),
 55		Nonce:   1003,
 56		Fee:     144,
 57	}
 58	l2Tx, err = NewL2Tx(l2Tx)
 59	assert.NoError(t, err)
 60	assert.Equal(t, "0x0206b372f967061d1148bbcff679de38120e075141a80a07326d0f514c2efc6ca9",
 61		l2Tx.TxID.String())
 62
 63	l2Tx = &L2Tx{
 64		FromIdx: 1,
 65		ToIdx:   1,
 66		TokenID: 1,
 67		Amount:  big.NewInt(1),
 68		Nonce:   1,
 69		Fee:     1,
 70	}
 71	l2Tx, err = NewL2Tx(l2Tx)
 72	assert.NoError(t, err)
 73	assert.Equal(t, "0x0236f7ea5bccf78ba60baf56c058d235a844f9b09259fd0efa4f5f72a7d4a26618",
 74		l2Tx.TxID.String())
 75
 76	l2Tx = &L2Tx{
 77		FromIdx: 999,
 78		ToIdx:   999,
 79		TokenID: 999,
 80		Amount:  big.NewInt(999),
 81		Nonce:   999,
 82		Fee:     255,
 83	}
 84	l2Tx, err = NewL2Tx(l2Tx)
 85	assert.NoError(t, err)
 86	assert.Equal(t, "0x02ac122f5b709ce190129fecbbe35bfd30c70e6433dbd85a8eb743d110906a1dc1",
 87		l2Tx.TxID.String())
 88
 89	l2Tx = &L2Tx{
 90		FromIdx: 4444,
 91		ToIdx:   300,
 92		TokenID: 0,
 93		Amount:  big.NewInt(3400000000),
 94		Nonce:   2,
 95		Fee:     25,
 96	}
 97	l2Tx, err = NewL2Tx(l2Tx)
 98	assert.NoError(t, err)
 99	assert.Equal(t, "0x02c674951a81881b7bc50db3b9e5efd97ac88550c7426ac548720e5057cfba515a",
100		l2Tx.TxID.String())
101}
102
103func TestL2TxByteParsers(t *testing.T) {
104	// test vectors values generated from javascript implementation
105	amount, ok := new(big.Int).SetString("343597383670000000000000000000000000000000", 10)
106	require.True(t, ok)
107	l2Tx := &L2Tx{
108		ToIdx:   (1 << 16) - 1,
109		FromIdx: (1 << 16) - 1,
110		Amount:  amount,
111		Fee:     (1 << 8) - 1,
112	}
113	expected := "ffffffffffffffffffff"
114	encodedData, err := l2Tx.BytesDataAvailability(16)
115	require.NoError(t, err)
116	assert.Equal(t, expected, hex.EncodeToString(encodedData))
117
118	decodedData, err := L2TxFromBytesDataAvailability(encodedData, 16)
119	require.NoError(t, err)
120	assert.Equal(t, l2Tx, decodedData)
121
122	l2Tx = &L2Tx{
123		ToIdx:   (1 << 32) - 1,
124		FromIdx: (1 << 32) - 1,
125		Amount:  amount,
126		Fee:     (1 << 8) - 1,
127	}
128	expected = "ffffffffffffffffffffffffffff"
129	encodedData, err = l2Tx.BytesDataAvailability(32)
130	require.NoError(t, err)
131	assert.Equal(t, expected, hex.EncodeToString(encodedData))
132
133	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
134	require.NoError(t, err)
135	assert.Equal(t, l2Tx, decodedData)
136
137	l2Tx = &L2Tx{
138		ToIdx:   0,
139		FromIdx: 0,
140		Amount:  big.NewInt(0),
141		Fee:     0,
142	}
143	expected = "0000000000000000000000000000"
144	encodedData, err = l2Tx.BytesDataAvailability(32)
145	require.NoError(t, err)
146	assert.Equal(t, expected, hex.EncodeToString(encodedData))
147
148	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
149	require.NoError(t, err)
150	assert.Equal(t, l2Tx, decodedData)
151
152	l2Tx = &L2Tx{
153		ToIdx:   0,
154		FromIdx: 1061,
155		Amount:  big.NewInt(420000000000),
156		Fee:     127,
157	}
158	expected = "000004250000000010fa56ea007f"
159	encodedData, err = l2Tx.BytesDataAvailability(32)
160	require.NoError(t, err)
161	assert.Equal(t, expected, hex.EncodeToString(encodedData))
162
163	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
164	require.NoError(t, err)
165	assert.Equal(t, l2Tx, decodedData)
166
167	l2Tx = &L2Tx{
168		ToIdx:   256,
169		FromIdx: 257,
170		Amount:  big.NewInt(79000000),
171		Fee:     201,
172	}
173	expected = "00000101000001000004b571c0c9"
174	encodedData, err = l2Tx.BytesDataAvailability(32)
175	require.NoError(t, err)
176	assert.Equal(t, expected, hex.EncodeToString(encodedData))
177
178	decodedData, err = L2TxFromBytesDataAvailability(encodedData, 32)
179	require.NoError(t, err)
180	assert.Equal(t, l2Tx, decodedData)
181}