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	fromIdx := Idx(300)
 21	l1Tx := &L1Tx{
 22		ToForgeL1TxsNum: &toForge,
 23		Position:        71,
 24		UserOrigin:      true,
 25		ToIdx:           301,
 26		TokenID:         5,
 27		Amount:          big.NewInt(1),
 28		LoadAmount:      big.NewInt(2),
 29		FromIdx:         &fromIdx,
 30	}
 31	l1Tx, err := NewL1Tx(l1Tx)
 32	assert.Nil(t, err)
 33	assert.Equal(t, "0x00000000000001e240004700", l1Tx.TxID.String())
 34}
 35
 36func TestNewL1CoordinatorTx(t *testing.T) {
 37	fromIdx := Idx(300)
 38	batchNum := BatchNum(51966)
 39	l1Tx := &L1Tx{
 40		Position:   88,
 41		UserOrigin: false,
 42		ToIdx:      301,
 43		TokenID:    5,
 44		Amount:     big.NewInt(1),
 45		LoadAmount: big.NewInt(2),
 46		FromIdx:    &fromIdx,
 47		BatchNum:   &batchNum,
 48	}
 49	l1Tx, err := NewL1Tx(l1Tx)
 50	assert.Nil(t, err)
 51	assert.Equal(t, "0x01000000000000cafe005800", l1Tx.TxID.String())
 52}
 53
 54func TestL1TxByteParsers(t *testing.T) {
 55	var pkComp babyjub.PublicKeyComp
 56	err := pkComp.UnmarshalText([]byte("0x56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c"))
 57	require.Nil(t, err)
 58
 59	pk, err := pkComp.Decompress()
 60	require.Nil(t, err)
 61
 62	fromIdx := new(Idx)
 63	*fromIdx = 2
 64	l1Tx := &L1Tx{
 65		ToIdx:       3,
 66		TokenID:     5,
 67		Amount:      big.NewInt(1),
 68		LoadAmount:  big.NewInt(2),
 69		FromIdx:     fromIdx,
 70		FromBJJ:     pk,
 71		FromEthAddr: ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
 72	}
 73
 74	expected, err := utils.HexDecode("c58d29fa6e86e4fae04ddced660d45bcf3cb237056ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c0000000000020002000100000005000000000003")
 75	require.Nil(t, err)
 76
 77	encodedData, err := l1Tx.Bytes()
 78	require.Nil(t, err)
 79	assert.Equal(t, expected, encodedData)
 80
 81	decodedData, err := L1TxFromBytes(encodedData)
 82	require.Nil(t, err)
 83	assert.Equal(t, l1Tx, decodedData)
 84
 85	encodedData2, err := decodedData.Bytes()
 86	require.Nil(t, err)
 87	assert.Equal(t, encodedData, encodedData2)
 88
 89	// expect error if length!=68
 90	_, err = L1TxFromBytes(encodedData[:66])
 91	require.NotNil(t, err)
 92	_, err = L1TxFromBytes([]byte{})
 93	require.NotNil(t, err)
 94	_, err = L1TxFromBytes(nil)
 95	require.NotNil(t, err)
 96}
 97
 98func TestL1CoordinatorTxByteParsers(t *testing.T) {
 99	privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
100	require.Nil(t, err)
101
102	publicKey := privateKey.Public()
103	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
104	if !ok {
105		log.Fatal("error casting public key to ECDSA")
106	}
107	publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
108	pubKey, err := crypto.UnmarshalPubkey(publicKeyBytes)
109	require.Nil(t, err)
110	fromEthAddr := crypto.PubkeyToAddress(*pubKey)
111	var pkComp babyjub.PublicKeyComp
112	err = pkComp.UnmarshalText([]byte("0x56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c"))
113	require.Nil(t, err)
114	pk, err := pkComp.Decompress()
115	require.Nil(t, err)
116	bytesMessage1 := []byte("\x19Ethereum Signed Message:\n98")
117	bytesMessage2 := []byte("I authorize this babyjubjub key for hermez rollup account creation")
118
119	babyjub := pk.Compress()
120	var data []byte
121	data = append(data, bytesMessage1...)
122	data = append(data, bytesMessage2...)
123	data = append(data, babyjub[:]...)
124	hash := crypto.Keccak256Hash(data)
125	signature, err := crypto.Sign(hash.Bytes(), privateKey)
126	require.Nil(t, err)
127	// Ethereum adds 27 to v
128	v := int(signature[64])
129	signature[64] = byte(v + 27)
130
131	l1Tx := &L1Tx{
132		TokenID:     231,
133		FromBJJ:     pk,
134		FromEthAddr: fromEthAddr,
135	}
136
137	bytesCoordinatorL1, err := l1Tx.BytesCoordinatorTx(signature)
138	require.Nil(t, err)
139	l1txDecoded, err := L1TxFromCoordinatorBytes(bytesCoordinatorL1)
140	require.Nil(t, err)
141	assert.Equal(t, l1Tx, l1txDecoded)
142}
143
144func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
145	var signature []byte
146	r, err := hex.DecodeString("da71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3b")
147	require.Nil(t, err)
148	s, err := hex.DecodeString("186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8c")
149	require.Nil(t, err)
150	v, err := hex.DecodeString("1b")
151	require.Nil(t, err)
152
153	signature = append(signature, r[:]...)
154	signature = append(signature, s[:]...)
155	signature = append(signature, v[:]...)
156
157	var pkComp babyjub.PublicKeyComp
158	err = pkComp.UnmarshalText([]byte("0xa2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c"))
159	require.Nil(t, err)
160	// Data from the compatibility test
161	expected := "1b186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8cda71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3ba2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c000000e7"
162	pk, err := pkComp.Decompress()
163	require.Nil(t, err)
164
165	l1Tx := &L1Tx{
166		TokenID: 231,
167		FromBJJ: pk,
168	}
169
170	encodeData, err := l1Tx.BytesCoordinatorTx(signature)
171	require.Nil(t, err)
172	assert.Equal(t, expected, hex.EncodeToString(encodeData))
173}