@@ -209,7 +209,7 @@ if err != nil {
 		panic(err)
 	}
 	// L2DB
-	l2DB := l2db.NewL2DB(database, database, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
+	l2DB := l2db.NewL2DB(database, database, 10, 1000, 0.0, 1000.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB()) // this will clean HistoryDB and L2DB
 	// Config (smart contract constants)
 	chainID := uint16(0)
@@ -240,6 +240,7 @@ }
 	nodeConfig := &historydb.NodeConfig{
 		MaxPoolTxs: 10,
 		MinFeeUSD:  0,
+		MaxFeeUSD:  10000000000,
 	}
 	if err := hdb.SetNodeConfig(nodeConfig); err != nil {
 		panic(err)
@@ -615,7 +616,7 @@ apiConnConTO := db.NewAPIConnectionController(1, 100*time.Millisecond)
 	hdbTO := historydb.NewHistoryDB(databaseTO, databaseTO, apiConnConTO)
 	require.NoError(t, err)
 	// L2DB
-	l2DBTO := l2db.NewL2DB(databaseTO, databaseTO, 10, 1000, 1.0, 24*time.Hour, apiConnConTO)
+	l2DBTO := l2db.NewL2DB(databaseTO, databaseTO, 10, 1000, 1.0, 1000.0, 24*time.Hour, apiConnConTO)
 
 	// API
 	apiGinTO := gin.Default()

@@ -145,8 +145,8 @@ require.NoError(t, err)
 	assert.Greater(t, ni.StateAPI.Metrics.TransactionsPerBatch, float64(0))
 	assert.Greater(t, ni.StateAPI.Metrics.BatchFrequency, float64(0))
 	assert.Greater(t, ni.StateAPI.Metrics.TransactionsPerSecond, float64(0))
-	assert.Greater(t, ni.StateAPI.Metrics.TotalAccounts, int64(0))
-	assert.Greater(t, ni.StateAPI.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.TokenAccounts, int64(0))
+	assert.Greater(t, ni.StateAPI.Metrics.Wallets, int64(0))
 	assert.Greater(t, ni.StateAPI.Metrics.AvgTransactionFee, float64(0))
 }
 
@@ -210,8 +210,8 @@ // TODO: perform real asserts (not just greater than 0)
 	assert.Greater(t, status.Metrics.TransactionsPerBatch, float64(0))
 	assert.Greater(t, status.Metrics.BatchFrequency, float64(0))
 	assert.Greater(t, status.Metrics.TransactionsPerSecond, float64(0))
-	assert.Greater(t, status.Metrics.TotalAccounts, int64(0))
-	assert.Greater(t, status.Metrics.TotalBJJs, int64(0))
+	assert.Greater(t, status.Metrics.TokenAccounts, int64(0))
+	assert.Greater(t, status.Metrics.Wallets, int64(0))
 	assert.Greater(t, status.Metrics.AvgTransactionFee, float64(0))
 	// Recommended fee
 	// TODO: perform real asserts (not just greater than 0)

@@ -2569,9 +2569,9 @@ type: array
       description: List of next coordinators to forge.
       items: 
         $ref: '#/components/schemas/NextForger'
-    NodeConfig:
+    Node:
       type: object
-      description: Configuration of the coordinator node. Note that this is specific for each coordinator.
+      description: Configuration and metrics of the coordinator node. Note that this is specific for each coordinator.
       properties:
         forgeDelay:
           type: number
@@ -2581,9 +2581,14 @@ already committed. If set to 0s, the coordinator will continuously
             forge at the maximum rate. Note that this is a configuration parameter of a node,
             so each coordinator may have a different value.
           example: 193.4
+        poolLoad:
+          type: number
+          description: Number of pending transactions in the pool
+          example: 23201
       additionalProperties: false
       required: 
         - forgeDelay
+        - poolLoad
     State:
       type: object
       description: Gobal variables of the network
@@ -2600,8 +2605,8 @@ withdrawalDelayer:
           $ref: '#/components/schemas/StateWithdrawDelayer'
         recommendedFee:
           $ref: '#/components/schemas/RecommendedFee'
-        nodeConfig:
-          $ref: '#/components/schemas/NodeConfig'
+        node:
+          $ref: '#/components/schemas/Node'
       additionalProperties: false
       required: 
         - network
