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, "0x020000000156660000000090", poolL2Tx.TxID.String())
 25}
 26
 27func TestTxCompressedData(t *testing.T) {
 28	var sk babyjub.PrivateKey
 29	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
 30	assert.NoError(t, err)
 31	tx := PoolL2Tx{
 32		FromIdx: 2,
 33		ToIdx:   3,
 34		Amount:  big.NewInt(4),
 35		TokenID: 5,
 36		Nonce:   6,
 37		ToBJJ:   sk.Public().Compress(),
 38	}
 39	txCompressedData, err := tx.TxCompressedData()
 40	assert.NoError(t, err)
 41	// test vector value generated from javascript implementation
 42	expectedStr := "1766847064778421992193717128424891165872736891548909569553540445094274575"
 43	assert.Equal(t, expectedStr, txCompressedData.String())
 44	assert.Equal(t, "010000000000060000000500040000000000030000000000020000c60be60f", hex.EncodeToString(txCompressedData.Bytes()))
 45	tx = PoolL2Tx{
 46		RqFromIdx: 7,
 47		RqToIdx:   8,
 48		RqAmount:  big.NewInt(9),
 49		RqTokenID: 10,
 50		RqNonce:   11,
 51		RqFee:     12,
 52		RqToBJJ:   sk.Public().Compress(),
 53	}
 54	txCompressedData, err = tx.RqTxCompressedDataV2()
 55	assert.NoError(t, err)
 56	// test vector value generated from javascript implementation
 57	expectedStr = "6571340879233176732837827812956721483162819083004853354503"
 58	assert.Equal(t, expectedStr, txCompressedData.String())
 59	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
 60}
 61
 62func TestTxCompressedDataV2(t *testing.T) {
 63	var sk babyjub.PrivateKey
 64	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
 65	assert.NoError(t, err)
 66	tx := PoolL2Tx{
 67		FromIdx: 7,
 68		ToIdx:   8,
 69		Amount:  big.NewInt(9),
 70		TokenID: 10,
 71		Nonce:   11,
 72		Fee:     12,
 73		ToBJJ:   sk.Public().Compress(),
 74	}
 75	txCompressedData, err := tx.TxCompressedDataV2()
 76	assert.NoError(t, err)
 77	// test vector value generated from javascript implementation
 78	expectedStr := "6571340879233176732837827812956721483162819083004853354503"
 79	assert.Equal(t, expectedStr, txCompressedData.String())
 80	expected, ok := new(big.Int).SetString(expectedStr, 10)
 81	assert.True(t, ok)
 82
 83	assert.Equal(t, expected.Bytes(), txCompressedData.Bytes())
 84	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
 85}
 86
 87func TestRqTxCompressedDataV2(t *testing.T) {
 88	var sk babyjub.PrivateKey
 89	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
 90	assert.NoError(t, err)
 91	tx := PoolL2Tx{
 92		RqFromIdx: 7,
 93		RqToIdx:   8,
 94		RqAmount:  big.NewInt(9),
 95		RqTokenID: 10,
 96		RqNonce:   11,
 97		RqFee:     12,
 98		RqToBJJ:   sk.Public().Compress(),
 99	}
100	txCompressedData, err := tx.RqTxCompressedDataV2()
101	assert.NoError(t, err)
102	// test vector value generated from javascript implementation
103	expectedStr := "6571340879233176732837827812956721483162819083004853354503"
104	assert.Equal(t, expectedStr, txCompressedData.String())
105	expected, ok := new(big.Int).SetString(expectedStr, 10)
106	assert.True(t, ok)
107	assert.Equal(t, expected.Bytes(), txCompressedData.Bytes())
108	assert.Equal(t, "010c000000000b0000000a0009000000000008000000000007", hex.EncodeToString(txCompressedData.Bytes()))
109}
110
111func TestHashToSign(t *testing.T) {
112	var sk babyjub.PrivateKey
113	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
114	assert.NoError(t, err)
115	tx := PoolL2Tx{
116		FromIdx:   2,
117		ToIdx:     3,
118		Amount:    big.NewInt(4),
119		TokenID:   5,
120		Nonce:     6,
121		ToEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
122	}
123	toSign, err := tx.HashToSign()
124	assert.NoError(t, err)
125	assert.Equal(t, "1469900657138253851938022936440971384682713995864967090251961124784132925291", toSign.String())
126}
127
128func TestVerifyTxSignature(t *testing.T) {
129	var sk babyjub.PrivateKey
130	_, err := hex.Decode(sk[:], []byte("0001020304050607080900010203040506070809000102030405060708090001"))
131	assert.NoError(t, err)
132	tx := PoolL2Tx{
133		FromIdx:     2,
134		ToIdx:       3,
135		Amount:      big.NewInt(4),
136		TokenID:     5,
137		Nonce:       6,
138		ToBJJ:       sk.Public().Compress(),
139		RqToEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
140		RqToBJJ:     sk.Public().Compress(),
141	}
142	toSign, err := tx.HashToSign()
143	assert.NoError(t, err)
144	assert.Equal(t, "18645218094210271622244722988708640202588315450486586312909439859037906375295", toSign.String())
145
146	sig := sk.SignPoseidon(toSign)
147	tx.Signature = sig.Compress()
148	assert.True(t, tx.VerifySignature(sk.Public().Compress()))
149}
150
151func TestDecompressEmptyBJJComp(t *testing.T) {
152	pkComp := EmptyBJJComp
153	pk, err := pkComp.Decompress()
154	require.NoError(t, err)
155	assert.Equal(t, "2957874849018779266517920829765869116077630550401372566248359756137677864698", pk.X.String())
156	assert.Equal(t, "0", pk.Y.String())
157}