Update coordinator to work better under real net

- cli / node
    - Update handler of SIGINT so that after 3 SIGINTs, the process terminates
      unconditionally
- coordinator
    - Store stats without pointer
    - In all functions that send a variable via channel, check for context done
      to avoid deadlock (due to no process reading from the channel, which has
      no queue) when the node is stopped.
    - Abstract `canForge` so that it can be used outside of the `Coordinator`
    - In `canForge` check the blockNumber in current and next slot.
    - Update tests due to smart contract changes in slot handling, and minimum
      bid defaults
    - TxManager
        - Add consts, vars and stats to allow evaluating `canForge`
        - Add `canForge` method (not used yet)
        - Store batch and nonces status (last success and last pending)
        - Track nonces internally instead of relying on the ethereum node (this
          is required to work with ganache when there are pending txs)
        - Handle the (common) case of the receipt not being found after the tx
          is sent.
        - Don't start the main loop until we get an initial messae fo the stats
          and vars (so that in the loop the stats and vars are set to
          synchronizer values)
- eth / ethereum client
    - Add necessary methods to create the auth object for transactions manually
      so that we can set the nonce, gas price, gas limit, etc manually
    - Update `RollupForgeBatch` to take an auth object as input (so that the
      coordinator can set parameters manually)
- synchronizer
    - In stats, add `NextSlot`

test/ethclient.go

@@ -11,6 +11,8 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	ethKeystore "github.com/ethereum/go-ethereum/accounts/keystore"
 	ethCommon "github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/hermeznetwork/hermez-node/common"
@@ -179,7 +181,6 @@ func (a *AuctionBlock) canForge(forger ethCommon.Address, blockNum int64) (bool,
 	}
 
 	slotToForge := a.getSlotNumber(blockNum)
-	// fmt.Printf("DBG canForge slot: %v\n", slotToForge)
 	// Get the relativeBlock to check if the slotDeadline has been exceeded
 	relativeBlock := blockNum - (a.Constants.GenesisBlockNum + (slotToForge * int64(a.Constants.BlocksPerSlot)))
 
@@ -616,6 +617,38 @@ func (c *Client) EthChainID() (*big.Int, error) {
 	return c.chainID, nil
 }
 
+// EthPendingNonceAt returns the account nonce of the given account in the pending
+// state. This is the nonce that should be used for the next transaction.
+func (c *Client) EthPendingNonceAt(ctx context.Context, account ethCommon.Address) (uint64, error) {
+	// NOTE: For now Client doesn't simulate nonces
+	return 0, nil
+}
+
+// EthNonceAt returns the account nonce of the given account. The block number can
+// be nil, in which case the nonce is taken from the latest known block.
+func (c *Client) EthNonceAt(ctx context.Context, account ethCommon.Address, blockNumber *big.Int) (uint64, error) {
+	// NOTE: For now Client doesn't simulate nonces
+	return 0, nil
+}
+
+// EthSuggestGasPrice retrieves the currently suggested gas price to allow a
+// timely execution of a transaction.
+func (c *Client) EthSuggestGasPrice(ctx context.Context) (*big.Int, error) {
+	// NOTE: For now Client doesn't simulate gasPrice
+	return big.NewInt(0), nil
+}
+
+// EthKeyStore returns the keystore in the Client
+func (c *Client) EthKeyStore() *ethKeystore.KeyStore {
+	return nil
+}
+
+// EthCall runs the transaction as a call (without paying) in the local node at
+// blockNum.
+func (c *Client) EthCall(ctx context.Context, tx *types.Transaction, blockNum *big.Int) ([]byte, error) {
+	return nil, tracerr.Wrap(common.ErrTODO)
+}
+
 // EthLastBlock returns the last blockNum
 func (c *Client) EthLastBlock() (int64, error) {
 	c.rw.RLock()
@@ -912,7 +945,7 @@ func (c *Client) newTransaction(name string, value interface{}) *types.Transacti
 }
 
 // RollupForgeBatch is the interface to call the smart contract function
-func (c *Client) RollupForgeBatch(args *eth.RollupForgeBatchArgs) (tx *types.Transaction, err error) {
+func (c *Client) RollupForgeBatch(args *eth.RollupForgeBatchArgs, auth *bind.TransactOpts) (tx *types.Transaction, err error) {
 	c.rw.Lock()
 	defer c.rw.Unlock()
 	cpy := c.nextBlock().copy()
@@ -1822,7 +1855,7 @@ func (c *Client) CtlAddBlocks(blocks []common.BlockData) (err error) {
 				ProofA:      [2]*big.Int{},    // Intentionally empty
 				ProofB:      [2][2]*big.Int{}, // Intentionally empty
 				ProofC:      [2]*big.Int{},    // Intentionally empty
-			}); err != nil {
+			}, nil); err != nil {
 				return tracerr.Wrap(err)
 			}
 		}

test/ethclient_test.go

@@ -98,7 +98,7 @@ func TestClientAuction(t *testing.T) {
 	_, err := c.AuctionBidSimple(0, big.NewInt(1))
 	assert.Equal(t, errBidClosed, tracerr.Unwrap(err))
 
-	_, err = c.AuctionBidSimple(4322, big.NewInt(1))
+	_, err = c.AuctionBidSimple(4323, big.NewInt(1))
 	assert.Equal(t, errBidNotOpen, tracerr.Unwrap(err))
 
 	// 101 % 6 = 5;  defaultSlotSetBid[5] = 1500;  1500 + 10% = 1650