@@ -2610,7 +2615,7 @@ - rollup
         - auction
         - withdrawalDelayer
         - recommendedFee
-        - nodeConfig
+        - node
     StateNetwork:
       type: object
       description: Gobal statistics of the network
@@ -2813,11 +2818,11 @@ transactionsPerSecond:
           type: number
           description: Average transactions per second in the last 24 hours.
           example: 302.3
-        totalAccounts:
+        tokenAccounts:
           type: integer
           description: Number of created accounts.
           example: 90473
-        totalBJJs:
+        wallets:
           type: integer
           description: Number of different registered BJJs.
           example: 23067
@@ -2834,8 +2839,8 @@ required:
         - transactionsPerBatch
         - batchFrequency
         - transactionsPerSecond
-        - totalAccounts
-        - totalBJJs
+        - tokenAccounts
+        - wallets
         - avgTransactionFee
         - estimatedTimeToForgeL1
     PendingItems:

@@ -99,6 +99,7 @@ [Coordinator.L2DB]
 SafetyPeriod = 10
 MaxTxs       = 512
 MinFeeUSD    = 0.0
+MaxFeeUSD    = 50.0
 TTL          = "24h"
 PurgeBatchDelay = 10
 InvalidateBatchDelay = 20

@@ -318,6 +318,7 @@ dbRead, dbWrite,
 		cfg.Coordinator.L2DB.SafetyPeriod,
 		cfg.Coordinator.L2DB.MaxTxs,
 		cfg.Coordinator.L2DB.MinFeeUSD,
+		cfg.Coordinator.L2DB.MaxFeeUSD,
 		cfg.Coordinator.L2DB.TTL.Duration,
 		nil,
 	)

@@ -144,6 +144,10 @@ // MinFeeUSD is the minimum fee in USD that a tx must pay in
 		// order to be accepted into the pool.  Txs with lower than
 		// minimum fee will be rejected at the API level.
 		MinFeeUSD float64
+		// MaxFeeUSD is the maximum fee in USD that a tx must pay in
+		// order to be accepted into the pool.  Txs with greater than
+		// maximum fee will be rejected at the API level.
+		MaxFeeUSD float64 `validate:"required"`
 		// TTL is the Time To Live for L2Txs in the pool.  Once MaxTxs
 		// L2Txs is reached, L2Txs older than TTL will be deleted.
 		TTL Duration `validate:"required"`
@@ -376,6 +380,10 @@ // MinFeeUSD is the minimum fee in USD that a tx must pay in
 			// order to be accepted into the pool.  Txs with lower than
 			// minimum fee will be rejected at the API level.
 			MinFeeUSD float64
+			// MaxFeeUSD is the maximum fee in USD that a tx must pay in
+			// order to be accepted into the pool.  Txs with greater than
+			// maximum fee will be rejected at the API level.
+			MaxFeeUSD float64 `validate:"required"`
 		} `validate:"required"`
 	}
 	Debug NodeDebug `validate:"required"`

@@ -105,7 +105,7 @@ pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 	historyDB := historydb.NewHistoryDB(db, db, nil)
 
 	txSelDBPath, err = ioutil.TempDir("", "tmpTxSelDB")

@@ -21,7 +21,7 @@ pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
 	test.WipeDB(db)
-	return l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	return l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 }
 
 func newStateDB(t *testing.T) *statedb.LocalStateDB {

@@ -1083,12 +1083,8 @@ return nextForgers, nil
 }
 
 // GetMetricsInternalAPI returns the MetricsAPI
