mv of babyjub.PublicKey to babyjub.PublicKeyComp

Update usage of `*babyjub.PublicKey` to `babyjub.PublicKeyComp`
- when the key is not defined, internally is used `babyjub.EmptyBJJComp`, which is a `[32]byte` of zeroes of type `babyjub.PublicKeyComp`
- the API continues returning `nil` when the key is not defined

common/l1tx_test.go

@@ -28,7 +28,7 @@ func TestNewL1UserTx(t *testing.T) {
 		FromIdx:         Idx(300),
 	}
 	l1Tx, err := NewL1Tx(l1Tx)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, "0x00000000000001e240004700", l1Tx.TxID.String())
 }
 
@@ -45,7 +45,7 @@ func TestNewL1CoordinatorTx(t *testing.T) {
 		BatchNum:      &batchNum,
 	}
 	l1Tx, err := NewL1Tx(l1Tx)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, "0x01000000000000cafe005800", l1Tx.TxID.String())
 }
 
@@ -57,7 +57,7 @@ func TestL1TxCompressedData(t *testing.T) {
 		TokenID: 5,
 	}
 	txCompressedData, err := tx.TxCompressedData()
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	// test vector value generated from javascript implementation
 	expectedStr := "7307597389635308713748674793997299267459594577423"
@@ -73,7 +73,7 @@ func TestBytesDataAvailability(t *testing.T) {
 		TokenID: 5,
 	}
 	txCompressedData, err := tx.BytesDataAvailability(32)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, "0000000200000003000000", hex.EncodeToString(txCompressedData))
 
 	tx = L1Tx{
@@ -83,7 +83,7 @@ func TestBytesDataAvailability(t *testing.T) {
 		TokenID:         5,
 	}
 	txCompressedData, err = tx.BytesDataAvailability(32)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, "0000000200000003000400", hex.EncodeToString(txCompressedData))
 }
 
@@ -94,7 +94,7 @@ func TestL1TxFromDataAvailability(t *testing.T) {
 		Amount:  big.NewInt(4),
 	}
 	txCompressedData, err := tx.BytesDataAvailability(32)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	l1tx, err := L1TxFromDataAvailability(txCompressedData, 32)
 	require.NoError(t, err)
 	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
@@ -106,7 +106,7 @@ func TestL1TxFromDataAvailability(t *testing.T) {
 		EffectiveAmount: big.NewInt(4),
 	}
 	txCompressedData, err = tx.BytesDataAvailability(32)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	l1tx, err = L1TxFromDataAvailability(txCompressedData, 32)
 	require.NoError(t, err)
 	assert.Equal(t, tx.FromIdx, l1tx.FromIdx)
