Merge pull request #128 from hermeznetwork/feature/l1txbytes

Update common.L1Tx parsers, add test checks

common/l1tx.go

@@ -1,6 +1,7 @@
 package common
 
 import (
+	"fmt"
 	"math/big"
 
 	ethCommon "github.com/ethereum/go-ethereum/common"
@@ -8,11 +9,8 @@ import (
 )
 
 const (
-	fromBJJCompressedB = 256
-	fromEthAddrB       = 160
-	f16B               = 16
-	tokenIDB           = 32
-	cidXB              = 32
+	// L1TxBytesLen is the length of the byte array that represents the L1Tx
+	L1TxBytesLen = 68
 )
 
 // L1Tx is a struct that represents a L1 tx
@@ -64,69 +62,57 @@ func (tx *L1Tx) Tx() *Tx {
 }
 
 // Bytes encodes a L1Tx into []byte
-func (tx *L1Tx) Bytes(nLevels int) []byte {
-	res := big.NewInt(0)
-	res = res.Add(res, big.NewInt(0).Or(big.NewInt(0), tx.ToIdx.BigInt()))
-	res = res.Add(res, big.NewInt(0).Lsh(big.NewInt(0).Or(big.NewInt(0), big.NewInt(int64(tx.TokenID))), uint(nLevels)))
-	res = res.Add(res, big.NewInt(0).Lsh(big.NewInt(0).Or(big.NewInt(0), tx.Amount), uint(nLevels+tokenIDB)))
-	res = res.Add(res, big.NewInt(0).Lsh(big.NewInt(0).Or(big.NewInt(0), tx.LoadAmount), uint(nLevels+tokenIDB+f16B)))
-	res = res.Add(res, big.NewInt(0).Lsh(big.NewInt(0).Or(big.NewInt(0), tx.FromIdx.BigInt()), uint(nLevels+tokenIDB+2*f16B)))
-
-	fromBJJ := big.NewInt(0)
-	fromBJJ.SetString(tx.FromBJJ.String(), 16)
-	fromBJJCompressed := big.NewInt(0).Or(big.NewInt(0), fromBJJ)
-	res = res.Add(res, big.NewInt(0).Lsh(fromBJJCompressed, uint(2*nLevels+tokenIDB+2*f16B)))
-
-	fromEthAddr := big.NewInt(0).Or(big.NewInt(0), tx.FromEthAddr.Hash().Big())
-	res = res.Add(res, big.NewInt(0).Lsh(fromEthAddr, uint(fromBJJCompressedB+2*nLevels+tokenIDB+2*f16B)))
-
-	return res.Bytes()
+func (tx *L1Tx) Bytes(nLevels int) ([]byte, error) {
+	var b [68]byte
+	copy(b[0:20], tx.FromEthAddr.Bytes())
+	pkComp := tx.FromBJJ.Compress()
+	copy(b[20:52], pkComp[:])
+	copy(b[52:56], tx.FromIdx.Bytes())
+	loadAmountFloat16, err := NewFloat16(tx.LoadAmount)
+	if err != nil {
+		return nil, err
+	}
+	copy(b[56:58], loadAmountFloat16.Bytes())
+	amountFloat16, err := NewFloat16(tx.Amount)
+	if err != nil {
+		return nil, err
+	}
+	copy(b[58:60], amountFloat16.Bytes())
+	copy(b[60:64], tx.TokenID.Bytes())
+	copy(b[64:68], tx.ToIdx.Bytes())
+	return b[:], nil
 }
 
 // L1TxFromBytes decodes a L1Tx from []byte
-func L1TxFromBytes(l1TxEncoded []byte) (*L1Tx, error) {
-	l1Tx := &L1Tx{}
-	var idxB uint = cidXB
-
-	l1TxEncodedBI := big.NewInt(0)
-	l1TxEncodedBI.SetBytes(l1TxEncoded)
-
-	toIdx, err := IdxFromBigInt(extract(l1TxEncodedBI, 0, idxB))
-
-	if err != nil {
-		return nil, err
+func L1TxFromBytes(b []byte) (*L1Tx, error) {
+	if len(b) != L1TxBytesLen {
+		return nil, fmt.Errorf("Can not parse L1Tx bytes, expected length %d, current: %d", 68, len(b))
 	}
 
-	l1Tx.ToIdx = toIdx
-
-	l1Tx.TokenID = TokenID(extract(l1TxEncodedBI, idxB, tokenIDB).Uint64())
-	l1Tx.Amount = extract(l1TxEncodedBI, idxB+tokenIDB, f16B)
-	l1Tx.LoadAmount = extract(l1TxEncodedBI, idxB+tokenIDB+f16B, f16B)
-	fromIdx, err := IdxFromBigInt(extract(l1TxEncodedBI, idxB+tokenIDB+2*f16B, f16B))
-
-	if err != nil {
-		return nil, err
-	}
-
-	l1Tx.FromIdx = fromIdx
-
+	tx := &L1Tx{}
+	var err error
+	tx.FromEthAddr = ethCommon.BytesToAddress(b[0:20])
+	pkCompB := b[20:52]
 	var pkComp babyjub.PublicKeyComp
-	copy(pkComp[:], extract(l1TxEncodedBI, 2*idxB+tokenIDB+2*f16B, fromBJJCompressedB).Bytes())
-	pk, err := pkComp.Decompress()
-
+	copy(pkComp[:], pkCompB)
+	tx.FromBJJ, err = pkComp.Decompress()
+	if err != nil {
+		return nil, err
+	}
+	tx.FromIdx, err = IdxFromBytes(b[52:56])
+	if err != nil {
+		return nil, err
+	}
+	tx.LoadAmount = Float16FromBytes(b[56:58]).BigInt()
+	tx.Amount = Float16FromBytes(b[58:60]).BigInt()
+	tx.TokenID, err = TokenIDFromBytes(b[60:64])
+	if err != nil {
+		return nil, err
+	}
+	tx.ToIdx, err = IdxFromBytes(b[64:68])
 	if err != nil {
 		return nil, err
 	}
 
-	l1Tx.FromBJJ = pk
-
-	l1Tx.FromEthAddr = ethCommon.BigToAddress(extract(l1TxEncodedBI, fromBJJCompressedB+2*idxB+tokenIDB+2*f16B, fromEthAddrB))
-
-	return l1Tx, nil
-}
-
-// extract masks and shifts a bigInt
-func extract(num *big.Int, origin uint, len uint) *big.Int {
-	mask := big.NewInt(0).Sub(big.NewInt(0).Lsh(big.NewInt(1), len), big.NewInt(1))
-	return big.NewInt(0).And(big.NewInt(0).Rsh(num, origin), mask)
+	return tx, nil
 }