-func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (*MetricsAPI, error) {
-	var metrics MetricsAPI
-	// Get the first and last batch of the last 24h and their timestamps
-	// if u.state.Network.LastBatch == nil {
-	// 	return &metrics, nil
-	// }
+func (hdb *HistoryDB) GetMetricsInternalAPI(lastBatchNum common.BatchNum) (metrics *MetricsAPI, poolLoad int64, err error) {
+	metrics = &MetricsAPI{}
 	type period struct {
 		FromBatchNum  common.BatchNum `meddler:"from_batch_num"`
 		FromTimestamp time.Time       `meddler:"from_timestamp"`
@@ -1106,7 +1102,7 @@ COALESCE (MAX(block.timestamp), NOW()) AS to_timestamp
 			FROM batch INNER JOIN block ON batch.eth_block_num = block.eth_block_num
 			WHERE block.timestamp >= NOW() - INTERVAL '24 HOURS';`,
 	); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	// Get the amount of txs of that period
 	row := hdb.dbRead.QueryRow(
@@ -1115,7 +1111,7 @@ p.FromBatchNum, p.ToBatchNum,
 	)
 	var nTxs int
 	if err := row.Scan(&nTxs); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	// Set txs/s
 	seconds := p.ToTimestamp.Sub(p.FromTimestamp).Seconds()
@@ -1141,7 +1137,7 @@ p.FromBatchNum, p.ToBatchNum,
 	)
 	var totalFee float64
 	if err := row.Scan(&totalFee); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	// Set batch frequency
 	metrics.BatchFrequency = seconds / float64(nBatches)
@@ -1152,7 +1148,7 @@ p.FromBatchNum, p.ToBatchNum,
 	)
 	var nL2Txs int
 	if err := row.Scan(&nL2Txs); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	if nL2Txs > 0 {
 		metrics.AvgTransactionFee = totalFee / float64(nL2Txs)
@@ -1161,18 +1157,18 @@ metrics.AvgTransactionFee = 0
 	}
 	// Get and set amount of registered accounts
 	type registeredAccounts struct {
-		TotalIdx int64 `meddler:"total_idx"`
-		TotalBJJ int64 `meddler:"total_bjj"`
+		TokenAccounts int64 `meddler:"token_accounts"`
+		Wallets       int64 `meddler:"wallets"`
 	}
 	ra := &registeredAccounts{}
 	if err := meddler.QueryRow(
 		hdb.dbRead, ra,
-		`SELECT COUNT(*) AS total_bjj, COUNT(DISTINCT(bjj)) AS total_idx FROM account;`,
+		`SELECT COUNT(*) AS token_accounts, COUNT(DISTINCT(bjj)) AS wallets FROM account;`,
 	); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
-	metrics.TotalAccounts = ra.TotalIdx
-	metrics.TotalBJJs = ra.TotalBJJ
+	metrics.TokenAccounts = ra.TokenAccounts
+	metrics.Wallets = ra.Wallets
 	// Get and set estimated time to forge L1 tx
 	row = hdb.dbRead.QueryRow(
 		`SELECT COALESCE (AVG(EXTRACT(EPOCH FROM (forged.timestamp - added.timestamp))), 0) FROM tx
@@ -1184,10 +1180,18 @@ p.FromBatchNum, p.ToBatchNum,
 	)
 	var timeToForgeL1 float64
 	if err := row.Scan(&timeToForgeL1); err != nil {
-		return nil, tracerr.Wrap(err)
+		return nil, 0, tracerr.Wrap(err)
 	}
 	metrics.EstimatedTimeToForgeL1 = timeToForgeL1
-	return &metrics, nil
+	// Get amount of txs in the pool
+	row = hdb.dbRead.QueryRow(
+		`SELECT COUNT(*) FROM tx_pool WHERE state = $1 AND NOT external_delete;`,
+		common.PoolL2TxStatePending,
+	)
+	if err := row.Scan(&poolLoad); err != nil {
+		return nil, 0, tracerr.Wrap(err)
+	}
+	return metrics, poolLoad, nil
 }
 
 // GetStateAPI returns the StateAPI

@@ -1181,7 +1181,7 @@ CreateAccountInternalExtraFeePercentage float64 = 2.0
 )
 
 // GetRecommendedFee returns the RecommendedFee information