@@ -118,10 +118,7 @@ func TestL1userTxByteParsers(t *testing.T) {
 	var pkComp babyjub.PublicKeyComp
 	pkCompL := []byte("0x56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
 	err := pkComp.UnmarshalText(pkCompL)
-	require.Nil(t, err)
-
-	pk, err := pkComp.Decompress()
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	l1Tx := &L1Tx{
 		UserOrigin:    true,
@@ -130,17 +127,17 @@ func TestL1userTxByteParsers(t *testing.T) {
 		Amount:        big.NewInt(1),
 		DepositAmount: big.NewInt(2),
 		FromIdx:       2,
-		FromBJJ:       pk,
+		FromBJJ:       pkComp,
 		FromEthAddr:   ethCommon.HexToAddress("0xc58d29fA6e86E4FAe04DDcEd660d45BCf3Cb2370"),
 	}
 
 	encodedData, err := l1Tx.BytesUser()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	decodedData, err := L1UserTxFromBytes(encodedData)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, l1Tx, decodedData)
 	encodedData2, err := decodedData.BytesUser()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, encodedData, encodedData2)
 
 	// expect error if length!=68
@@ -156,13 +153,10 @@ func TestL1TxByteParsersCompatibility(t *testing.T) {
 	// Data from compatibility test
 	var pkComp babyjub.PublicKeyComp
 	pkCompB, err := hex.DecodeString("0dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	pkCompL := SwapEndianness(pkCompB)
 	err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
-	require.Nil(t, err)
-
-	pk, err := pkComp.Decompress()
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	depositAmount := new(big.Int)
 	depositAmount.SetString("100000000000000000000", 10)
@@ -172,16 +166,16 @@ func TestL1TxByteParsersCompatibility(t *testing.T) {
 		Amount:        big.NewInt(2400000000000000000),
 		DepositAmount: depositAmount,
 		FromIdx:       Idx(29767899),
-		FromBJJ:       pk,
+		FromBJJ:       pkComp,
 		FromEthAddr:   ethCommon.HexToAddress("0x85dab5b9e2e361d0c208d77be90efcc0439b0a53"),
 		UserOrigin:    true,
 	}
 
 	expected, err := utils.HexDecode("85dab5b9e2e361d0c208d77be90efcc0439b0a530dd02deb2c81068e7a0f7e327df80b4ab79ee1f41a7def613e73a20c32eece5a000001c638db8be880f00020039c0000053cb88d")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	encodedData, err := l1Tx.BytesUser()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expected, encodedData)
 }
 
@@ -191,7 +185,7 @@ func TestL1CoordinatorTxByteParsers(t *testing.T) {
 	chainIDBytes := ethCommon.LeftPadBytes(chainID.Bytes(), 2)
 
 	privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	publicKey := privateKey.Public()
 	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
@@ -200,19 +194,16 @@ func TestL1CoordinatorTxByteParsers(t *testing.T) {
 	}
 	publicKeyBytes := crypto.FromECDSAPub(publicKeyECDSA)
 	pubKey, err := crypto.UnmarshalPubkey(publicKeyBytes)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	fromEthAddr := crypto.PubkeyToAddress(*pubKey)
 	var pkComp babyjub.PublicKeyComp
 	pkCompL := []byte("56ca90f80d7c374ae7485e9bcc47d4ac399460948da6aeeb899311097925a72c")
 	err = pkComp.UnmarshalText(pkCompL)
-	require.Nil(t, err)
-	pk, err := pkComp.Decompress()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	bytesMessage1 := []byte("\x19Ethereum Signed Message:\n120")
 	bytesMessage2 := []byte("I authorize this babyjubjub key for hermez rollup account creation")
 
-	babyjub := pk.Compress()
-	babyjubB := SwapEndianness(babyjub[:])
+	babyjubB := SwapEndianness(pkComp[:])
 	var data []byte
 	data = append(data, bytesMessage1...)
 	data = append(data, bytesMessage2...)
@@ -221,26 +212,26 @@ func TestL1CoordinatorTxByteParsers(t *testing.T) {
 	data = append(data, hermezAddress.Bytes()...)
 	hash := crypto.Keccak256Hash(data)
 	signature, err := crypto.Sign(hash.Bytes(), privateKey)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	// Ethereum adds 27 to v
 	v := int(signature[64])
 	signature[64] = byte(v + 27)
 
 	l1Tx := &L1Tx{
 		TokenID:       231,
-		FromBJJ:       pk,
+		FromBJJ:       pkComp,
 		FromEthAddr:   fromEthAddr,
 		Amount:        big.NewInt(0),
 		DepositAmount: big.NewInt(0),
 	}
 
 	bytesCoordinatorL1, err := l1Tx.BytesCoordinatorTx(signature)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	l1txDecoded, err := L1CoordinatorTxFromBytes(bytesCoordinatorL1, chainID, hermezAddress)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, l1Tx, l1txDecoded)
 	bytesCoordinatorL12, err := l1txDecoded.BytesCoordinatorTx(signature)
-	require.Nil(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, bytesCoordinatorL1, bytesCoordinatorL12)
 
 	// expect error if length!=68
@@ -256,11 +247,11 @@ func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
 	// Data from compatibility test
 	var signature []byte
 	r, err := hex.DecodeString("da71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3b")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	s, err := hex.DecodeString("186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8c")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	v, err := hex.DecodeString("1b")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	signature = append(signature, r[:]...)
 	signature = append(signature, s[:]...)
@@ -268,24 +259,22 @@ func TestL1CoordinatorTxByteParsersCompatibility(t *testing.T) {
 
 	var pkComp babyjub.PublicKeyComp
 	pkCompB, err := hex.DecodeString("a2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c")
-	require.Nil(t, err)
+	require.NoError(t, err)
 	pkCompL := SwapEndianness(pkCompB)
 	err = pkComp.UnmarshalText([]byte(hex.EncodeToString(pkCompL)))
-	require.Nil(t, err)
+	require.NoError(t, err)
 	// Data from the compatibility test
-	require.Nil(t, err)
-	pk, err := pkComp.Decompress()
-	require.Nil(t, err)
+	require.NoError(t, err)
 	l1Tx := &L1Tx{
 		TokenID: 231,
-		FromBJJ: pk,
+		FromBJJ: pkComp,
 	}
 
 	encodeData, err := l1Tx.BytesCoordinatorTx(signature)
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	expected, err := utils.HexDecode("1b186d7122ff7f654cfed3156719774898d573900c86599a885a706dbdffe5ea8cda71e5eb097e115405d84d1e7b464009b434b32c014a2df502d1f065ced8bc3ba2c2807ee39c3b3378738cff85a46a9465bb8fcf44ea597c33da9719be7c259c000000e7")
-	require.Nil(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, expected, encodeData)
 }