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