-func (hdb *HistoryDB) GetRecommendedFee(minFeeUSD float64) (*common.RecommendedFee, error) {
+func (hdb *HistoryDB) GetRecommendedFee(minFeeUSD, maxFeeUSD float64) (*common.RecommendedFee, error) {
 	var recommendedFee common.RecommendedFee
 	// Get total txs and the batch of the first selected tx of the last hour
 	type totalTxsSinceBatchNum struct {
@@ -1217,11 +1217,11 @@ avgTransactionFee = tbf.TotalFees / float64(ttsbn.TotalTxs)
 	} else {
 		avgTransactionFee = 0
 	}
-	recommendedFee.ExistingAccount =
-		math.Max(avgTransactionFee, minFeeUSD)
-	recommendedFee.CreatesAccount =
-		math.Max(CreateAccountExtraFeePercentage*avgTransactionFee, minFeeUSD)
-	recommendedFee.CreatesAccountInternal =
-		math.Max(CreateAccountInternalExtraFeePercentage*avgTransactionFee, minFeeUSD)
+	recommendedFee.ExistingAccount = math.Min(maxFeeUSD,
+		math.Max(avgTransactionFee, minFeeUSD))
+	recommendedFee.CreatesAccount = math.Min(maxFeeUSD,
+		math.Max(CreateAccountExtraFeePercentage*avgTransactionFee, minFeeUSD))
+	recommendedFee.CreatesAccountInternal = math.Min(maxFeeUSD,
+		math.Max(CreateAccountInternalExtraFeePercentage*avgTransactionFee, minFeeUSD))
 	return &recommendedFee, nil
 }

@@ -1177,7 +1177,7 @@ err = historyDB.AddBlockSCData(&blocks[i])
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDB.GetMetricsInternalAPI(common.BatchNum(numBatches))
+	res, _, err := historyDB.GetMetricsInternalAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
 	assert.Equal(t, float64(numTx)/float64(numBatches), res.TransactionsPerBatch)
@@ -1186,8 +1186,8 @@ // Frequency is not exactly the desired one, some decimals may appear
 	// There is a -2 as time for first and last batch is not taken into account
 	assert.InEpsilon(t, float64(frequency)*float64(numBatches-2)/float64(numBatches), res.BatchFrequency, 0.01)
 	assert.InEpsilon(t, float64(numTx)/float64(frequency*blockNum-frequency), res.TransactionsPerSecond, 0.01)
-	assert.Equal(t, int64(3), res.TotalAccounts)
-	assert.Equal(t, int64(3), res.TotalBJJs)
+	assert.Equal(t, int64(3), res.TokenAccounts)
+	assert.Equal(t, int64(3), res.Wallets)
 	// Til does not set fees
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
@@ -1255,22 +1255,22 @@ err = historyDB.AddBlockSCData(&blocks[i])
 		assert.NoError(t, err)
 	}
 
-	res, err := historyDBWithACC.GetMetricsInternalAPI(common.BatchNum(numBatches))
+	res, _, err := historyDBWithACC.GetMetricsInternalAPI(common.BatchNum(numBatches))
 	assert.NoError(t, err)
 
 	assert.InEpsilon(t, 1.0, res.TransactionsPerBatch, 0.1)
 
 	assert.InEpsilon(t, res.BatchFrequency, float64(blockTime/time.Second), 0.1)
 	assert.InEpsilon(t, 1.0/float64(blockTime/time.Second), res.TransactionsPerSecond, 0.1)
-	assert.Equal(t, int64(3), res.TotalAccounts)
-	assert.Equal(t, int64(3), res.TotalBJJs)
+	assert.Equal(t, int64(3), res.TokenAccounts)
+	assert.Equal(t, int64(3), res.Wallets)
 	// Til does not set fees
 	assert.Equal(t, float64(0), res.AvgTransactionFee)
 }
 
 func TestGetMetricsAPIEmpty(t *testing.T) {
 	test.WipeDB(historyDB.DB())
-	_, err := historyDBWithACC.GetMetricsInternalAPI(0)
+	_, _, err := historyDBWithACC.GetMetricsInternalAPI(0)
 	assert.NoError(t, err)
 }
 
@@ -1485,7 +1485,7 @@ var i64 int64 = 8888
 	addr := ethCommon.HexToAddress("0x1234")
 	hash := ethCommon.HexToHash("0x5678")
 	stateAPI := &StateAPI{
-		NodePublicConfig: NodePublicConfig{
+		NodePublicInfo: NodePublicInfo{
 			ForgeDelay: 3.1,
 		},
 		Network: NetworkAPI{
@@ -1544,7 +1544,7 @@ },
 		},
 		Metrics: MetricsAPI{
 			TransactionsPerBatch: 1.1,
-			TotalAccounts:        42,
+			TokenAccounts:        42,
 		},
 		Rollup:            *NewRollupVariablesAPI(clientSetup.RollupVariables),
 		Auction:           *NewAuctionVariablesAPI(clientSetup.AuctionVariables),

@@ -35,16 +35,17 @@ NextForgers   []NextForgerAPI `json:"nextForgers"`
 	PendingL1Txs  int             `json:"pendingL1Transactions"`
 }
 
