Add common> Idx parsers

batchbuilder/batchbuilder.go

@@ -55,7 +55,9 @@ func (bb *BatchBuilder) Reset(batchNum int, idx uint64, fromSynchronizer bool) e
 	return nil
 }
 
-func (bb *BatchBuilder) BuildBatch(configBatch ConfigBatch, l1usertxs, l1coordinatortxs []common.L1Tx, l2txs []common.L2Tx, tokenIDs []common.TokenID) (*common.ZKInputs, error) {
+type ZKInputs struct{} // TMP
+
+func (bb *BatchBuilder) BuildBatch(configBatch ConfigBatch, l1usertxs, l1coordinatortxs []common.L1Tx, l2txs []common.L2Tx, tokenIDs []common.TokenID) (*ZKInputs, error) {
 
 	for _, tx := range l1usertxs {
 		bb.processL1Tx(tx)
@@ -123,7 +125,7 @@ func (bb *BatchBuilder) applyCreateLeaf(tx common.L1Tx) error {
 		EthAddr: tx.FromEthAddr,
 	}
 
-	v, err := leaf.Value()
+	v, err := leaf.HashValue()
 	if err != nil {
 		return err
 	}
@@ -133,7 +135,10 @@ func (bb *BatchBuilder) applyCreateLeaf(tx common.L1Tx) error {
 	if err != nil {
 		return err
 	}
-	leafBytes := leaf.Bytes()
+	leafBytes, err := leaf.Bytes()
+	if err != nil {
+		return err
+	}
 	dbTx.Put(v.Bytes(), leafBytes[:])
 
 	// Add k & v into the MT

common/leaf.go

@@ -66,10 +66,13 @@ func (l *Leaf) BigInts() ([5]*big.Int, error) {
 	return e, nil
 }
 
-// Value returns the value of the Leaf, which is the Poseidon hash of its *big.Int representation
+// HashValue returns the value of the Leaf, which is the Poseidon hash of its *big.Int representation
-func (l *Leaf) Value() (*big.Int, error) {
+func (l *Leaf) HashValue() (*big.Int, error) {
 	toHash := [poseidon.T]*big.Int{}
-	lBI := l.BigInts()
+	lBI, err := l.BigInts()
+	if err != nil {
+		return nil, err
+	}
 	copy(toHash[:], lBI[:])
 
 	v, err := poseidon.Hash(toHash)

common/tx.go

@@ -1,14 +1,38 @@
 package common
 
 import (
+	"encoding/binary"
 	"math/big"
 )
 
+// Idx represents the account Index in the MerkleTree
+type Idx uint32
+
+// Bytes returns a byte array representing the Idx
+func (idx Idx) Bytes() []byte {
+	var b [4]byte
+	binary.LittleEndian.PutUint32(b[:], uint32(idx))
+	return b[:]
+}
+
+// BigInt returns a *big.Int representing the Idx
+func (idx Idx) BigInt() *big.Int {
+	return big.NewInt(int64(idx))
+}
+
+// IdxFromBigInt converts a *big.Int to Idx type
+func IdxFromBigInt(b *big.Int) (Idx, error) {
+	if b.Int64() > 4294967295 { // 2**32-1
+		return 0, ErrNumOverflow
+	}
+	return Idx(uint32(b.Int64())), nil
+}
+
 // Tx is a struct that represents a Hermez network transaction
 type Tx struct {
 	TxID     TxID
-	FromIdx  uint32
+	FromIdx  Idx // FromIdx is used by L1Tx/Deposit to indicate the Idx receiver of the L1Tx.LoadAmount (deposit)
-	ToIdx    uint32
+	ToIdx    Idx // ToIdx is ignored in L1Tx/Deposit, but used in the L1Tx/DepositAndTransfer
 	TokenID  TokenID
 	Amount   *big.Int
 	Nonce    uint64 // effective 48 bits used

common/tx_test.go

@@ -0,0 +1,23 @@
+package common
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIdx(t *testing.T) {
+	i := Idx(100)
+	assert.Equal(t, big.NewInt(100), i.BigInt())
+
+	i = Idx(uint32(4294967295))
+	assert.Equal(t, "4294967295", i.BigInt().String())
+
+	b := big.NewInt(4294967296)
+	i, err := IdxFromBigInt(b)
+	assert.NotNil(t, err)
+	assert.Equal(t, ErrNumOverflow, err)
+	assert.Equal(t, Idx(0), i)
+
+}