-// NodePublicConfig is the configuration of the node that is exposed via API
-type NodePublicConfig struct {
+// NodePublicInfo is the configuration and metrics of the node that is exposed via API
+type NodePublicInfo struct {
 	// ForgeDelay in seconds
 	ForgeDelay float64 `json:"forgeDelay"`
+	// PoolLoad amount of transactions in the pool
+	PoolLoad int64 `json:"poolLoad"`
 }
 
 // StateAPI is an object representing the node and network state exposed via the API
 type StateAPI struct {
-	// NodePublicConfig is the configuration of the node that is exposed via API
-	NodePublicConfig  NodePublicConfig         `json:"nodeConfig"`
+	NodePublicInfo    NodePublicInfo           `json:"node"`
 	Network           NetworkAPI               `json:"network"`
 	Metrics           MetricsAPI               `json:"metrics"`
 	Rollup            RollupVariablesAPI       `json:"rollup"`
@@ -64,6 +65,7 @@ // NodeConfig contains the node config exposed in the API
 type NodeConfig struct {
 	MaxPoolTxs uint32
 	MinFeeUSD  float64
+	MaxFeeUSD  float64
 	ForgeDelay float64
 }
 

@@ -314,8 +314,8 @@ type MetricsAPI struct {
 	TransactionsPerBatch   float64 `json:"transactionsPerBatch"`
 	BatchFrequency         float64 `json:"batchFrequency"`
 	TransactionsPerSecond  float64 `json:"transactionsPerSecond"`
-	TotalAccounts          int64   `json:"totalAccounts" meddler:"total_accounts"`
-	TotalBJJs              int64   `json:"totalBJJs" meddler:"total_bjjs"`
+	TokenAccounts          int64   `json:"tokenAccounts"`
+	Wallets                int64   `json:"wallets"`
 	AvgTransactionFee      float64 `json:"avgTransactionFee"`
 	EstimatedTimeToForgeL1 float64 `json:"estimatedTimeToForgeL1" meddler:"estimated_time_to_forge_l1"`
 }

@@ -62,6 +62,10 @@ if feeUSD < l2db.minFeeUSD {
 		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) < minFeeUSD (%v)",
 			feeUSD, l2db.minFeeUSD))
 	}
+	if feeUSD > l2db.maxFeeUSD {
+		return tracerr.Wrap(fmt.Errorf("tx.feeUSD (%v) > maxFeeUSD (%v)",
+			feeUSD, l2db.maxFeeUSD))
+	}
 
 	// Prepare insert SQL query argument parameters
 	namesPart, err := meddler.Default.ColumnsQuoted(tx, false)

@@ -27,6 +27,7 @@ safetyPeriod common.BatchNum
 	ttl          time.Duration
 	maxTxs       uint32 // limit of txs that are accepted in the pool
 	minFeeUSD    float64
+	maxFeeUSD    float64
 	apiConnCon   *db.APIConnectionController
 }
 
@@ -38,6 +39,7 @@ dbRead, dbWrite *sqlx.DB,
 	safetyPeriod common.BatchNum,
 	maxTxs uint32,
 	minFeeUSD float64,
+	maxFeeUSD float64,
 	TTL time.Duration,
 	apiConnCon *db.APIConnectionController,
 ) *L2DB {
@@ -48,6 +50,7 @@ safetyPeriod: safetyPeriod,
 		ttl:          TTL,
 		maxTxs:       maxTxs,
 		minFeeUSD:    minFeeUSD,
+		maxFeeUSD:    maxFeeUSD,
 		apiConnCon:   apiConnCon,
 	}
 }

@@ -37,9 +37,9 @@ db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	if err != nil {
 		panic(err)
 	}
-	l2DB = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, nil)
+	l2DB = NewL2DB(db, db, 10, 1000, 0.0, 1000.0, 24*time.Hour, nil)
 	apiConnCon := dbUtils.NewAPIConnectionController(1, time.Second)
-	l2DBWithACC = NewL2DB(db, db, 10, 1000, 0.0, 24*time.Hour, apiConnCon)
+	l2DBWithACC = NewL2DB(db, db, 10, 1000, 0.0, 1000.0, 24*time.Hour, apiConnCon)
 	test.WipeDB(l2DB.DB())
 	historyDB = historydb.NewHistoryDB(db, db, nil)
 	// Run tests

@@ -230,6 +230,7 @@ dbRead, dbWrite,
 			cfg.Coordinator.L2DB.SafetyPeriod,
 			cfg.Coordinator.L2DB.MaxTxs,
 			cfg.Coordinator.L2DB.MinFeeUSD,
+			cfg.Coordinator.L2DB.MaxFeeUSD,
 			cfg.Coordinator.L2DB.TTL.Duration,
 			apiConnCon,
 		)
@@ -253,6 +254,7 @@
 	hdbNodeCfg := historydb.NodeConfig{
 		MaxPoolTxs: cfg.Coordinator.L2DB.MaxTxs,
 		MinFeeUSD:  cfg.Coordinator.L2DB.MinFeeUSD,
+		MaxFeeUSD:  cfg.Coordinator.L2DB.MaxFeeUSD,
 		ForgeDelay: cfg.Coordinator.ForgeDelay.Duration.Seconds(),
 	}
 	if err := historyDB.SetNodeConfig(&hdbNodeCfg); err != nil {
@@ -522,6 +524,7 @@ dbRead, dbWrite,
 			0,
 			cfg.Coordinator.L2DB.MaxTxs,
 			cfg.Coordinator.L2DB.MinFeeUSD,
+			cfg.Coordinator.L2DB.MaxFeeUSD,
 			0,
 			apiConnCon,
 		)

@@ -27,7 +27,7 @@ hdb:    hdb,
 		config: *config,
 		consts: *consts,
 		state: historydb.StateAPI{
-			NodePublicConfig: historydb.NodePublicConfig{
+			NodePublicInfo: historydb.NodePublicInfo{
 				ForgeDelay: config.ForgeDelay,
 			},
 		},
@@ -65,7 +65,7 @@ }
 
 // UpdateRecommendedFee update Status.RecommendedFee information
 func (u *Updater) UpdateRecommendedFee() error {
-	recommendedFee, err := u.hdb.GetRecommendedFee(u.config.MinFeeUSD)
+	recommendedFee, err := u.hdb.GetRecommendedFee(u.config.MinFeeUSD, u.config.MaxFeeUSD)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
@@ -84,12 +84,13 @@ if lastBatch == nil {
 		return nil
 	}
 	lastBatchNum := lastBatch.BatchNum
-	metrics, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
+	metrics, poolLoad, err := u.hdb.GetMetricsInternalAPI(lastBatchNum)
 	if err != nil {
 		return tracerr.Wrap(err)
 	}
 	u.rw.Lock()
 	u.state.Metrics = *metrics
+	u.state.NodePublicInfo.PoolLoad = poolLoad
 	u.rw.Unlock()
 	return nil
 }

@@ -323,7 +323,7 @@ // Clear DB
 	test.WipeDB(historyDB.DB())
 
 	// Init L2 DB
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 
 	return stateDB, historyDB, l2DB
 }

@@ -77,7 +77,7 @@ coordUser *til.User) (*txselector.TxSelector, *l2db.L2DB, *statedb.StateDB) {
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpSyncDB")
 	require.NoError(t, err)

@@ -30,7 +30,7 @@ coordUser *til.User) *TxSelector {
 	pass := os.Getenv("POSTGRES_PASS")
 	db, err := dbUtils.InitSQLDB(5432, "localhost", "hermez", pass, "hermez")
 	require.NoError(t, err)
-	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 24*time.Hour, nil)
+	l2DB := l2db.NewL2DB(db, db, 10, 100, 0.0, 1000.0, 24*time.Hour, nil)
 
 	dir, err := ioutil.TempDir("", "tmpdb")
 	require.NoError(t, err)